// license that can be found in the LICENSE file.

package main

import (
	"./pkg1"
	"./pkg2"
)

func main() {
	if pkg1.T != pkg2.T {
		panic("pkg1.T != pkg2.T")
	}
	if pkg1.U != pkg2.U {
		panic("pkg1.U != pkg2.U")
	}
	if pkg1.V != pkg2.V {
		panic("pkg1.V != pkg2.V")
	}
	if pkg1.W != pkg2.W {
		panic("pkg1.W != pkg2.W")
	}

func (opts *goTest) packages() []string {
	pkgs := opts.pkgs
	if opts.pkg != "" {
		pkgs = append(pkgs[:len(pkgs):len(pkgs)], opts.pkg)
	}
	if len(pkgs) == 0 {
		panic("no packages")
	}
	return pkgs
}

// printSkip prints a skip message for all of goTest.
func (opts *goTest) printSkip(t *tester, msg string) {
	if t.json {
		enc := json.NewEncoder(os.Stdout)
		for _, pkg := range opts.packages() {

module exmod

-- cmd/c1/main.go --
package main

func main() {}

-- cmd/c2/main.go --
package main

func main() {}

-- pkg1/pkg1.go --
package pkg1

-- pkg2/pkg2.go --
package pkg2

-- exec.go --
package main

func main() {}

-- c1$GOEXE/keep.txt --

	pkgs := load.PackagesAndErrors(ctx, load.PackageOpts{}, args)
	w := 0
	for _, pkg := range pkgs {
		if pkg.Error != nil {
			base.Errorf("%v", pkg.Error)
			continue
		}
		pkgs[w] = pkg
		w++
	}
	pkgs = pkgs[:w]

	printed := false
	for _, pkg := range pkgs {
		if modload.Enabled() && pkg.Module != nil && !pkg.Module.Main {
			if !printed {

}

func TestInverse(t *testing.T) {
	pkgs, err := loadPkgs("./testdata/inverse/...")
	if err != nil {
		t.Fatalf("unexpected failure: %v", err)
	}
	if len(pkgs) != 10 {
		t.Fatalf("expected 10 pkg results, got %d", len(pkgs))
	}

	boss := newBoss(pkgs)

	var errs []error
	for _, pkg := range pkgs {
		errs = append(errs, boss.Verify(pkg)...)
	}

	expect := []string{

	for {
		var pkg Pkg
		err := dec.Decode(&pkg)
		if err == io.EOF {
			break
		}
		if err != nil {
			return nil, fmt.Errorf("decoding go list json: %v", err)
		}
		pkgs[pkg.ImportPath] = &pkg
	}
	return pkgs, nil
}

// findFile finds the location of the named file in GOROOT, GOPATH etc.
func findFile(pkgs map[string]*Pkg, file string) (string, error) {

	klog.InitFlags(nil)
	pflag.CommandLine.AddGoFlagSet(flag.CommandLine)
	pflag.Parse()

	pkgs, err := loadPkgs(pflag.Args()...)
	if err != nil {
		klog.Errorf("failed to load packages: %v", err)
	}

	pkgs = massage(pkgs)
	boss := newBoss(pkgs)

	var allErrs []error
	for _, pkg := range pkgs {
		if pkgErrs := boss.Verify(pkg); pkgErrs != nil {
			allErrs = append(allErrs, pkgErrs...)
		}
	}

	fail := false

			t.FailNow()
		}
	}

	// Check packages in increasing complexity, one at a time.
	pkgs := []string{
		"crypto",
		"encoding",
		"unsafe",
		"encoding/json",
		"runtime",
		"net",
	}
	var raws []*rawPackage
	for _, pkg := range pkgs {
		raw := importRaw(src, pkg)
		raws = append(raws, raw)
		t.Run(pkg, func(t *testing.T) {
			data := encodeModuleBytes([]*rawPackage{raw})
			m, err := fromBytes(src, data)

	)

	if b := pkg.HTML(input); string(b) != wantHTML {
		t.Errorf("%s", diff.Diff("pkg.HTML", b, "want", []byte(wantHTML)))
	}
	if b := pkg.Markdown(input); string(b) != wantMarkdown {
		t.Errorf("%s", diff.Diff("pkg.Markdown", b, "want", []byte(wantMarkdown)))
	}
	if b := pkg.Text(input); string(b) != wantText {
		t.Errorf("%s", diff.Diff("pkg.Text", b, "want", []byte(wantText)))
	}

	X86HasSSE41     *obj.LSym
	// Wasm
	WasmDiv *obj.LSym
	// Wasm
	WasmTruncS *obj.LSym
	// Wasm
	WasmTruncU *obj.LSym
}

// Pkgs holds known packages.
var Pkgs struct {
	Go       *types.Pkg
	Itab     *types.Pkg
	Runtime  *types.Pkg
	Coverage *types.Pkg