t.Run(tt.name, func(t *testing.T) {
			gotArn, err := Parse(tt.args.arnStr)
			if err == nil && tt.wantErr {
				t.Errorf("Parse() error = %v, wantErr %v", err, tt.wantErr)
			}
			if err != nil && !tt.wantErr {
				t.Errorf("Parse() error = %v, wantErr %v", err, tt.wantErr)
			}
			if err == nil {
				if !reflect.DeepEqual(gotArn, tt.wantArn) {
					t.Errorf("Parse() gotArn = %v, want %v", gotArn, tt.wantArn)
				}
			}

exec ./print_abspath$GOEXE
stdout $WORK[/\\]gopath[/\\]src[/\\]m[/\\]printpath[/\\]main.go

go build -overlay overlay.json -o print_trimpath$GOEXE -trimpath ./printpath
exec ./print_trimpath$GOEXE
stdout ^m[/\\]printpath[/\\]main.go

go build -overlay overlay.json -o print_trimpath_two_files$GOEXE printpath/main.go printpath/other.go
exec ./print_trimpath_two_files$GOEXE
stdout $WORK[/\\]gopath[/\\]src[/\\]m[/\\]printpath[/\\]main.go

cmp vendor/example.com/q/q.go q1_1_0/q.go
go list -m -f '{{.Version}}' example.com/q
stdout '^v1.1.0$'

go list -f '{{.Dir}}' example.com/q
stdout $GOPATH[\\/]src[\\/]vendor[\\/]example.com[\\/]q
go list -f '{{.Dir}}' example.com/b
stdout $GOPATH[\\/]src[\\/]vendor[\\/]example.com[\\/]b

[short] skip

rm b
rm q1_0_0
rm q1_1_0
go run example.com/p
stdout 'version 1.1.0'

-- modules.txt.want --

.PHONY: $(PHONYS)
$(PHONYS):
	@$(MAKE_DOCKER) $@
endif

# istioctl-install builds then installs istioctl into $GOPATH/BIN
# Used for debugging istioctl during dev work
.PHONY: istioctl-install
istioctl-install: istioctl-install-container

// displayed when an error happens.
func Init(goPath string, goRoot string) {
	var goPathList []string
	var goRootList []string
	var defaultgoPathList []string
	var defaultgoRootList []string
	pathSeparator := ":"
	// Add all possible GOPATH paths into trimStrings
	// Split GOPATH depending on the OS type
	if runtime.GOOS == "windows" {
		pathSeparator = ";"
	}

//go:build ignore
package main

import (
    "fmt"
    "os"
)

func main() {
    work := os.Getenv("WORK")
fmt.Printf(`module example.com/mod

require b.com v0.0.0

replace b.com => %s\gopath\src/modb
`,  work)
}
-- a.go --
package a

import _ "b.com/b"
-- modb/go.mod --
module b.com
-- modb/b/b.go --

		} else {
			paths = append(paths, "\t($GOROOT not set)")
		}
		format = "\t%s (from $GOPATH)"
		for _, dir := range tried.gopath {
			paths = append(paths, fmt.Sprintf(format, dir))
			format = "\t%s"
		}
		if len(tried.gopath) == 0 {
			paths = append(paths, "\t($GOPATH not set. For more details see: 'go help gopath')")
		}
		return p, fmt.Errorf("cannot find package %q in any of:\n%s", path, strings.Join(paths, "\n"))

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'

				}
				d.scan <- Dir{importPath, dir, root.inModule}
			}
		}

	}
}

var testGOPATH = false // force GOPATH use for testing

// codeRoots returns the code roots to search for packages.
// In GOPATH mode this is GOROOT/src and GOPATH/src, with empty import paths.
// In module mode, this is each module root, with an import path set to its module path.
func codeRoots() []Dir {

func testGoLib(t *testing.T, iscgo bool) {
	t.Parallel()
	tmpdir, err := os.MkdirTemp("", "TestGoLib")
	if err != nil {
		t.Fatal(err)
	}
	defer os.RemoveAll(tmpdir)

	gopath := filepath.Join(tmpdir, "gopath")
	libpath := filepath.Join(gopath, "src", "mylib")

	err = os.MkdirAll(libpath, 0777)
	if err != nil {
		t.Fatal(err)
	}
	src := filepath.Join(libpath, "a.go")
	file, err := os.Create(src)