},
		"secure, no roots": {
			TLSConfig:   &tls.Config{InsecureSkipVerify: false},
			ExpectError: "unknown authority|not trusted",
		},
		"secure with roots": {
			TLSConfig: &tls.Config{InsecureSkipVerify: false, RootCAs: roots},
		},
		"secure with mismatched server": {
			TLSConfig:   &tls.Config{InsecureSkipVerify: false, RootCAs: roots, ServerName: "bogus.com"},
			ExpectError: "not bogus.com",

            throw UnsupportedOperationException()

        override fun visitFileTree(root: File, patterns: PatternSet, fileTree: FileTreeInternal) {
            roots.add(DirectoryTreeSpec(root, patterns))
        }

        override fun visitFileTreeBackedByFile(file: File, fileTree: FileTreeInternal, sourceTree: FileSystemMirroringFileTree) {
            roots.add(toSpec(sourceTree))
        }
    }

    private

    List<BuildOperationRecord> getRoots() {
        operations.roots
    }

    @Override
    @SuppressWarnings("GrUnnecessaryPublicModifier")
    public <T extends BuildOperationType<?, ?>> BuildOperationRecord root(Class<T> type, Spec<? super BuildOperationRecord> predicate = Specs.satisfyAll()) {
        def detailsType = BuildOperationTypes.detailsType(type)
        def roots = operations.roots.findAll {

            return SnapshotVisitResult.CONTINUE;
        }
    };

    /**
     * Returns a stream of roots.
     */
    Stream<FileSystemLocationSnapshot> roots();

    /**
     * Walks the whole hierarchy represented by this snapshot.
     *
     * The walk is depth first.
     */

    String COMPILE_CLASSPATH_IDENTIFIER = "COMPILE_CLASSPATH";

    /**
     * Converts the roots into the {@link FileSystemLocationFingerprint}s used by the {@link FileCollectionFingerprint}.
     */
    Map<String, FileSystemLocationFingerprint> collectFingerprints(FileSystemSnapshot roots);

    /**

-----END CERTIFICATE-----`

	// First, create the set of root certificates. For this example we only
	// have one. It's also possible to omit this in order to use the
	// default root set of the current operating system.
	roots := x509.NewCertPool()
	ok := roots.AppendCertsFromPEM([]byte(rootPEM))
	if !ok {
		panic("failed to parse root certificate")
	}

	block, _ := pem.Decode([]byte(certPEM))
	if block == nil {

        List<DependentBinariesResolvedResult> roots = new ArrayList<>();
        for (DependentBinariesResolutionStrategy strategy : strategies.values()) {
            DependentBinariesResolutionResult result = strategy.resolve(target);
            roots.add(result.getRoot());
        }
        return new DefaultDependentBinariesResolutionResult(mergeResults(roots));
    }

    }

    public static ImmutableListMultimap<String, HashCode> getRootHashes(FileSystemSnapshot roots) {
        if (roots == FileSystemSnapshot.EMPTY) {
            return ImmutableListMultimap.of();
        }
        ImmutableListMultimap.Builder<String, HashCode> builder = ImmutableListMultimap.builder();
        roots.accept(snapshot -> {
            builder.put(snapshot.getAbsolutePath(), snapshot.getHash());

     */
    public fun addBinaryRoot(root: Path) {
        binaryRoots.add(root)
    }

    /**
     * Adds a collection of [roots] to the current library.
     *
     * See [addBinaryRoot] for details
     *
     * @see addBinaryRoot for details
     */
    public fun addBinaryRoots(roots: Collection<Path>) {
        binaryRoots.addAll(roots)
    }

			}

			certFiles, certDirectories = tc.files, tc.dirs

			r, err := loadSystemRoots()
			if err != nil {
				t.Fatal("unexpected failure:", err)
			}

			if r == nil {
				t.Fatal("nil roots")
			}

			// Verify that the returned certs match, otherwise report where the mismatch is.
			for i, cn := range tc.cns {
				if i >= r.len() {
					t.Errorf("missing cert %v @ %v", cn, i)