return missingSnapshotForAbsolutePath(relativePath.getAbsolutePath());
    }

    @Override
    public Stream<FileSystemLocationSnapshot> roots() {
        return Stream.of(this);
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) {
            return true;
        }

            cannotInferSourceRoots(fileTree);
        }

        @Override
        public void visitFileTree(File root, PatternSet patterns, FileTreeInternal fileTree) {
            // We need to add missing files as source roots, since the package name for deleted files provided by InputChanges also need to be determined.
            if (!root.exists() || root.isDirectory()) {
                sourceRoots.add(root);
            } else {

	// has not .go files)
	BaseDir string `yaml:"baseImportPath"`
	// IgnoredSubTrees are roots of sub-trees of the BaseDir for which we do
	// not want to enforce any import restrictions whatsoever, given as
	// relative paths from the root of the repository.
	IgnoredSubTrees []string `yaml:"ignoredSubTrees,omitempty"`
	// AllowedImports are roots of package trees that are allowed to be

        """

        then:
        succeeds "t"
        def buildPaths = scopeIds.lastBuildPaths()
        buildPaths.size() == 2
    }

    def "different project roots have different workspace ids"() {
        when:
        file("a/settings.gradle") << ""
        file("b/settings.gradle") << ""
        succeeds("help", "-p", "a")
        succeeds("help", "-p", "b")

     * it is testing the fallback behavior of [SourcePathProvider]
     */
    @Test
    fun `given buildSrc folder, it will fallback to approximate buildSrc source roots`() {
        withFolders {
            "project" {
                "buildSrc/src/main" {
                    +"foo"
                    +"bar"
                }
            }
            "gradle" {

        SnapshotDiffListener NOOP = (removedSnapshots, addedSnapshots) -> {};

        /**
         * Called after the update to {@link SnapshotHierarchy} finished.
         *
         * Only the roots of added/removed hierarchies are reported.
         */
        void changed(Collection<FileSystemLocationSnapshot> removedSnapshots, Collection<FileSystemLocationSnapshot> addedSnapshots);
    }

test these changes without affecting `master`/`release` pipeline. Here are the instructions.

- Click the left sidebar "VCS Roots" here and create a VCS root [here](https://builds.gradle.org/admin/editProject.html?projectId=Gradle&cameFromUrl=%2Fproject.html%3FprojectId%3DGradle%26tab%3DprojectOverview%26branch_Gradle_Master_Check%3Dmaster)

# to the current version, converting the requirements from eager to lazy.
#
# Since we don't know which requirements are actually relevant to the main
# module, all requirements are added as roots, making the requirements untidy.

go list -mod=mod all
! stdout '^example.com/testdep$'
cmp stdout list-1.txt
cmpenv go.mod go.mod.untidy

go mod tidy
cmpenv go.mod go.mod.tidy

cp go.work.backup go.work

cp go.work.d go.work
go work use # update go version
go run example.com/d

# Test that we don't run into "newRequirements called with unsorted roots"
# panic with unsorted main modules.
cp go.work.backwards go.work
go work use # update go version
go run example.com/d

# Test that command-line-arguments work inside and outside modules.

! stderr .

! go build example.net/tools
stderr '^package example.net/tools: build constraints exclude all Go files in .*[/\\]tools$'


# https://golang.org/issue/29268
# 'go get' should fetch modules whose roots contain test-only packages, but
# without the -t flag shouldn't error out if the test has missing dependencies.

go get example.net/testonly@v0.1.0

# With the -t flag, the test dependencies must resolve successfully.