// Block until second build has produced blue things
        def build2 = executer.withTasks("redThings", "blueThings", "block2").start()
        block2.waitForAllPendingCalls()

        // Finish up first build while second build is still running
        block1.releaseAll()
        def result1 = build1.waitForFinish()

        block2.releaseAll()
        def result2 = build2.waitForFinish()

        then:

        executer.withTasks("a", "b", "block2")
        def build2 = executer.start()
        block2.waitForAllPendingCalls()

        // Finish up build 1 and 2
        block1.releaseAll() // finish build 1 while build 2 is still running
        def result1 = build1.waitForFinish()
        block2.releaseAll()
        def result2 = build2.waitForFinish()

        then:

        // Finish up build 1 and 2
        block1.releaseAll() // finish build 1 while build 2 is still running
        build1.waitForFinish()
        block2.releaseAll()
        build2.waitForFinish()
    }

        failure.assertThatCause(Matchers.containsText("Multiple build operations failed"));
    }

    // This is the current behavior:
    // We need to make sure that the build operation ids of nested builds started by a GradleBuild task do not overlap.

        ProjectConnection connection2 = connector.connect()

        def build = connection1.newBuild()
        build.forTasks('hang')
        build.run(resultHandler)

        def build2 = connection2.newBuild()
        build2.forTasks('hang')
        build2.run(resultHandler)

        sync.waitForAllPendingCalls(resultHandler)
        then:

        def build1 = singleProjectBuild("build1") {
            buildFile << "task foo1"
        }
        def build2 = singleProjectBuild("build2") {
            buildFile << "task foo2"
        }

        when:
        def allProgress = new CopyOnWriteArrayList<String>()

        concurrent.start {
            def connector = toolingApi.connector(build1)

                    commits: ['abcdef']
                ]
            ],
            totalTime: [
                [
                    label: 'build1',
                    data: [[0, 1]]
                ],
                [
                    label: 'build2',
                    data: [[0, 2]]
                ]
            ]
        ]
    }

    def 'can calculate background color'() {

    }

    PerformanceTestHistory mockCrossBuildHistory() {
        BuildDisplayInfo info1 = buildDisplayInfo('build1')
        CrossBuildPerformanceResults result1  = crossBuildResults(startTime: 100)
        result1.buildResult(info1).addAll(measuredOperations([1]))

        BuildDisplayInfo info2 = buildDisplayInfo('build2')
        CrossBuildPerformanceResults result2  = crossBuildResults(startTime: 200)

        """
        includedBuilds << buildE

        when:
        dependency(buildA, "org.test:buildD-impl:1.0")
        dependency(buildA, "org.test:buildE-impl:1.0")

        then:
        resolveSucceeds(":build")

        assertTaskExecuted(":buildD", ":buildD-api:jar")
        assertTaskExecuted(":buildE", ":buildE-api:jar")
        assertTaskExecuted(":buildD", ":buildD-impl:jar")

	testenv.MustHaveGoBuild(t)
	dir := t.TempDir()
	if fixedTestDir {
		dir = "/tmp/qqqzzz"
		os.RemoveAll(dir)
		mkdir(t, dir)
	}

	// Build harness. We need two copies of the harness, one built
	// with -covermode=atomic and one built non-atomic.
	bdir1 := mkdir(t, filepath.Join(dir, "build1"))
	hargs1 := []string{"-covermode=atomic", "-coverpkg=all"}
	atomicHarnessPath := buildHarness(t, bdir1, hargs1)
	nonAtomicMode := testing.CoverMode()