}
        """

        then:
        succeeds("t")
        afterBuild()

        when:
        update(i1, "2")

        then:
        buildTriggeredAndSucceeded()
        afterBuild()

        when:
        update(i2, "2")

        then:
        buildTriggeredAndSucceeded()
        afterBuild()

        and:

            task t {
                dependsOn t1, t2
            }
        """

        then:
        succeeds("t")
        afterBuild()
        scopeIds.buildInvocationId != null

        when:
        update(i1, "2")

        then:
        succeeds("t")
        afterBuild()
        originBuildInvocationId(":t1") == null
        originBuildInvocationId(":t2") == scopeIds.buildInvocationIds[0].asString()

    InitScriptExecuterFixture(GradleExecuter executer, TestDirectoryProvider testDir) {
        this.executer = executer
        this.testDir = testDir
    }

    String initScriptContent() {
    }

    void afterBuild() {
    }

    Statement apply(Statement base, FrameworkMethod method, Object target) {
        def temporaryFolder = testDir.testDirectory

    UserInitScriptExecuterFixture(GradleExecuter executer, TestDirectoryProvider testDir) {
        this.executer = executer
        this.testDir = testDir
    }

    String initScriptContent() {
    }

    void afterBuild() {
    }

    Statement apply(Statement base, FrameworkMethod method, Object target) {
        configureExecuter(executer)
        return base
    }

    void configureExecuter(GradleExecuter executer) {

        }
    }

    @Rule
    final TestResources resources = new TestResources(testDirectoryProvider)

    def operations = new BuildOperationsFixture(delegatingExecuter, temporaryFolder)

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

    def setup() {
        executer.withRepositoryMirrors()
    }

    def "emits test operations for continuous builds"() {
        given:

                            directory = '${cacheDir.absoluteFile.toURI()}'
                        }
                    }
                """.stripIndent()
        }

        @Override
        void afterBuild(BuildContext context, Throwable t) {
            assert !new File(projectDir, 'error.log').exists()
            def buildCacheDirectory = new TestFile(projectDir, 'local-build-cache')

                    outputFile << project.path + ";"
                }
                void beforeEvaluate(Project project) {}
           }
           gradle.addListener(listener)
       """
    }

    void afterBuild() {
        configuredProjects = asList(fixtureData.text.split(";"))
        assert fixtureData.delete()
    }

    void assertProjectsConfigured(String ... projectPaths) {

                }
                gradle.services.get(${BuildEventListenerRegistryInternal.name}).onOperationCompletion(collector)
            }
        """
    }

    @Override
    void afterBuild() {
        def rawOrigins = (Map<String, Map<String, String>>) new JsonSlurper().parse(file)
        origins.clear()
        rawOrigins.each {
            origins[it.key] = it.value == null ? null : new OriginMetadata(

                        assert settings.text.contains(buildCacheServer.uri.toString())
                    }
                }

                @Override
                void afterBuild(BuildContext context, Throwable error) {
                    if (isLastRun(context, invocationSettings) && checkIfCacheUsed) {

                // forces the service to be initialized immediately
                outputProgress.get()
            }
       """
    }

    @Override
    void afterBuild() {
        if (fixtureData.exists()) {
            progressContent = fixtureData.text.readLines()
            assert fixtureData.delete()
        } else {
            progressContent = []
        }
    }