// Tests a G being created from within a syscall.
//
// Specifically, it tests a scenerio wherein a C
// thread is calling into Go, creating a goroutine in
// a syscall (in the tracer's model). The system is free
// to reuse thread IDs, so first a thread ID is used to
// call into Go, and then is used for a Go-created thread.
//
// This is a regression test. The trace parser didn't correctly

Carlos Amedee <******@****.***> 1715265901 -0400

        and:
        configurationCacheRun 'ok'

        then:
        output.contains "Calculating task graph as configuration cache cannot be reused because remote script $scriptUrl has changed."
        configurationCache.assertStateStored()
    }

    def "reuse cache if remote script is up to date"() {
        when:
        configurationCacheRun 'ok'

        then:
        configurationCache.assertStateStored()

    }

    def "does not reuse cached state from previous version"() {

        when:
        runPrevious()

        then:
        previousFixture.assertStateStored(previous.loadsFromConfigurationCacheAfterStore)

        when:
        runCurrent()

        then:
        currentFixture.assertStateStored()
    }

    def "does not reuse cached state from future version"() {

        when:

	p = pthread_self();
	addr = pthread_get_stackaddr_np(p); // high address (!)
	size = pthread_get_stacksize_np(p);

	// bounds points into the Go stack. TSAN can't see the synchronization
	// in Go around stack reuse.
	_cgo_tsan_acquire();
	bounds[0] = (uintptr)addr - size;
	bounds[1] = (uintptr)addr;
	_cgo_tsan_release();

import com.google.common.base.Objects;

/**
 * This abstract class provide a sensible default implementation for {@code Serializer} equality. This equality
 * implementation is required to enable cache instance reuse within the same Gradle runtime. Serializers are used
 * as cache parameter which need to be compared to determine compatible cache.
 */
public abstract class AbstractSerializer<T> implements Serializer<T> {
    @Override

import java.util.UUID;

public class ClassLoaderDetails implements Serializable {
    // TODO:ADAM - using a UUID means we create a ClassLoader hierarchy for each daemon process we talk to. Instead, use the spec to decide whether to reuse a ClassLoader
    public final UUID uuid;
    public final ClassLoaderSpec spec;
    public final List<ClassLoaderDetails> parents = new ArrayList<ClassLoaderDetails>();

	addr = __builtin_frame_address(0) + 4096 - size;
#endif
	pthread_attr_destroy(&attr);

	// bounds points into the Go stack. TSAN can't see the synchronization
	// in Go around stack reuse.
	_cgo_tsan_acquire();
	bounds[0] = (uintptr)addr;
	bounds[1] = (uintptr)addr + size;
	_cgo_tsan_release();

import org.gradle.internal.component.model.ComponentIdGenerator;
import org.gradle.internal.component.model.DefaultExternalComponentGraphResolveState;

/**
 * <p>The aim is to create only a single instance of this type per component and reuse that for all resolution that happens in a build tree. This isn't quite the case yet.
 */

public class JavaHomeBasedJavaCompilerFactory implements Factory<ContextAwareJavaCompiler>, Serializable {
    private final List<File> compilerPluginsClasspath;
    // We use a static cache here because we want to reuse classloaders in compiler workers as
    // it has a huge impact on performance. Previously there was a single, JdkTools.current()
    // instance, but we can have different "compiler plugins" classpath. For this reason we use