${body}
                }
            }
        """
    }

    @Override
    protected String getExecResultDsl() {
        return "${taskUnderTestDsl}.executionResult.getOrNull()"
    }

import org.gradle.internal.build.BuildLifecycleController;
import org.gradle.internal.build.BuildState;
import org.gradle.internal.build.BuildStateRegistry;
import org.gradle.internal.build.ExecutionResult;
import org.gradle.internal.build.ExportedTaskNode;
import org.gradle.internal.buildtree.BuildTreeWorkGraph;
import org.gradle.internal.buildtree.BuildTreeWorkGraphPreparer;

                ${body}
                }
            }
        """
    }

    @Override
    protected String getExecResultDsl() {
        return "${taskUnderTestDsl}.executionResult.getOrNull()"
    }

                ${body}
                }
            }
        """
    }

    @Override
    protected String getExecResultDsl() {
        return "${taskUnderTestDsl}.executionResult.getOrNull()"
    }

    }

    void assertResultHasProblems(
        ExecutionResult result,
        @DelegatesTo(value = HasConfigurationCacheProblemsSpec, strategy = Closure.DELEGATE_FIRST) Closure<?> specClosure
    ) {
        assertResultHasProblems(result, ConfigureUtil.configureUsing(specClosure))
    }

    void assertResultHasProblems(
        ExecutionResult result,
        Action<HasConfigurationCacheProblemsSpec> specAction = {}

    }

    void execute(ModuleComponentResolveMetadata key) {
        def executionResult = executor.execute(key, rule, detailsToResult, onCacheMiss, cachePolicy)
        result = executionResult
    }

    void withRule(Class<? extends Action<ComponentMetadataContext>> ruleClass, Map<String, Object> services = [:]) {

        targetDir.file("build.gradle.kts").assertIsFile()
    }

    private ExecutionResult runInitWith(BuildInitDsl dsl, String... initOptions) {
        def tasks = ['init', '--dsl', dsl.id]
        tasks.addAll(initOptions)
        run tasks
    }

    private ExecutionResult initFailsWith(BuildInitDsl dsl, String... initOptions) {
        def tasks = ['init', '--dsl', dsl.id]

    protected ForkingGradleHandle createForkingGradleHandle(Action<ExecutionResult> resultAssertion, String encoding, Factory<? extends AbstractExecHandleBuilder> execHandleFactory) {
        return new ForkingGradleHandle(getStdinPipe(), isUseDaemon(), resultAssertion, encoding, execHandleFactory, getDurationMeasurement());
    }

    @Override
    protected ExecutionResult doRun() {
        return createGradleHandle().waitForFinish();
    }

        0 * _
        result.length == 6
    }


    void execute(Id id) {
        def executionResult = executor.execute(id, rule, detailsToResult, onCacheMiss, cachePolicy)
        result = executionResult
    }

    void withToUpperCaseRule() {
        rule = new InstantiatingAction<Details>(DefaultConfigurableRules.of(DefaultConfigurableRule.of(

    def gradleDistribution = Mock(GradleDistribution)

    AbstractGradleExecuter executer = new AbstractGradleExecuter(gradleDistribution, testDir) {
        @Override
        protected ExecutionResult doRun() {
            return null
        }

        @Override
        protected ExecutionFailure doRunWithFailure() {
            return null
        }

        @Override