t.Fatalf("Stat %q (looking for size %d): %s", path, size, err)
	}
	if dir.Size() != size {
		t.Errorf("Stat %q: size %d want %d", path, dir.Size(), size)
	}
}

func TestReadFile(t *testing.T) {
	t.Parallel()

	filename := "rumpelstilzchen"
	contents, err := ReadFile(filename)
	if err == nil {
		t.Fatalf("ReadFile %s: error expected, none found", filename)
	}

	filename = "read_test.go"

//          which represents the first branch of replicate group 0 and
//          the first branch of parallel group 0.
// Second instance of "tf.OpC" after flattening will have
//          `_parallel_execution_ids = "r0:1,p0:0"`
//          which represents the second branch of replicate group 0 and
//          the first branch of parallel group 0.
// First instance of "tf.OpD" after flattening will have

        public static final String GRADLE_PROPERTY = "org.gradle.parallel";

        public ParallelOption() {
            super(GRADLE_PROPERTY, BooleanCommandLineOptionConfiguration.create("parallel", "Build projects in parallel. Gradle will attempt to determine the optimal number of executor threads to use.", "Disables parallel execution to build projects."));
        }

        @Override

     * Returns {@code false} when the models will not be queried in parallel, for example because the target Gradle version does not support parallel execution,
     * or because some build configuration disables the parallel execution, or because the queries are unsafe to perform in parallel.
     *

<% if (binding.hasVariable("daemonMemory")) { %>org.gradle.jvmargs=-Xms${binding.getVariable("daemonMemory")} -Xmx${binding.getVariable("daemonMemory")}<% } %>
<% if (binding.hasVariable("parallel")) { %>org.gradle.parallel=true<% } %>

You can also use `-Dorg.gradle.internal.invalidate-coupled-projects=false` to force parallel configuration when there are access problems.

Please be aware that these options disable the validation that makes execution parallel- and caching-safe when isolated projects is enabled,
so you may see some unexpected behaviour when using them.

== Build logic constraints

import org.junit.Rule

@Requires(IntegTestPreconditions.NotParallelExecutor)
// no point, always runs in parallel
class ParallelDependencyResolutionIntegrationTest extends AbstractHttpDependencyResolutionTest {
    @Rule BlockingHttpServer blockingServer = new BlockingHttpServer()

    def setup() {
        executer.withArgument('--parallel')

	newLevels().
		// Level 1: bf=20(parallel)
		Add(20, true).
		// Level 2: bf=5(parallel)
		Add(5, true).
		// Level 3: bf=2(parallel)
		Add(2, true).
		Build().
		Run(t)
}

func TestMix(t *testing.T) {
	// Root is always run sync.
	newLevels().
		// Level 1: bf=20(parallel)
		Add(20, true).
		// Level 2: bf=5(sync)
		Add(5, false).
		// Level 3: bf=2(parallel)
		Add(2, true).
		Build().
		Run(t)

@Requires(IntegTestPreconditions.NotParallelExecutor)
class EnablingParallelExecutionIntegrationTest extends AbstractIntegrationSpec {

    def "parallel mode enabled via gradle.properties"() {
        file("gradle.properties") << "org.gradle.parallel=true"
        buildFile << "assert gradle.startParameter.parallelProjectExecutionEnabled"
        expect:
        run()
    }

	}
	if err := lockedfile.Write(path, bytes.NewReader(buf[:8]), 0666); err != nil {
		t.Fatal(err)
	}

	var attempts int64 = 128
	if !testing.Short() {
		attempts *= 16
	}
	const parallel = 32

	var sem = make(chan bool, parallel)

	for n := attempts; n > 0; n-- {
		sem <- true
		go func() {
			defer func() { <-sem }()

			time.Sleep(time.Duration(rand.Intn(100)) * time.Microsecond)