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();
        }
    }

import org.gradle.integtests.fixtures.AbstractIntegrationSpec
import org.gradle.integtests.fixtures.Sample
import org.gradle.integtests.fixtures.UsesSample
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.test.fixtures.file.LeaksFileHandles
import org.gradle.test.precondition.Requires

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

     */
    ExecutionResult<Void> beforeModelReset();

    /**
     * Restarts the lifecycle of the model of this build, discarding all current model state.
     */
    void resetModel();

    /**
     * Runs whatever work is required prior to discarding the model for this build. Called at the end of the build.
     */
    ExecutionResult<Void> beforeModelDiscarded(boolean failed);

        then:
        executedAndNotSkipped(":test")

        and:
        def executionResult = new DefaultTestExecutionResult(testDirectory)
        executionResult.testClass("ATest").assertTestOutcomes(passedTestOutcome, "test")
        !executionResult.testClassExists("BTest")
        executionResult.testClass("CTest").assertTestOutcomes(passedTestOutcome, "test")
    }

    private createTestABC() {

            }

            @Override
            public boolean executedIncrementally() {
                return result.getExecution()
                    .map(executionResult -> executionResult.getOutcome() == EXECUTED_INCREMENTALLY)
                    .getOrMapFailure(throwable -> false);
            }

            @Override
            public List<String> getExecutionReasons() {

 * limitations under the License.
 */

package org.gradle.integtests.tooling.m8

import org.apache.commons.io.output.TeeOutputStream
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.tooling.fixture.TestOutputStream
import org.gradle.integtests.tooling.fixture.ToolingApiLoggingSpecification
import org.gradle.test.fixtures.file.LeaksFileHandles