// set it as the name of the test.  Then in runTest we can reflectively load and invoke the
    // corresponding method on AbstractFutureTest in the correct classloader.
    TestSuite suite = new TestSuite(AbstractFutureFallbackAtomicHelperTest.class.getName());
    for (Method method : AbstractFutureTest.class.getDeclaredMethods()) {

    def setup() {
        settingsFile << plugin.pluginManagement() << plugin.plugins()
        plugin.publishDummyPlugin(executer)
    }

    def "provided build state is correct"() {
        given:
        buildFile << """
            def serviceRef = gradle.extensions.serviceRef
            task check {
                doLast {
                    def service = serviceRef.get()

// a ProcSteal applies to is ambiguous. This only happens in
// practice when the events aren't already properly ordered
// by timestamp, since the ProcSteal won't be seen until after
// the correct GoSyscallBegin appears on the frontier.

package main

import (
	"internal/trace"
	"internal/trace/event/go122"
	testgen "internal/trace/internal/testgen/go122"
)

func main() {
	testgen.Main(gen)

		if err != nil {
			// The DNSError type stores the error as a string, so it cannot wrap the
			// original error code and we cannot check for it here. However, we can at
			// least use its error string to identify the correct localized text for
			// the error to skip.
			var DNS_ERROR_RCODE_SERVER_FAILURE syscall.Errno = 9002
			if strings.HasSuffix(err.Error(), DNS_ERROR_RCODE_SERVER_FAILURE.Error()) {
				testenv.SkipFlaky(t, 38111)
			}

	if err != nil {
		t.Errorf("failed to decode intermediate certificate: %v", err)
	}
	intermediateX509 := parseCert(t, intermediateCert)
	// verify the correct intermediate cert is in the certificate chain
	if intermediateX509.SerialNumber.String() != caX590.SerialNumber.String() {
		return fmt.Errorf("intermediate certificate serial numbers do not match: got %v, wanted %v",

    return sampler.Hello()
}
-- b/go.mod --
module example.com/b

go 1.23

// The indrect comment below is inaccurate. Its purpose
// is to test that it is corrected when enough packages
// are loaded to correct it.

require example.com/c v1.0.0 // indirect

replace example.com/c => ../c
-- b/b.go --
package b

import "example.com/c"

func B() {
    c.C()
}
-- c/go.mod --
module example.com/c

            proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
            proxy_set_header X-Forwarded-Proto $scheme;
            proxy_set_header X-NginX-Proxy true;

            # This is necessary to pass the correct IP to be hashed
            real_ip_header X-Real-IP;

            proxy_connect_timeout 300;
            
            # To support websocket
            proxy_http_version 1.1;

// attached as an attribute.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateMaterializePassthroughOpPass();

// Replicates the TensorList init op by undoing some CSE needed for correct
// shape assignment in shape_inference.
std::unique_ptr<OperationPass<func::FuncOp>>
CreateReplicateTensorListInitOpsPass();

// Performs Shape Inference on the TensorFlow dialect using the global registry.

        return decodePreservingSharedIdentity {
            val available = readBoolean()
            if (available) {
                val value = read()
                // TODO - restore the correct display name when the container is attached to its owner (rather than writing the display name to the cache)
                calculatedValueContainerFactory.create(Describables.of("unknown value"), value as Any)
            } else {

    // Currently flaky with CC enabled
    def "producer task followed by a destroyer task followed by a producer with a dependency on the first producer are run in the correct order"() {
        def foo = subproject(':foo')
        def bar = subproject(':bar')

        def cleanFooLocal = foo.task('cleanFooLocalState').destroys('build/foo-local')