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

! stdout '^x/fromotherroottest$'
! stdout '^y/fromotherdeptest$'

cmp go.mod go.mod.orig

# With -deps -test, test dependencies of other roots should be included,
# but test dependencies of non-roots should not.

go list -deps -test all x/otherroot
stdout '^x/inall$'
stdout '^x/inall/fromtest$'
stdout '^x/inall/fromtestinall$'
stdout '^x/otherroot$'
stdout '^x/otherdep$'

stdout '^x/fromotherroottest$'

// walk walks the trees in GOROOT and GOPATH.
func (d *Dirs) walk(roots []Dir) {
	for _, root := range roots {
		d.bfsWalkRoot(root)
	}
	close(d.scan)
}

// bfsWalkRoot walks a single directory hierarchy in breadth-first lexical order.
// Each Go source directory it finds is delivered on d.scan.
func (d *Dirs) bfsWalkRoot(root Dir) {
	root.dir = filepath.Clean(root.dir) // because filepath.Join will do it anyway

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