! 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$'

     * 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" {

 * [shouldBuildStubsForBinaryLibraries] is true. In Standalone mode, binary roots don't need to be specified because library symbols are
 * provided via class-based deserialization, not stub-based deserialization.
 *
 * @param binaryRoots Binary roots of the binary libraries that are specific to [project].
 * @param sharedBinaryRoots Binary roots that are shared between multiple different projects. This allows Kotlin tests to cache stubs for

        if (cacheableWork.shouldInvalidateOutputsBeforeLoad()) {
            ImmutableList.Builder<String> roots = ImmutableList.builder();
            cacheableWork.visitOutputTrees((name, type, root) -> roots.add(root.getAbsolutePath()));
            fileSystemAccess.invalidate(roots.build());
        }
        return buildCache.load(cacheKey, cacheableWork);
    }

     */
    @CheckReturnValue
    SnapshotHierarchy empty();

    CaseSensitivity getCaseSensitivity();

    /**
     * Returns all root snapshots in the hierarchy.
     */
    Stream<FileSystemLocationSnapshot> rootSnapshots();

    /**
     * Returns all root snapshots in the hierarchy below {@code absolutePath}.
     */
    Stream<FileSystemLocationSnapshot> rootSnapshotsUnder(String absolutePath);

    /**

		ctxt.loader.SetAttrLocal(ctxt.mainInittasks, true)
	case BuildModeShared:
		// For a shared library, all packages are roots.
		var roots []string
		for _, lib := range ctxt.Library {
			roots = append(roots, fmt.Sprintf("%s..inittask", objabi.PathToPrefix(lib.Pkg)))
		}
		ctxt.mainInittasks = ctxt.inittaskSym(roots, "go:shlib.inittasks")
		// Make symbol local so multiple plugins don't clobber each other's inittask list.

            result.assertTaskNotExecuted(":build-logic:classes")
        }
    }

    def "can exclude task from included build that is a dependency of the root build and also produces a project plugin used from root build"() {
        setup:
        settingsFile << "includeBuild('build-logic')"
        def rootDir = file("build-logic")
        addPluginIncludedBuild(rootDir)
        buildFile.text = """

     *
     * @return The name of the JDK.
     * @since 3.4
     */
    String getJdkName() throws UnsupportedMethodException;

    /**
     * All content roots. Most idea modules have a single content root.
     *
     * @return content roots
     * @since 1.0-milestone-5
     */
    DomainObjectSet<? extends IdeaContentRoot> getContentRoots();

    /**
     * The gradle project that is associated with this module.

# Regression test for https://golang.org/issue/47979:
#
# An argument to 'go get' that results in an upgrade to a different existing
# root should be allowed, and should not panic the 'go' command.

cp go.mod go.mod.orig


# Transitive upgrades from upgraded roots should not prevent
# 'go get -u' from performing upgrades.

cp go.mod.orig go.mod
go get -u .
cmp go.mod go.mod.want

cp go.mod $WORK/a/src/paths/
cp go.mod $WORK/b/src/paths/


# A binary built without -trimpath should contain the module root dir
# and GOROOT for debugging and stack traces.
cd $WORK/a/src/paths
go build -o $WORK/paths-dbg.exe .
exec $WORK/paths-dbg.exe $WORK/paths-dbg.exe
stdout 'binary contains module root: true'
stdout 'binary contains an empty GOROOT'

# A binary built with -trimpath should not contain the current workspace.