import java.util.concurrent.atomic.AtomicLong;

/**
 * Creates unique ids for objects created during configuration.
 * <p>
 * Usage of this factory in object factories ensures that ids are reused consistently when loading from the configuration cache.
 */
@ThreadSafe
@ServiceScope(Scope.BuildTree.class)
public class ConfigurationCacheableIdFactory {

    private static final long USED_ASSIGNED_ID_MARKER = -1;

        def scriptPath = relativePathOf(scriptFile, projectDir)
        def scriptDesc = scriptPath.contains('init') ? 'init script' : 'file'
        return "configuration cache cannot be reused because $scriptDesc '$scriptPath' has changed."
    }

    void setup() {
        scriptFile.text = "println(\"$expectedOutputBeforeChange\")"
    }

    void applyChange() {

stdout '"Ref": "HEAD"'
stdout '"Hash": "f213069baa68ec26412fb373c7cf6669db1f8e69"'
stdout '"Reuse": true'


# If the hash refers to some other commit instead, the
# result should not be reused.

replace f213069baa68ec26412fb373c7cf6669db1f8e69 08a4fa6bb9c04ffba03b26ae427b0d6335d90a2a no-nested.json

go list -reuse=no-nested.json -json -m --versions -e vcs-test.golang.org/git/issue61415.git/nested@latest

}

func (t *panicOnNonReuseTransport) GotConn(info httptrace.GotConnInfo) {
	if !t.gotConnSeen {
		t.gotConnSeen = true
		return
	}
	if !info.Reused {
		panic(fmt.Sprintf("expected the connection to be reused, info %#v", info))
	}
}

// TestErrConnKilledHTTP2 check if HTTP/2 connection is not closed when an HTTP handler panics

        lock.lock();
        try {
            // Determine whether the given set of classloaders have already been used for some previous request
            // A single daemon side classloader is used for a given set of client side classloaders
            // So, if we find an entry for the given set of classloaders, then reuse it
            for (LocalClassLoaderMapping localClassLoaderMapping : new ArrayList<>(classLoaders.values())) {

    }

    protected
    fun withKotlinDslPluginInBuildSrc() {
        // this is to force buildSrc/build.gradle.kts to be written to test-local buildscript cache
        // and not to be reused from daemon's cache from other tests when daemon is in use
        withBuildScriptIn("buildSrc", scriptWithKotlinDslPlugin())
            .bustScriptCache()
    }

    private
    fun File.bustScriptCache() {

// while executing tests in m.
func RunWithPrivateKeyFixtureDirectory(m *testing.M) {
	defer install()()
	os.Exit(m.Run())
}

// Reset indicates a new test is starting and previously returned private key fixtures may be reused.
func Reset() {
	lock.Lock()
	defer lock.Unlock()
	ecdsa = 0
	rsa = 0
}

var (
	testFunction = regexp.MustCompile(`.*\.Test[^./]+(.func\d*)?$`)

	lock       = sync.Mutex{}
	fixtureDir = ""

// is only safe if the output object is not mutated or reused.
func (c unsafeObjectConvertor) ConvertToVersion(in Object, outVersion GroupVersioner) (Object, error) {
	return c.Scheme.UnsafeConvertToVersion(in, outVersion)
}

// UnsafeObjectConvertor performs object conversion without copying the object structure,
// for use when the converted object will not be reused or mutated. Primarily for use within

            if (unreliableArgument.isPresent()) {
                LOGGER.info("Worker requested to be persistent, but the JVM argument '{}' may make the worker unreliable when reused across multiple builds. Worker will expire at the end of the build session.", unreliableArgument.get());
                return new DaemonForkOptions(forkOptions, KeepAliveMode.SESSION, classLoaderStructure);
            }
        }

 * request body start and end events occur within the response header events. Similarly,
 * [duplex calls][RequestBody.isDuplex] interleave the request and response bodies.
 *
 * Since connections may be reused, the proxy selection, DNS, and connect events may not be present
 * for a call. In future releases of OkHttp these events may also occur concurrently to permit
 * multiple routes to be attempted simultaneously.
 *