env GO111MODULE=off
[short] skip # rebuilds std for mips

# Set up fresh GOCACHE.
env GOCACHE=$WORK/gocache
mkdir $GOCACHE

# Building for mipsle without setting GOMIPS will use floating point registers.
env GOARCH=mipsle
env GOOS=linux
go build -gcflags=-S f.go
stderr ADDD.F[0-9]+,.F[0-9]+,.F[0-9]+

# Clean cache
go clean -cache

# Building with GOMIPS=softfloat will not use floating point registers
env GOMIPS=softfloat

[!fuzz] skip
[short] skip
env GOCACHE=$WORK/cache

# This test checks that cached corpus loading properly handles duplicate entries (this can
# happen when a f.Add value has a duplicate entry in the cached corpus.) Duplicate entries
# should be discarded, and the rest of the cache should be loaded as normal.

env GOCACHE=$WORK/cache
env GODEBUG=fuzzdebug=1

mkdir -p $GOCACHE/fuzz/fuzztest/FuzzTarget
go run ./populate $GOCACHE/fuzz/fuzztest/FuzzTarget

env GO111MODULE=on

[short] skip
[!cgo] skip

# Regression test for golang.org/issue/29667:
# spurious 'failed to cache compiled Go files' errors.

env GOCACHE=$WORK/gocache
mkdir $GOCACHE

go list -json -compiled -test=false -export=false -deps=true -- . &
go list -json -compiled -test=false -export=false -deps=true -- . &
wait

-- go.mod --
module sandbox/bar
-- bar.go --
package bar

// changed. crdCache is a cached.Replaceable and updates are thread
// safe. Thus, no lock is needed to protect this struct.
type specCache struct {
	crdCache          cached.LastSuccess[*apiextensionsv1.CustomResourceDefinition]
	mergedVersionSpec cached.Value[*spec.Swagger]
}

func (s *specCache) update(crd *apiextensionsv1.CustomResourceDefinition) {
	s.crdCache.Store(cached.Static(crd, generateCRDHash(crd)))
}

! stdout ^ok
stdout 'Failing input written to testdata[/\\]fuzz[/\\]FuzzWithNoCache[/\\]'
stdout FAIL

# Write a crashing input to the cache
mkdir $GOCACHE/fuzz/example.com/x/FuzzWithCache
cp cache-file $GOCACHE/fuzz/example.com/x/FuzzWithCache/1

# Test that fuzzing a target with a failure in the cache prints the crash
# and writes this as a "new" crash to testdata/fuzz

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) {

func (s *fsResourceAnalyzer) updateCachedPodVolumeStats() {
	oldCache := s.cachedVolumeStats.Load().(statCache)
	newCache := make(statCache)

	// Copy existing entries to new map, creating/starting new entries for pods missing from the cache
	for _, pod := range s.statsProvider.GetPods() {
		if value, found := oldCache[pod.GetUID()]; !found {

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()