testExecutionResult.assertTestPassed(testCase.getName());
            }
        }
    }

    public Set<String> getImports() {
        return imports;
    }

    public XCTestSourceFileElement withImport(String importName) {
        imports.add(importName);
        return this;
    }

    public Set<String> getTestableImports() {
        return testableImports;
    }

// other, mirroring the import dependencies. So if package p
// imports package q, then there will be a dependency p -> q.
// We can't initialize package p until after package q has
// already been initialized.
//
// Package dependencies are encoded with relocations. If package
// p imports package q, then package p's inittask record will
// have a R_INITORDER relocation pointing to package q's inittask

# In GOPATH mode, module legacy support does path rewriting very similar to vendoring.

env GO111MODULE=off

go list -f '{{range .Imports}}{{.}}{{"\n"}}{{end}}' old/p1
stdout ^new/p1$

go list -f '{{range .Imports}}{{.}}{{"\n"}}{{end}}' new/p1
stdout ^new/p2$           # not new/v2/p2
! stdout ^new/v2
stdout ^new/sub/x/v1/y$   # not new/sub/v2/x/v1/y
! stdout ^new/sub/v2
stdout ^new/sub/inner/x # not new/sub/v2/inner/x

go build old/p1 new/p1

packages" which are more sophisticated than Go's `internal` convention.

If inverse rules are found, then all known imports of the package are checked
against each such rule, in the same fashion as regular rules.  Note that this
can only handle known imports, which is defined as any package which is also
being considered by this `import-boss` run.  For most repositories, `./...` will
suffice.

Example:

# The linker loads implicit dependencies
go list -find -f {{.Deps}} ./cmd
stdout '\[\]'

# Cgo translation may add imports of "unsafe", "runtime/cgo" and "syscall"
go list -find -f {{.Deps}} ./cgo
stdout '\[\]'

# SWIG adds imports of some standard packages
go list -find -f {{.Deps}} ./swig
stdout '\[\]'

-- go.mod --
module listfind

-- cmd/main.go --
package main

		if p.Doc == "" && !isTest && !isXTest {
			if synopsis := tf.synopsis(); synopsis != "" {
				p.Doc = synopsis
			}
		}

		// Record Imports and information about cgo.
		isCgo := false
		imports := tf.imports()
		for _, imp := range imports {
			if imp.path == "C" {
				if isTest {
					badGoFile(name, fmt.Errorf("use of cgo in test %s not supported", name))
					continue
				}
				isCgo = true

# Regression test for https://go.dev/issue/51125:
# Relative import paths (a holdover from GOPATH) were accidentally allowed in module mode.

cd $WORK

# Relative imports should not be allowed with a go.mod file.

! go run driver.go
stderr '^driver.go:3:8: "./mypkg" is relative, but relative import paths are not supported in module mode$'

go list -e -f '{{with .Error}}{{.}}{{end}}' -deps driver.go

// errorcheck

// Copyright 2017 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Verify that invalid imports are rejected by the compiler.
// Does not compile.

package main

// Each of these pairs tests both `` vs "" strings
// and also use of invalid characters spelled out as
// escape sequences and written directly.

 */
trait DynamicGroovyPluginMixin {
    void withPluginCode(String imports, String codeUnderTest, boolean enableIndy) {
        file("buildSrc/src/main/groovy/SomePlugin.groovy") << """
            import ${Plugin.name}
            import ${Project.name}

            $imports

            class SomePlugin implements Plugin<Project> {
                void apply(Project project) {

import org.hamcrest.CoreMatchers.containsString
import org.hamcrest.MatcherAssert.assertThat
import org.junit.Test


class ImplicitImportsTest : AbstractKotlinIntegrationTest() {

    @Test
    fun `implicit imports are fully qualified to allow use of the preferred type amongst those with same simple name in different Gradle API packages`() {

        // given:
        withBuildScript(
            """