then:
        customGradleUserHome.exists()
        project.gradle.startParameter.gradleUserHomeDir == customGradleUserHome
    }

    def "can be used in parallel"() {
        def threads = 5
        def startSignal = new CountDownLatch(1)
        def doneSignal = new CountDownLatch(threads)

        when:
        threads.times {
            new Thread({

Accessors for org.gradle.api.tasks.javadoc.Javadoc.maxMemory don't use symmetrical @Nullable
Accessors for org.gradle.api.tasks.testing.Test.forkEvery don't use symmetrical @Nullable
Accessors for org.gradle.api.tasks.testing.testng.TestNGOptions.parallel don't use symmetrical @Nullable
Accessors for org.gradle.caching.http.HttpBuildCache.url don't use symmetrical @Nullable

	f.Add(`C:\"Program Files"\`)
	f.Add(`\\"Quoted Host"\\share`)
	f.Add("\xfb")
	f.Add("0")
	f.Add("")
	f.Add("''''''''")
	f.Add("\r")
	f.Add("\n")
	f.Add("E,%")
	f.Fuzz(func(t *testing.T, s string) {
		t.Parallel()

		for _, c := range []byte(s) {
			if c == 0 {
				t.Skipf("skipping %q: contains a null byte. Null bytes can't occur in the environment"+

        skipped ':test'

        where:
        property                 | modification
        'suiteName'              | '= "Honeymoon Suite"'
        'testName'               | '= "Turing completeness"'
        'parallel'               | '= "methods"'
        'threadCount'            | '= 2'
        'suiteThreadPoolSize'    | '= 2'
        'listeners'              | '= ["org.testng.reporters.FailedReporter"]'

import java.util.List;

/**
 * A specialized {@link ComponentGraphResolveState} for local components (ie project dependencies).
 *
 * <p>Instances of this type are cached and reused for multiple graph resolutions, possibly in parallel. This means that the implementation must be thread-safe.
 */
@ThreadSafe
public interface LocalComponentGraphResolveState extends ComponentGraphResolveState {
    ModuleVersionIdentifier getModuleVersionId();

/**
 * [ApplicationServiceRegistration] centralizes registration of services with shared [MockApplication]s.
 *
 * The Kotlin core environment shares the application between multiple tests running in parallel. We need to ensure that application
 * services are only registered once, and especially that no races happen. Thread safety is ensured with a lock, while registrations are

		{goSrc: "libfuzzer2.go", cSrc: "libfuzzer2.c", expectedError: "panic: found it"},
	}
	for _, tc := range cases {
		tc := tc
		name := strings.TrimSuffix(tc.goSrc, ".go")
		t.Run(name, func(t *testing.T) {
			t.Parallel()

			dir := newTempDir(t)
			defer dir.RemoveAll(t)

			// build Go code in libfuzzer mode to a c-archive
			outPath := dir.Join(name)
			archivePath := dir.Join(name + ".a")

// tracefpunwindoff being set to 0 or 1.
func TestTraceUnwindCGO(t *testing.T) {
	if *flagQuick {
		t.Skip("-quick")
	}
	testenv.MustHaveGoBuild(t)
	t.Parallel()

	exe, err := buildTestProg(t, "testprogcgo")
	if err != nil {
		t.Fatal(err)
	}

	wantLogs := []string{
		"goCalledFromC",
		"goCalledFromCThread",
	}
	logs := make(map[string]*trace.Event)

			return nil
		}
	}
	return errors.Wrapf(err, "failed to pull image %s", image)
}

// PullImagesInParallel pulls a list of images in parallel
func (runtime *CRIRuntime) PullImagesInParallel(images []string, ifNotPresent bool) error {
	errs := pullImagesInParallelImpl(images, ifNotPresent, runtime.ImageExists, runtime.PullImage)
	return errorsutil.NewAggregate(errs)

        withConnection {
            def action = action(new ActionRunsNestedActions())
            action.standardOutput = System.out
            action.standardError = System.err
            action.addArguments("--parallel")
            action.run()
        }

        then:
        def e = thrown(BuildActionFailureException)
        def root = rootCause(e)
        root.message.startsWith(targetVersion >= GradleVersion.version("8.8") ?