// checkCacheDir checks if the directory specified by GOMODCACHE exists. An
// error is returned if it does not.
func checkCacheDir(ctx context.Context) error {
	if cfg.GOMODCACHE == "" {
		// modload.Init exits if GOPATH[0] is empty, and cfg.GOMODCACHE
		// is set to GOPATH[0]/pkg/mod if GOMODCACHE is empty, so this should never happen.
		return fmt.Errorf("module cache not found: neither GOMODCACHE nor GOPATH is set")
	}

	"google.golang.org/protobuf/types/known/structpb"

	"istio.io/istio/pilot/pkg/model"
	"istio.io/istio/pilot/pkg/util/protoconv"
	"istio.io/istio/pkg/config/xds"
)

type mockCache struct {
	wantSecret []byte
	wantPolicy PullPolicy
}

func (c *mockCache) Get(downloadURL string, opts GetOptions) (string, error) {
	url, _ := url.Parse(downloadURL)
	query := url.Query()

	module := query.Get("module")
	errMsg := query.Get("error")

! go env -u GOOS
stderr 'unsupported GOOS/GOARCH.*windows/mips$'
env GOOS=

# go env -w should reject relative paths in GOMODCACHE environment.
! go env -w GOMODCACHE=~/test
stderr 'go: GOMODCACHE entry is relative; must be absolute path: "~/test"'
! go env -w GOMODCACHE=./test
stderr 'go: GOMODCACHE entry is relative; must be absolute path: "./test"'

# go env -w checks validity of GOEXPERIMENT
env GOEXPERIMENT=

)

func TestMain(m *testing.M) {
	flag.Parse()
	if err := testMain(m); err != nil {
		log.Fatal(err)
	}
}

func testMain(m *testing.M) (err error) {
	cfg.GOPROXY = "direct"
	cfg.ModCacheRW = true

	srv, err := vcstest.NewServer()
	if err != nil {
		return err
	}
	defer func() {
		if closeErr := srv.Close(); err == nil {
			err = closeErr
		}
	}()

# Normally, the default is gcc or clang, but if CC was set during make.bash,
# that becomes the default.
[!cc:clang] [!cc:gcc] skip 'C compiler is not gcc or clang'

env GOCACHE=$WORK/gocache  # Looking for compile flags, so need a clean cache.
[!GOOS:windows] env PATH=.:$PATH
[!GOOS:windows] chmod 0755 p/gcc p/clang
[!GOOS:windows] exists -exec p/gcc p/clang
[GOOS:windows] exists -exec p/gcc.bat p/clang.bat

[short] skip
[!fuzz-instrumented] skip

env GOCACHE=$WORK/cache
! go test -fuzz=FuzzDead -v
# This is a somewhat inexact check, but since we don't prefix the error with anything
# and as the error suffix is platform dependent, this is the best we can do. In the
# deadlock failure case, the test will just deadlock and timeout anyway, so it should
# be clear that that failure mode is different.
stdout 'open'

-- go.mod --
module test

        this.map = map;
    }

    @Override
    protected <T extends K> V doGet(T key) {
        return map.get(key);
    }

    @Override
    protected <T extends K, N extends V> void doCache(T key, N value) {
        map.put(key, value);
    }

		t.Run(tt.desc, func(t *testing.T) {
			defer FlushObjectCaches()
			for key, value := range tt.in {
				objectCaches[key] = value
			}
			if gotCache := GetCache(tt.key); !reflect.DeepEqual(*gotCache, tt.want) {
				t.Errorf("%s: expected cache %v, got cache %v\n", tt.desc, tt.want, *gotCache)
			}
		})
	}
}

func TestRemoveObject(t *testing.T) {
	tests := []struct {
		desc string
		in   map[string]*ObjectCache

		t.Fatal(err)
	}
	env := append(os.Environ(), "GOROOT=", "GOROOT_BOOTSTRAP="+realGoroot)

	// Use a clean cache.
	gocache := t.TempDir()
	env = append(env, "GOCACHE="+gocache)

	// Build the toolchain without GOEXPERIMENT.
	var makeScript string
	switch runtime.GOOS {
	case "windows":
		makeScript = "make.bat"
	case "plan9":
		makeScript = "make.rc"

import org.apache.maven.api.services.ModelCache;
import org.apache.maven.api.services.Source;
import org.eclipse.aether.RepositoryCache;
import org.eclipse.aether.RepositorySystemSession;

import static java.util.Objects.requireNonNull;

/**
 * A model builder cache backed by the repository system cache.
 *
 */
public class DefaultModelCache implements ModelCache {