package cmd

import (
	"context"
)

const (
	memTotal     = "total"
	memUsed      = "used"
	memFree      = "free"
	memBuffers   = "buffers"
	memCache     = "cache"
	memUsedPerc  = "used_perc"
	memShared    = "shared"
	memAvailable = "available"
)

var (
	memTotalMD     = NewGaugeMD(memTotal, "Total memory on the node")

            MultiProcessSafeAsyncPersistentIndexedCache<K, V> memCache = applyInMemoryCaching(cacheId, asyncCache, maxEntriesToKeepInMemory, cacheInMemoryForShortLivedProcesses);
            return new CrossProcessSynchronizingIndexedCache<>(memCache, crossProcessCacheAccess);
        }
    }

    private static class CacheDetails {
        private final int maxEntries;

import javax.inject.Named;
import javax.inject.Singleton;

import org.apache.maven.model.building.ModelCache;
import org.eclipse.aether.RepositorySystemSession;

/**
 * Default implementation of {@link ModelCacheFactory}.
 */
@Singleton
@Named
public class DefaultModelCacheFactory implements ModelCacheFactory {
    @Override
    public ModelCache createCache(RepositorySystemSession session) {

import org.junit.jupiter.api.Test

class CacheControlJvmTest {
  @Test
  @Throws(Exception::class)
  fun completeBuilder() {
    val cacheControl =
      CacheControl.Builder()
        .noCache()
        .noStore()
        .maxAge(1, TimeUnit.SECONDS)
        .maxStale(2, TimeUnit.SECONDS)
        .minFresh(3, TimeUnit.SECONDS)
        .onlyIfCached()
        .noTransform()
        .immutable()

// 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