}
               }
            }
        """

        when:
        executer.withArgument('--parallel')
        run 'resolve'

        then:
        noExceptionThrown()

        when: "second build from cache"
        executer.withArgument('--parallel')
        run 'resolve'

        then:
        noExceptionThrown()

        where:
        displayName       | rules

class ParallelCompilerDaemonIntegrationTest extends AbstractIntegrationSpec {
    @Rule TestResources resources = new TestResources(temporaryFolder)

    def "daemon compiler can handle --parallel"() {
        generateProjects(10, 10, 10)

        args("--parallel")

        expect:
        succeeds("classes")
    }

    private generateProjects(int numProjects, int numJavaSources, int numGroovySources) {
        def settingsText = ""

 *
 * <ul>
 *     <li>Parallel execution of work items within a single task</li>
 *     <li>Execution in isolated contexts such as an isolated classloader or even a separate process</li>
 *     <li>Safe execution of multiple tasks in parallel</li>
 * </ul>
 *

org.gradle.caching=true
org.gradle.jvmargs='-Dfile.encoding=UTF-8'
org.gradle.parallel=true
android.enableJetifier=true
android.useAndroidX=true
kotlin.mpp.stability.nowarn=true
kotlin.js.compiler=ir
kotlin.incremental.js.ir=true
androidBuild=false
graalBuild=false
loomBuild=false
containerTests=false

                session.getProjects().size());
        boolean parallel = nThreads > 1;
        // Propagate the parallel flag to the root session and all of the cloned sessions in each project segment
        session.setParallel(parallel);
        for (ProjectSegment segment : projectBuilds) {
            segment.getSession().setParallel(parallel);
        }

		t.Run(tt.Name, func(t *testing.T) {
			if tt.Version == "" {
				if testing.Verbose() {
					// Don't run in parallel: cmd/fix sometimes writes directly to stderr,
					// and since -v prints which test is currently running we want that
					// information to accurately correlate with the stderr output.
				} else {
					t.Parallel()
				}
			} else {
				old := *goVersion
				*goVersion = tt.Version
				defer func() {

rootProject.name = "parallel-test-execution"...

	"path/filepath"
	"strings"
	"testing"
)

// Make sure "hello world" does not link in all the
// fmt.scanf routines. See issue 6853.
func TestScanfRemoval(t *testing.T) {
	testenv.MustHaveGoBuild(t)
	t.Parallel()

	// Make a directory to work in.
	dir := t.TempDir()

	// Create source.
	src := filepath.Join(dir, "test.go")
	f, err := os.Create(src)
	if err != nil {
		t.Fatalf("could not create source file: %v", err)

import java.util.ArrayList;
import java.util.List;

/**
 * A wrapper that prepares artifacts in parallel when visiting the delegate.
 * This is done by collecting all artifacts to prepare and/or visit in a first step.
 * The collected artifacts are prepared in parallel and subsequently visited in sequence.
 */
public abstract class ParallelResolveArtifactSet {

// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Package par implements parallel execution helpers.
package par

import (
	"errors"
	"math/rand"
	"sync"
	"sync/atomic"
)

// Work manages a set of work items to be executed in parallel, at most once each.
// The items in the set must all be valid map keys.
type Work[T comparable] struct {