*
 * <p>You can use {@link CacheBuilder#withInitializer(java.util.function.Consumer)} to provide an action to initialize the contents
 * of the cache, for building a read-only cache. An exclusive lock is held by this process while the initializer is running.</p>
 *
 * <p>You can also use {@link #useCache(java.util.function.Supplier)} to perform some action on the cache while holding an exclusive

[short] skip

# Packages in std do not have an install target.
go list -f '{{.Target}}' fmt
! stdout .
go list -export -f '{{.Export}}' fmt
stdout $GOCACHE

# With GODEBUG=installgoroot=all, fmt has a target.
# (Though we can't try installing it without modifying goroot).
env GODEBUG=installgoroot=all
go list -f '{{.Target}}' fmt
stdout fmt\.a

# However, the fake packages "builtin" and "unsafe" do not.

 * limitations under the License.
 */

package org.gradle.cache.internal

import org.apache.commons.io.FileUtils
import org.gradle.cache.CacheBuilder
import org.gradle.cache.FileLockManager
import org.gradle.cache.PersistentCache
import org.gradle.cache.scopes.GlobalScopedCacheBuilderFactory
import org.gradle.test.fixtures.file.TestNameTestDirectoryProvider

        def result = new TestInMemoryIndexedCache<>(valueSerializer)
        caches.put(cacheName, result)
        return result
    }

    @Override
    <T> T useCache(Supplier<? extends T> action) {
        action.get()
    }

    @Override
    void useCache(Runnable action) {
        action.run()
    }

    @Override
    <T> T withFileLock(Supplier<? extends T> action) {
        action.get()
    }

		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"

# should not depend on its working directory, even if the binary is specified as
# a list of relative source files.

[short] skip  # links and runs binaries

env GOFLAGS=-trimpath
env GOCACHE=$WORK/gocache


# When we build a binary in module mode with -trimpath, the -D flag (for the
# "local import prefix") should not be passed to it.

cd $WORK/tmp/foo
go build -x -o a.exe main.go

env GO111MODULE=on
env GOCACHE=$WORK/gocache
env GODEBUG=gocachetest=1

# The first run of a test should not be cached.
# The second run should be.
go test -run=WriteTmp .
! stdout '(cached)'
go test -run=WriteTmp .
stdout '(cached)'

# 'go test' without arguments should never be cached.
go test -run=WriteTmp
! stdout '(cached)'
go test -run=WriteTmp
! stdout '(cached)'

	err := s.scanFolder(ctx, folder, &root)
	if err != nil {
		// No useful information...
		return cache, err
	}
	s.newCache.forceCompact(dataScannerCompactAtChildren)
	s.newCache.Info.LastUpdate = UTCNow()
	s.newCache.Info.NextCycle = cache.Info.NextCycle
	return s.newCache, nil
}

// sendUpdate() should be called on a regular basis when the newCache contains more recent total than previously.

# go get should skip build with no Go files in root
go get golang.org/x/text@14c0d48

# dropping -d, we should see a build.
[short] skip

env GOCACHE=$WORK/gocache  # Looking for compile commands, so need a clean cache.

go build -x golang.org/x/text/language
stderr 'compile|cp|gccgo .*language\.a$'

go list -f '{{.Stale}}' golang.org/x/text/language
stdout ^false

David P. Baker <******@****.***> 1641482883 -0800