! go mod tidy

stderr '^go: example.com/untidy imports\n\texample.net/directnotfound: cannot find module providing package example.net/directnotfound: module example.net/directnotfound: reading http://.*: 404 Not Found$'

			if err != nil {
				t.Fatalf("error reading want: %v", err)
			}
			want := string(bytes.TrimSpace(wantData))

			imports, _, err := ScanDir(path.Join("testdata", dir.Name()), tags)
			if err != nil {
				t.Fatal(err)
			}
			got := strings.Join(imports, "\n")
			if got != want {
				t.Errorf("ScanDir: got imports:\n%s\n\nwant:\n%s", got, want)
			}
		})
	}

    final GreeterElement greeter
    final SwiftSum sum
    String[] imports = ['cppGreeter']

    SwiftMainWithCppDep(GreeterElement greeter) {
        this(greeter, new SwiftSum())
    }

    SwiftMainWithCppDep(GreeterElement greeter, String[] imports) {
        this(greeter, new SwiftSum())
        this.imports = imports
    }

    SwiftMainWithCppDep(GreeterElement greeter, SwiftSum sum) {

env GO111MODULE=off

# issue 26880: list with tests has wrong variant in imports
go list -test -f '{{.ImportPath}}:{{with .Imports}} {{join . ", "}}{{end}}' a b
cmp stdout imports.txt

-- a/a.go --
package a; import _ "b"
-- b/b.go --
package b
-- b/b_test.go --
package b
-- b/b_x_test.go --
package b_test; import _ "a"

-- imports.txt --
a: b
b:

// If pkg uses cgo and the FakeImportC configuration option
// was enabled, the imports list may contain a fake "C" package.
func (pkg *Package) Imports() []*Package { return pkg.imports }

// SetImports sets the list of explicitly imported packages to list.
// It is the caller's responsibility to make sure list elements are unique.
func (pkg *Package) SetImports(list []*Package) { pkg.imports = list }

func (pkg *Package) String() string {

    #set ( $types = { } )
    #set ( $imports = $class.getClass().forName("java.util.TreeSet").newInstance() )
    #set ( $dummy = $imports.add( "java.io.Serializable" ) )
    #set ( $dummy = $imports.add( "java.util.AbstractList" ) )
    #set ( $dummy = $imports.add( "java.util.Collections" ) )
    #set ( $dummy = $imports.add( "java.util.HashMap" ) )
    #set ( $dummy = $imports.add( "java.util.List" ) )

}

// forbiddenImportsFor determines all of the forbidden
// imports for a package given the import restrictions
// and returns a deduplicated list of them
func (i *ImportRestriction) forbiddenImportsFor(pkg Package) []string {
	forbiddenImportSet := map[string]struct{}{}
	imports := pkg.Imports
	if !i.ExcludeTests {
		imports = append(imports, append(pkg.TestImports, pkg.XTestImports...)...)
	}

interface Resolver {
    fun resolve(schema: AnalysisSchema, imports: List<Import>, topLevelBlock: Block): ResolutionResult
}


class ResolverImpl(
    private val codeAnalyzer: CodeAnalyzer,
    private val errorCollector: ErrorCollector,
    private val generationId: OperationGenerationId
) : Resolver {
    override fun resolve(schema: AnalysisSchema, imports: List<Import>, topLevelBlock: Block): ResolutionResult {

			imports = append(imports, metaImport{
				Prefix:   f[0],
				VCS:      f[1],
				RepoRoot: f[2],
			})
		}
	}

	// Extract mod entries if we are paying attention to them.
	var list []metaImport
	var have map[string]bool
	if mod == PreferMod {
		have = make(map[string]bool)
		for _, m := range imports {
			if m.VCS == "mod" {
				have[m.Prefix] = true

env GO111MODULE=off  # Relative imports only work in GOPATH mode.

[short] skip

# Imports should be resolved relative to the source file.
go build testdata/local/easy.go
exec ./easy$GOEXE
stdout '^easysub\.Hello'

# Ignored files should be able to import the package built from
# non-ignored files in the same directory.
go build -o easysub$GOEXE testdata/local/easysub/main.go
exec ./easysub$GOEXE
stdout '^easysub\.Hello'