rootVs := root.Spec.(*networking.VirtualService)
		mergedRoutes := []*networking.HTTPRoute{}
		for _, route := range rootVs.Http {
			// it is root vs with delegate
			if delegate := route.Delegate; delegate != nil {
				delegateNamespace := delegate.Namespace
				if delegateNamespace == "" {
					delegateNamespace = root.Namespace
				}

- 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)
  - Suppose the VCS root you just create is `MyNewVcsRoot`. Set "default branch" to `myTestBranch` where your code exists.

# 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.

Dependencies found in the `implementation` configuration will, on the other hand, not be exposed to consumers, and therefore not leak into the consumer's compile include root and link libraries.
This comes with several benefits:

        if (sourceRoots.isEmpty()) {
            throw new InvalidUserDataException("Unable to infer source roots. Incremental Groovy compilation requires the source roots. Change the configuration of your sources or disable incremental Groovy compilation.");
        }

        if (annotationProcessingConfigured) {

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.
! go get -t example.net/testonly@v0.1.0

        calculateRoots(files)
    }

    List<File> files(String... paths) {
        paths.collect { new File("/", it).absoluteFile }
    }

    def "can find roots when leafs are directories"() {
        expect:
        toRoots([]) == []
        toRoots(files("a/a", "a/a")) == files("a/a")
        toRoots(files("a", "b", "c")) == files("a", "b", "c")

            return rebuildAllCompiler.execute(spec);
        }
        if (spec.getSourceRoots().isEmpty()) {
            LOG.info("Full recompilation is required because the source roots could not be inferred.");
            return rebuildAllCompiler.execute(spec);
        }

        Timer clock = Time.startTimer();

			certMap: map[string][]string{"foo.domain.com": {validRootCert}},
		},
		{
			name:    "Successful validation with multiple roots",
			certMap: map[string][]string{"foo.domain.com": {validRootCert, validRootCert2}},
		},
		{
			name: "Successful validation with multiple roots multiple mappings",
			certMap: map[string][]string{
				"foo.domain.com": {validRootCert, validRootCert2},
				"bar.domain.com": {validRootCert2},