func (tg *testgoData) check(err error) {
	tg.t.Helper()
	if err != nil {
		tg.t.Error(err)
	}
}

// parallel runs the test in parallel by calling t.Parallel.
func (tg *testgoData) parallel() {
	tg.t.Helper()
	if tg.ran {
		tg.t.Fatal("internal testsuite error: call to parallel after run")
	}
	for _, e := range tg.env {

<% if (binding.hasVariable("daemonMemory")) { %>org.gradle.jvmargs=-Xms${binding.getVariable("daemonMemory")} -Xmx${binding.getVariable("daemonMemory")}<% } %>
<% if (binding.hasVariable("parallel")) { %>org.gradle.parallel=true<% } %>
<% if (binding.hasVariable("maxWorkers")) { %>org.gradle.workers.max=${binding.getVariable("maxWorkers")}<% } %>
compilerMemory=<% if (binding.hasVariable("compilerMemory")) { %>${binding.getVariable("compilerMemory")}<% } else { %>1g<% } %>

            }
        """

        when:
        args "--parallel"
        execute(buildA, "clean", "build")

        then:
        result.assertTaskOrder(':buildB:clean', ':buildB:compileJava', ':clean', ':compileJava')

        when:
        args "--parallel"
        execute(buildA, "build", "clean")

        then:

    "groups" : [ {
      "testProject" : "excludeRuleMergingBuild",
      "coverage" : {
        "per_commit" : [ "linux" ]
      }
    } ]
  }, {
    "testId" : "org.gradle.performance.regression.corefeature.LargeDependencyGraphPerformanceTest.resolve large dependency graph (parallel = false, locking = true)",
    "groups" : [ {

package work

import (
	"bytes"
	"cmd/internal/objabi"
	"cmd/internal/sys"
	"fmt"
	"math/rand"
	"testing"
	"time"
	"unicode/utf8"
)

func TestEncodeArgs(t *testing.T) {
	t.Parallel()
	tests := []struct {
		arg, want string
	}{
		{"", ""},
		{"hello", "hello"},
		{"hello\n", "hello\\n"},
		{"hello\\", "hello\\\\"},
		{"hello\nthere", "hello\\nthere"},
		{"\\\n", "\\\\\\n"},
	}

    final def converter = new ParallelismBuildOptions().commandLineConverter()

    def "converts parallel executor"() {
        when:
        def result = convert("--parallel")

        then:
        result.parallelProjectExecutionEnabled == true

        when:
        result = convert("--no-parallel")

        then:
        result.parallelProjectExecutionEnabled == false
    }

    def "single project with parallel build should not emit configuration resolution deprecation warning"() {
        given:
        propertiesFile << gradleProperties

        expect:
        loadValidatedToolingModel(KotlinDslScriptsModel)
    }

    @Issue("https://github.com/gradle/gradle/issues/25555")
    def "multi project with parallel build should not emit configuration resolution deprecation warning"() {

	return frame.Function
}

// Parallel signals that this test is to be run in parallel with (and only with)
// other parallel tests. When a test is run multiple times due to use of
// -test.count or -test.cpu, multiple instances of a single test never run in
// parallel with each other.
func (t *T) Parallel() {
	if t.isParallel {
		panic("testing: t.Parallel called multiple times")
	}
	if t.isEnvSet {

/**
 * A {@code ParallelismConfiguration} defines the parallel settings for a Gradle build.
 *
 * @since 4.1
 */
public interface ParallelismConfiguration {
    /**
     * Returns true if parallel project execution is enabled.
     *
     * @see #getMaxWorkerCount()
     */
    boolean isParallelProjectExecutionEnabled();

    /**
     * Enables/disables parallel project execution.
     *

				realTest.Error("sequential test was not run")
			}
		},
	}, {
		desc:   "failure in parallel test propagates upwards",
		ok:     false,
		maxPar: 1,
		output: `
--- FAIL: failure in parallel test propagates upwards (N.NNs)
    --- FAIL: failure in parallel test propagates upwards/#00 (N.NNs)
        --- FAIL: failure in parallel test propagates upwards/#00/par (N.NNs)
        `,
		f: func(t *T) {
			t.Run("", func(t *T) {