}

    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());

        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)
    }

    protected fun getBinaryRoots(): List<Path> = binaryRoots.distinct()

        1 * watchable.stream() >> Stream.of(parent, child, grandchild)
    }

    private static List<String> rootsOf(FileHierarchySet set) {
        def roots = []
        set.visitRoots((root -> roots.add(root)))
        return roots
    }

    def "uses ucrt found in registry"() {
        def dir1 = ucrtDir("ucrt", "10.0.10150.0")

        given:
        windowsRegistry.getStringValue(WindowsRegistry.Key.HKEY_LOCAL_MACHINE, /SOFTWARE\Microsoft\Windows Kits\Installed Roots/, "KitsRoot10") >> dir1.absolutePath

        when:
        def result = ucrtLocator.locateComponent(null)

        then:
        result.available
        result.component.name == "Universal C Runtime 10"

                    .addProgressListener(events).run()
        }

        then:
        println events.describeOperationsTree()
        def roots = events.operations.findAll { it.parent == null }
        roots.any { it.descriptor.name == 'Run build' }

        def orphans = roots.findAll { it.descriptor.name != 'Run build' }
        orphans.size() == 4

        List<String> roots;
        if (nonNull(scope, "scope") == ProjectScope.MAIN) {
            roots = prj.getCompileSourceRoots();
        } else if (scope == ProjectScope.TEST) {
            roots = prj.getTestCompileSourceRoots();
        } else {
            throw new IllegalArgumentException("Unsupported scope " + scope);
        }
        return roots.stream()
                .map(Paths::get)

		return nil, nil, fmt.Errorf("error when retrieving CA cert: (%v)", err)
	}
	// Verify the certificate chain before returning the certificate
	roots := x509.NewCertPool()
	if roots == nil {
		return nil, nil, fmt.Errorf("failed to create cert pool")
	}
	if ok := roots.AppendCertsFromPEM(caCert); !ok {
		return nil, nil, fmt.Errorf("failed to append CA certificate")
	}
	intermediates := x509.NewCertPool()

import org.gradle.internal.snapshot.SnapshotVisitResult;

import java.util.HashSet;

/**
 * A {@link RootTrackingFileSystemSnapshotHierarchyVisitor} that ignores missing roots and multiple entries for the same path.
 */
public abstract class MissingRootAndDuplicateIgnoringFileSystemSnapshotVisitor extends RootTrackingFileSystemSnapshotHierarchyVisitor {

class KotlinSettingsScriptModelCrossVersionSpec extends AbstractKotlinScriptModelCrossVersionTest {

    @LeaksFileHandles("Kotlin compiler daemon on buildSrc jar")
    def "sourcePath does not include buildSrc source roots"() {

        given:
        withKotlinBuildSrc()
        def settings = withDefaultSettings() << """
            include(":sub")
        """

        expect:
        assertThat(

    }

    @Override
    public Map<String, FileSystemLocationFingerprint> collectFingerprints(FileSystemSnapshot roots) {
        ImmutableMap.Builder<String, FileSystemLocationFingerprint> builder = ImmutableMap.builder();
        roots.accept(new MissingRootAndDuplicateIgnoringFileSystemSnapshotVisitor() {
            @Override