import org.gradle.api.internal.artifacts.verification.DependencyVerificationFixture
import org.gradle.integtests.fixtures.AbstractHttpDependencyResolutionTest
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.executer.GradleExecuter
import org.gradle.test.fixtures.plugin.PluginBuilder
import org.gradle.test.fixtures.server.http.MavenHttpModule

                    bar
                }

                dependencies {
                    bar "test:test-jar:1.0"
                }
            }
        """
        executer.withArgument("--parallel")

        expect:

                    }
                }
            }
        """
    }

    @Override
    void configureExecuter(GradleExecuter executer) {
        super.configureExecuter(executer)
        executer.beforeExecute {
            idsFile.delete()
        }
    }

    private TestFile getIdsFile() {
        testDir.testDirectory.file("ids.json")
    }

        @Delegate
        GradleExecuter delegate = executer

        void afterExecute(Closure action) {
            afterExecute << new ClosureBackedAction<GradleExecuter>(action)
        }
    }

    @Rule
    public final ScopeIdsFixture scopeIds = new ScopeIdsFixture(delegatingExecuter, temporaryFolder)

    void afterBuild() {
        afterExecute*.execute(executer)
    }

        // Make the first build in each test drop the VFS state
        executer.withArgument(FileSystemWatchingHelper.dropVfsArgument)
    }

    AbstractIntegrationSpec withWatchFs() {
        executer.withArgument(FileSystemWatchingHelper.enableFsWatchingArgument)
        this as AbstractIntegrationSpec
    }

    AbstractIntegrationSpec withoutWatchFs() {
        executer.withArgument(FileSystemWatchingHelper.disableFsWatchingArgument)

BUILD SUCCESSFUL in [ \\dms]+
1 actionable task: 1 executed
.*"""
    }

    def "outcome for failed build is logged with appropriate styling for log level #level"() {
        buildFile << """
            task broken {
                doLast {
                    throw new RuntimeException("broken")
                }
            }
        """

        expect:

 */

package org.gradle.launcher.continuous

import org.gradle.integtests.fixtures.AbstractContinuousIntegrationTest
import org.gradle.integtests.fixtures.executer.GradleExecuter
import org.gradle.integtests.fixtures.executer.GradleHandle
import org.gradle.integtests.fixtures.executer.UnexpectedBuildFailure
import spock.lang.Specification


class ContinuousIntegrationTestFixtureTest extends Specification {

import org.gradle.integtests.fixtures.build.BuildTestFile
import org.gradle.integtests.fixtures.build.BuildTestFixture
import org.gradle.integtests.fixtures.executer.OutputScrapingExecutionFailure
import org.gradle.integtests.fixtures.executer.OutputScrapingExecutionResult
import org.gradle.internal.Pair
import org.gradle.test.fixtures.file.TestFile
import org.gradle.tooling.BuildAction

        given: "A sample project with an Ant build"
        def dslDir = sample.dir.file(dsl)
        executer.inDirectory(dslDir)

        when:
        def result = succeeds('clean', 'assemble')

        then: "The correct JAR is built"
        dslDir.file('target/lib/hello-app.jar').isFile()

        and: "The compilejava task is executed in place of the original 'build' task"
        result.assertTaskExecuted(':compileJava')

            plugins.apply(my.MyPlugin)
            println("configuring root")
        """
    }

    def "parameterized models are reused in the same build action"() {
        when:
        executer.withArguments(ENABLE_CLI)
        def models = runBuildAction(new FetchParameterizedCustomModelForEachProject(["fetch1", "fetch2", "fetch1", "fetch2"]))

        then:
        fixture.assertStateStored {