@Rule
    public final TestResources resources = new TestResources(temporaryFolder)
    def version = GradleVersion.current().version
    def builtInOptions = """
     --rerun     Causes the task to be re-run even if up-to-date.
""".readLines().tail().join("\n")

    def "shows help message when tasks #tasks run in a directory with no build definition present"() {

        when:
        succeeds "b"

        then:
        result.assertTasksSkipped(":a", ":b")

        // Run with --rerun-tasks command-line options
        when:
        succeeds "b", "--rerun-tasks"

        then:
        result.assertTasksNotSkipped(":a", ":b")

        // Output files already exist before using this version of Gradle

	}
	installLog.Info("Installation succeed, start watching for re-installation.")

	for {
		// if sleepWatchInstall yields without error, that means the config might have been modified in some fashion.
		// so we rerun `install`, which will update the modified config if it has fallen out of sync with
		// our desired state
		err := in.sleepWatchInstall(ctx, installedBins)
		if err != nil {

                     swift-library

     --use-defaults     Use default values for options not configured explicitly

     --no-use-defaults     Disables option --use-defaults.

     --rerun     Causes the task to be re-run even if up-to-date.

Description""") // include the next header to make sure all options are listed
    }

	waitForRun("fifth run", t, timer, obj)

	// Retry was cancelled because we already ran
	timer.advance(4 * time.Second) // rel=4s since run, 5s since RetryAfter
	waitForNothing("retry cancelled", t, timer, obj)

	// Rerun happens after maxInterval
	timer.advance(5 * time.Second) // rel=9s since run, 10s since RetryAfter
	waitForNothing("premature", t, timer, obj)
	timer.advance(time.Second) // rel=10s since run

        succeeds ':resolvableConfigurations'
        reportsCompleteAbsenceOfResolvableConfigurations()
    }

    def "if only legacy configuration present, and --all not specified, task produces empty report and prompts for rerun"() {
        given:
        buildFile << """
            configurations.create("legacy") {
                description = "My legacy configuration"
                assert canBeResolved
                assert canBeConsumed

	// Reflector should already be stopped for maxIdleTime exceeded.
	assert.False(t, reflectorRunning())

	obj, _ = store.Get("ns", "name")
	assert.True(t, apiequality.Semantic.DeepEqual(secret, obj))
	// Reflector should reRun after get secret again.
	assert.True(t, reflectorRunning())

	fakeClock.Step(20 * time.Second)
	_, _ = store.Get("ns", "name")
	fakeClock.Step(20 * time.Second)
	_, _ = store.Get("ns", "name")

----

Gradle won't print more output to the console if all tests passed successfully.
You can find the test reports in the `<subproject>/build/reports` folders.

            }

            task custom(type: CustomTask) {
                outputFile = file("output.txt")
            }
        """

        expect:
        2.times {
            succeeds "custom", "--rerun-tasks"
        }
    }

    @Issue("https://github.com/gradle/gradle/issues/2293")
    def "detects a cycle with a task that mustRunAfter itself as finalizer of another task"() {
        buildFile << """

        }
    }

    public static class RerunTasksOption extends EnabledOnlyBooleanBuildOption<StartParameterInternal> {
        public RerunTasksOption() {
            super(null, CommandLineOptionConfiguration.create("rerun-tasks", "Ignore previously cached task results."));
        }

        @Override
        public void applyTo(StartParameterInternal settings, Origin origin) {
            settings.setRerunTasks(true);
        }