import org.gradle.test.fixtures.file.TestFile

class BuildActionCrossVersionSpec extends ToolingApiSpecification {
    @TargetGradleVersion(">=3.2")
    def "can use multiple action implementations with different classpath roots and loaded from same ClassLoader"() {
        settingsFile.text = 'rootProject.name = "not broken"'

        // Ensure daemon is reused
        toolingApi.requireIsolatedDaemons()

        }) == SnapshotVisitResult.CONTINUE;
    }

    private static Map<String, FileSystemLocationFingerprint> collectFingerprints(FileSystemSnapshot roots) {
        Map<String, FileSystemLocationFingerprint> result = new LinkedHashMap<>();
        roots.accept(new RelativePathTracker(),
            (snapshot, relativePath) -> {
                result.put(snapshot.getAbsolutePath(), createFingerprint(relativePath, snapshot));

		t.Skip()
	}
	if runtime.GOOS == "windows" {
		// NOTE(#51599): on the Windows builders we sometimes see that the state
		// of the root pool is not fully initialized, causing an expected
		// platform verification to fail. In part this is because Windows
		// dynamically populates roots into its local trust store at time of
		// use. We can attempt to prime the pool by attempting TLS connections

 */
public interface ExecutionOutputState {

    /**
     * Whether the execution was successful.
     */
    boolean isSuccessful();

    /**
     * Snapshots of the roots of output properties.
     *
     * In the presence of overlapping outputs this might be different from
     * {@link BeforeExecutionState#getOutputFileLocationSnapshots()},

	// funcs).
	haveSum map[sum224]bool

	// systemPool indicates whether this is a special pool derived from the
	// system roots. If it includes additional roots, it requires doing two
	// verifications, one using the roots provided by the caller, and one using
	// the system platform verifier.
	systemPool bool
}

// lazyCert is minimal metadata about a Cert and a func to retrieve it

         * <p>
         * Properties are visited depth-first lexicographical.
         * Roots are visited in semantic order (i.e. the order in which they make up the file collection)
         * Files and directories are depth-first lexicographical.
         * <p>
         * For roots that are a file, they are also visited with {@link #file(VisitState)}.
         */
        interface InputFilePropertyVisitor {

        /**
         * Whether any of the snapshot file collections is an archive tree backed by a file.
         */
        boolean containsArchiveTrees();
    }

    /**
     * Snapshot the roots of a file collection.
     */
    Result snapshot(FileCollection fileCollection);

    /**
     * {@inheritDoc}
     */
    @Override
    ImmutableSortedMap<String, CurrentFileCollectionFingerprint> getInputFileProperties();

    /**
     * Snapshots of the roots of output properties.
     *
     * This includes snapshots for the whole output {@link org.gradle.api.file.FileCollection}.
     *
     * @see PreviousExecutionState#getOutputFilesProducedByWork()

	"/etc/pki/tls/certs", // Fedora/RHEL
}

func init() {
	if goos.IsAndroid == 1 {
		certDirectories = append(certDirectories,
			"/system/etc/security/cacerts",    // Android system roots
			"/data/misc/keychain/certs-added", // User trusted CA folder
		)
	}

 * limitations under the License.
 */
package org.gradle.api.internal.file.collections;

/**
 * A file tree whose contents are contained in zero or more local roots (file or directory).
 */
public interface LocalFileTree extends MinimalFileTree {