withBuildCache().run "producer", "--rerun-tasks"
        then:
        executed ":producer"
    }

    @Issue("https://github.com/gradle/gradle/issues/3358")
    def "re-ran task is stored in cache"() {
        file("input.txt").text = "input"
        buildFile << defineProducerTask()

        // Store in local cache
        withBuildCache().run "producer", "--rerun-tasks"

        when:

        withConnection {
            ProjectConnection connection ->
                connection.newBuild()
                    .addProgressListener(events, [OperationType.TEST] as Set)
                    .withArguments("--rerun-tasks")
                    .forTasks("build")
                    .run()
        }

        then:
        events.tests.size() == events.operations.size()
        if (targetDist.runsBuildSrcTests) {

        10_000.times {
            defaultSerializerRegistry.build(SerializableParent)
        }
        then:
        noExceptionThrown()
        conditions.await(5.0)
        where:
        // Rerun this test 10 times
        testIteration << (0..9)
    }

    static class SerializableParent implements Serializable {}

    static class Serializable1 extends SerializableParent {}

        """

        when:
        succeeds("compileJava")

        then:
        pidFile().exists()
        def pid1 = pidFile().text.strip() as long
        kill(pid1)

        when:
        args "--rerun-tasks"
        succeeds("compileJava")

        then:
        pidFile().exists()
        def pid2 = pidFile().text.strip() as long
        pid2 != pid1

        and:
        outputContainsKilledWorkerWarning()

        executedAndNotSkipped(taskWithSources.taskPath)
    }

    @Issue("https://github.com/gradle/gradle/issues/8299")
    def "two tasks can output in the same directory with --rerun-tasks"() {
        buildFile << """
            apply plugin: 'base'

            task firstCopy {
                inputs.file('first.file')
                outputs.dir('build/destination')

        executesNonIncrementally()
    }

    def "incremental task is informed that all input files are 'out-of-date' when gradle is executed with --rerun-tasks"() {
        given:
        previousExecution()

        when:
        executer.withArgument("--rerun-tasks")

        then:
        executesNonIncrementally()
    }

        events.clear()
        withConnection {
            ProjectConnection connection ->
                connection.newBuild().withArguments('--rerun-tasks').forTasks('test').addProgressListener(events, EnumSet.of(OperationType.TEST)).run()
        }

        then: 'the parent of the root test progress event is null'
        events.tests[0].descriptor.parent == null

        if (matches.size() == 1) {
            return matches.get(0).getArtifacts();
        } else if (matches.size() > 1) {
            // Request is ambiguous. Rerun matching again, except capture an explanation this time for reporting.
            TraceDiscardedVariants newExpBuilder = new TraceDiscardedVariants();
            matches = matcher.matches(variants, componentRequested, newExpBuilder);

        // Not all entry nodes are always scheduled.
        // In particular, it happens when the entry node is a task of the included plugin build that runs as part of building the plugin.
        // Such tasks do not rerun when configuration cache is re-used, even if specified on the command line.
        // Not restoring them as entry points doesn't affect the resulting execution plan.
        val scheduledEntryNodeIds = mutableListOf<Int>()

        writeAllFiles()

        expect:
        2.times {
            server.expectConcurrent(cleanFoo.path, generateBar.path)

            args '--parallel', '--max-workers=2', '--rerun-tasks' // --rerun-tasks so that tasks are not up-to-date on second invocation
            succeeds(clean.path, generate.path)

            result.assertTaskOrder(cleanFoo.fullPath, generateFoo.fullPath, generate.fullPath)