if (value == null) {
            value = factory.apply(key);
            doCache(key, value);
        }

        return value;
    }

    @Override
    public V getIfPresent(K key) {
        return doGet(key);
    }

    @Override
    public void put(K key, V value) {
        doCache(key, value);
    }

    abstract protected <T extends K> V doGet(T key);

        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);
    }

// Copyright 2023 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

package dcache

import (
	"./aconfig"
	"./bresource"
	"./cmem"
)

type Module struct {
	cfg  *aconfig.Config
	err  error
	last any
}

//go:noinline
func TD() {
}

func (m *Module) Configure(x string) error {
	if m.err != nil {
		return m.err
	}

# We're testing cache behavior, so start with a clean GOCACHE.
env GOCACHE=$WORK/cache

# Build something so that the cache gets populates
go build main.go

# Check that cache contains directories before running
exists $GOCACHE/00

# Run go clean -cache -n and ensure that directories weren't deleted
go clean -cache -n
exists $GOCACHE/00

# Re-run go clean cache without the -n flag go ensure that directories were properly removed
go clean -cache

[!fuzz-instrumented] skip

[short] skip
env GOCACHE=$WORK/cache

# Fuzz cache should not exist after a regular test run.
go test .
exists $GOCACHE
! exists $GOCACHE/fuzz

# Fuzzing should write interesting values to the cache.
go test -fuzz=FuzzY -fuzztime=100x .
go run ./contains_files $GOCACHE/fuzz/example.com/y/FuzzY

# 'go clean -cache' should not delete the fuzz cache.
go clean -cache
exists $GOCACHE/fuzz

mkdir $WORK/gocache
mkdir $WORK/xdg
mkdir $WORK/home

# Set GOCACHE, XDG_CACHE_HOME, and HOME.
env GOCACHE=$WORK/gocache
env XDG_CACHE_HOME=$WORK/xdg
env HOME=$WORK/home

# With all three set, we should prefer GOCACHE.
go env GOCACHE
stdout $WORK'/gocache$'

# Without GOCACHE, we should prefer XDG_CACHE_HOME over HOME.
env GOCACHE=
go env GOCACHE
stdout $WORK'/xdg/go-build$$'

# If none of the variables we use to locate GOCACHE are set, the cache is off
# and we cannot build.
env GOCACHE=
env XDG_CACHE_HOME=
env HOME=
[GOOS:plan9] env home=
[GOOS:windows] env LocalAppData=
! go build -o triv triv.go
stderr 'build cache is required, but could not be located: GOCACHE is not defined and .*'

# If GOCACHE is set but is not an absolute path, and we cannot build.
env GOCACHE=test
! go build -o triv triv.go

[short] skip

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

# Building trivial non-main package should run preprofile the first time.
go build -x -pgo=default.pgo lib.go
stderr 'preprofile.*default\.pgo'

# ... but not again ...
go build -x -pgo=default.pgo lib.go
! stderr 'preprofile.*default\.pgo'

# ... unless we use -a.
go build -a -x -pgo=default.pgo lib.go
stderr 'preprofile.*default\.pgo'

symlink $GOROOT -> $TESTGO_GOROOT

# Set up fresh GOCACHE
env GOCACHE=$WORK/gocache1
mkdir $GOCACHE

# Build a simple binary
go build -o binary1 -trimpath -x main.go

# Now repeat the same process with the compiler at a different local path
env GOROOT=$WORK/goroot2
symlink $GOROOT -> $TESTGO_GOROOT

env GOCACHE=$WORK/gocache2
mkdir $GOCACHE

go build -o binary2 -trimpath -x main.go

env GO111MODULE=off
[short] skip

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

# Building trivial non-main package should run compiler the first time.
go build -x lib.go
stderr '(compile|gccgo)( |\.exe).*lib\.go'

# ... but not again ...
go build -x lib.go
! stderr '(compile|gccgo)( |\.exe).*lib\.go'

# ... unless we use -a.
go build -a -x lib.go
stderr '(compile|gccgo)( |\.exe)'

-- lib.go --