private final Action<ExecutionResult> resultAssertion;
    private final PipedOutputStream stdinPipe;
    private final boolean isDaemon;

    private final DurationMeasurement durationMeasurement;
    private final AtomicReference<ExecHandle> execHandleRef = new AtomicReference<>();

 */

package org.gradle.kotlin.dsl.caching.fixtures

import org.gradle.integtests.fixtures.executer.ExecutionResult


internal
fun ExecutionResult.classLoadingCache(action: ClassLoadingCache.() -> Unit) =
    action(ClassLoadingCache(this))


internal
class ClassLoadingCache(private val result: ExecutionResult) : KotlinDslCacheFixture {

    override fun misses(vararg cachedScripts: CachedScript) =

    String getJarTaskPath() {
        "${projectPath}:$JAR_TASK_NAME"
    }

    void assertBuildTasksExecuted(ExecutionResult result) {
        result.assertTaskNotSkipped(getCompileTaskPath())
        result.assertTaskNotSkipped(getJarTaskPath())
    }

    void assertBuildTasksSkipped(ExecutionResult result) {
        result.assertTaskSkipped(getCompileTaskPath())
        result.assertTaskSkipped(getJarTaskPath())
    }

package org.gradle.integtests.fixtures.executer;

public abstract class OutputScrapingGradleHandle implements GradleHandle {

    protected ExecutionResult toExecutionResult(String output, String error) {
        return OutputScrapingExecutionResult.from(output, error);
    }

    protected ExecutionResult toExecutionFailure(String output, String error) {
        return OutputScrapingExecutionFailure.from(output, error);
    }

 * limitations under the License.
 */

package org.gradle.internal.buildtree;

import org.gradle.execution.EntryTaskSelector;
import org.gradle.internal.build.ExecutionResult;
import org.gradle.internal.service.scopes.Scope;
import org.gradle.internal.service.scopes.ServiceScope;

import javax.annotation.Nullable;

@ServiceScope(Scope.BuildTree.class)

 */

package org.gradle.internal.cc.impl

import org.gradle.composite.internal.BuildTreeWorkGraphController
import org.gradle.execution.EntryTaskSelector
import org.gradle.internal.build.ExecutionResult
import org.gradle.internal.buildtree.BuildTreeWorkController
import org.gradle.internal.buildtree.BuildTreeWorkExecutor
import org.gradle.internal.buildtree.BuildTreeWorkGraph

import org.gradle.kotlin.dsl.execution.ProgramTarget.Settings

import java.io.File


fun ExecutionResult.compilationCache(action: CompilationCache.() -> Unit) =
    action(CompilationCache(this))


class CompilationCache(private val result: ExecutionResult) : KotlinDslCacheFixture {

    override fun misses(vararg cachedScripts: CachedScript) =
        cachedScripts.forEach { assertCompilations(it, 1) }

        'project'        | []
        'parent project' | ['my/project/dir']
    }

    ExecutionResult runWithWatchingEnabled(String... tasks) {
        def result = withWatchFs().run tasks
        assertOutputContainsNoInvalidation()
        return result
    }

    ExecutionResult runWithWatchingDisabled(String... tasks) {
        def result = withoutWatchFs().run tasks

 */

package org.gradle.play.integtest.fixtures.external

import org.gradle.api.JavaVersion
import org.gradle.integtests.fixtures.AbstractContinuousIntegrationTest
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.test.fixtures.file.TestFile

abstract class AbstractPlayExternalContinuousBuildIntegrationTest extends AbstractContinuousIntegrationTest {
    abstract RunningPlayApp getRunningApp()

import org.gradle.integtests.fixtures.executer.AbstractGradleExecuter
import org.gradle.integtests.fixtures.executer.ExecutionFailure
import org.gradle.integtests.fixtures.executer.ExecutionResult
import org.gradle.integtests.fixtures.executer.GradleContextualExecuter
import org.gradle.integtests.fixtures.executer.GradleDistribution
import org.gradle.integtests.fixtures.executer.GradleExecuter