buildFile << buildLogicForEndOfBuildWait(sleepPeriod)
    }

    @Override
    protected ExecutionResult succeeds(String... tasks) {
        runBuild(tasks)
        waitForBuild()
        throwOnBuildFailure()
        result
    }

    protected ExecutionResult buildTriggeredAndSucceeded() {
        if (!gradle.isRunning()) {
            throw new UnexpectedBuildFailure("Gradle has exited")

import org.gradle.integtests.fixtures.AvailableJavaHomes
import org.gradle.integtests.fixtures.CrossVersionIntegrationSpec
import org.gradle.integtests.fixtures.IgnoreVersions
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.internal.jvm.Jvm
import org.gradle.jvm.toolchain.JdkRepository
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions

import java.nio.file.Files

        when:
        def result = asWorker {
            controller.transition(TestState.A, TestState.B, action)
        }

        then:
        1 * action.apply(_) >> { ExecutionResult r ->
            assert r.failures.empty
            ExecutionResult.succeeded()
        }
        0 * action._
        result.failures.empty
    }

    def "can transition to new state and take previous failure as input"() {

    }

    long markCacheLastCleaned(long timeMillis) {
        gcFile().lastModified = timeMillis
        return gcFile().lastModified()
    }

    ExecutionResult run() {
        withEnabledBuildCache().succeeds("cacheable")
    }

    ExecutionResult runAndFail() {
        withEnabledBuildCache().fails("cacheable")
    }

    void assertCacheWasCleanedUpSince(long lastCleanupCheck) {

        }

        @Override
        ExecutionResult<Void> beforeModelDiscarded(boolean failed) {
            throw new UnsupportedOperationException()
        }

        @Override
        ExecutionResult<Void> beforeModelReset() {
            throw new UnsupportedOperationException()
        }

        @Override
        ExecutionResult<Void> finishBuild(@Nullable Throwable failure) {

            return stopActions;
        }
    }

    @Override
    public void maybeStop() {
        // We don't want to call stop actions with the lock held.
        ExecutionResult<Void> stopResult = ExecutionResult.forEach(getStopActions(), action -> action.accept(this));
        synchronized (instanceLock) {
            try {
                if (instance != null) {
                    instance.ifSuccessful(t -> {

 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.integtests

import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.test.fixtures.file.TestFile
import org.gradle.test.fixtures.server.http.BlockingHttpServer
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions

        super(distribution, testDirectoryProvider, GradleVersion.current(), buildContext);
    }

    @Override
    protected ExecutionResult doRun() {
        return configureExecuter().run();
    }

    @Override
    protected ExecutionFailure doRunWithFailure() {
        return configureExecuter().runWithFailure();
    }

    @Override

        });
    }

    /**
     * Allows a subclass to expose additional APIs for running builds.
     */
    protected ExecutionResult run(Supplier<ExecutionResult> action) {
        beforeBuildSetup();
        try {
            ExecutionResult result = action.get();
            afterBuildCleanup(result);
            return result;
        } finally {
            finished();
        }
    }

        executer.withBuildCacheEnabled()
        this
    }

    /**
     * Synonym for succeeds()
     */
    protected ExecutionResult run(String... tasks) {
        succeeds(*tasks)
    }

    protected ExecutionResult run(List<String> tasks) {
        succeeds(tasks.toArray(new String[tasks.size()]))
    }

    protected GradleExecuter args(String... args) {