* limitations under the License.
 */

package org.gradle.integtests.resolve.api

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.test.precondition.Requires
import org.gradle.test.preconditions.IntegTestPreconditions
import org.gradle.util.GradleVersion

        }
        AfterExecutionResult result = executeWithoutCache(cacheableWork.work, context);
        try {
            result.getExecution().ifSuccessfulOrElse(
                executionResult -> storeInCacheUnlessDisabled(cacheableWork, cacheKey, result, executionResult),
                failure -> LOGGER.debug("Not storing result of {} in cache because the execution failed", cacheableWork.getDisplayName())
            );
            return result;

    }

    @Override
    public ExecutionResult<Void> beforeModelReset() {
        return getBuildController().beforeModelReset();
    }

    @Override
    public ExecutionResult<Void> beforeModelDiscarded(boolean failed) {
        return getBuildController().beforeModelDiscarded(failed);
    }

    @Override

        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"() {

        }

        @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 -> {

    }

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

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

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

    void assertCacheWasCleanedUpSince(long lastCleanupCheck) {

 * 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