}
		defer unlock()

		if err := downloadZip(ctx, mod, zipfile); err != nil {
			return "", err
		}
		return zipfile, nil
	})
}

func downloadZip(ctx context.Context, mod module.Version, zipfile string) (err error) {
	ctx, span := trace.StartSpan(ctx, "modfetch.downloadZip "+zipfile)
	defer span.Done()

	// Double-check that the zipfile was not created while we were waiting for
	// the lock in DownloadZip.

	afile := src.NewFileBase("a.go", "a.go")
	bfile := src.NewFileBase("b.go", "/foo/bar/b.go")
	lfile := src.NewLinePragmaBase(src.MakePos(afile, 8, 1), "linedir", "linedir", 100, 1)

	var tests = []struct {
		pos  src.Pos
		want string
	}{
		{src.NoPos, "??:0"},
		{src.MakePos(afile, 1, 0), "a.go:1"},
		{src.MakePos(afile, 2, 0), "a.go:2"},
		{src.MakePos(bfile, 10, 4), "/foo/bar/b.go:10"},

			if len(subdirs) > 0 {
				if err := sh.RemoveAll(subdirs...); err != nil && !printedErrors {
					printedErrors = true
					base.Error(err)
				}
			}

			logFile := filepath.Join(dir, "log.txt")
			if err := sh.RemoveAll(logFile); err != nil && !printedErrors {
				printedErrors = true
				base.Error(err)
			}
		}
	}

	if cleanTestcache && !cleanCache {

	"fmt"
	"os"
	"testing"
)

var (
	logPath = flag.String("log", "", "path to log file")
	logFile *os.File
)

func TestMain(m *testing.M) {
	flag.Parse()
	var err error
	logFile, err = os.OpenFile(*logPath, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0666)
	if os.IsExist(err) {
		*logPath += ".worker"
		logFile, err = os.OpenFile(*logPath, os.O_RDWR|os.O_CREATE|os.O_EXCL, 0666)
	}
	if err != nil {

rsc.io/badfile1 v1.0.0
written by hand
this is part of the badfile test but is a valid zip file.

-- .mod --
module rsc.io/badfile1
-- .info --
{"Version":"v1.0.0"}
-- go.mod --
module rsc.io/badfile1
-- α.go --
package α
-- .gitignore --

			for _, m := range mg.BuildList() {
				r := resolveReplacement(m)
				if keepModSumsForZipSums {
					keep[modkey(r)] = true // we need the go version from the go.mod file to do anything useful with the zipfile
				}
				keep[r] = true
			}
		}
	}

	return keep
}

type whichSums int8

const (
	loadedZipSumsOnly = whichSums(iota)
	addBuildListZipSums
)

	// go and gofmt and $GOOS_$GOARCH (target bin when cross-compiling).
	binFiles, err := filepath.Glob(pathf("%s/bin/*", goroot))
	if err != nil {
		fatalf("glob: %v", err)
	}

	ok := map[string]bool{}
	for _, f := range oldBinFiles {
		ok[f] = true
	}
	for _, f := range binFiles {
		if gohostos == "darwin" && filepath.Base(f) == ".DS_Store" {

			return nil, err
		})
}

func scriptModzip() script.Cmd {
	return script.Command(
		script.CmdUsage{
			Summary: "create a Go module zip file from a directory",
			Args:    "zipfile path@version dir",
		},
		func(st *script.State, args ...string) (wait script.WaitFunc, err error) {
			if len(args) != 3 {
				return nil, script.ErrUsage
			}
			zipPath := st.Path(args[0])

		if tt.repo == gitrepo1 {
			for _, tt.repo = range altRepos() {
				t.Run(path.Base(tt.repo)+"/"+tt.rev+"/"+tt.file, runTest(tt))
			}
		}
	}
}

type zipFile struct {
	name string
	size int64
}

func TestReadZip(t *testing.T) {
	t.Parallel()

	type readZipTest struct {
		repo   string
		rev    string
		subdir string
		err    string

		t.Skip("skipping: Chmod ignored ModeSetgid on " + runtime.GOOS)
	}

	pkgfile, err := os.CreateTemp("", "pkgfile")
	if err != nil {
		t.Fatalf("os.CreateTemp(\"\", \"pkgfile\"): %v", err)
	}
	defer os.Remove(pkgfile.Name())
	defer pkgfile.Close()

	dirGIDFile := filepath.Join(setgiddir, "setgid")
	if err := sh.moveOrCopyFile(dirGIDFile, pkgfile.Name(), 0666, true); err != nil {
		t.Fatalf("moveOrCopyFile: %v", err)
	}