class CatchExceptionTaskExecuterTest extends Specification {
    private TaskExecuter delegate = Mock(TaskExecuter)
    private CatchExceptionTaskExecuter executer = new CatchExceptionTaskExecuter(delegate)
    private TaskInternal task = Mock(TaskInternal)
    private TaskStateInternal state = new TaskStateInternal()
    private TaskExecutionContext context = Mock(TaskExecutionContext)

    def 'calls delegate and does nothing'() {
        when:

import org.gradle.api.internal.TaskInternal;

public interface TaskIdentifier {
    BuildIdentifier getBuildIdentifier();

    String getTaskPath();

    interface TaskBasedTaskIdentifier extends TaskIdentifier {
        TaskInternal getTask();
    }

    static TaskBasedTaskIdentifier of(BuildIdentifier buildIdentifier, TaskInternal task) {
        return new TaskBasedTaskIdentifier() {

            results.put(details.getTaskIdentityPath(), result);
        }
    }

    @Override
    public AbstractTaskResult process(AbstractTaskResult taskResult, TaskInternal taskInternal) {
        CompileJavaBuildOperationType.Result compileResult = results.remove(taskInternal.getIdentityPath().getPath());
        if (taskResult instanceof DefaultTaskSuccessResult) {
            if (compileResult != null) {

public class CompileJavaBuildOperationReportingCompiler implements Compiler<JavaCompileSpec> {

    private final TaskInternal task;
    private final Compiler<JavaCompileSpec> delegate;
    private final BuildOperationRunner buildOperationRunner;

    public CompileJavaBuildOperationReportingCompiler(TaskInternal task, Compiler<JavaCompileSpec> delegate, BuildOperationRunner buildOperationRunner) {
        this.task = task;

 * limitations under the License.
 */
package org.gradle.execution;

import org.gradle.api.Task;
import org.gradle.api.internal.GradleInternal;
import org.gradle.api.internal.TaskInternal;
import org.gradle.execution.plan.FinalizedExecutionPlan;
import org.gradle.internal.build.ExecutionResult;
import org.gradle.internal.logging.text.StyledTextOutput;

    }

    @Override
    public File getFile() {
        return generator.get().getOutputs().getFiles().getSingleFile();
    }

    public boolean isEnabled() {
        TaskInternal task = (TaskInternal) generator.get();
        return task.getOnlyIf().isSatisfiedBy(task);
    }

    @Override
    public boolean shouldBePublished() {
        return isEnabled();
    }

    }

    @Override
    public Optional<CachingDisabledReason> shouldDisableCaching(
        TaskInternal task,
        TaskProperties taskProperties,
        Collection<SelfDescribingSpec<TaskInternal>> cacheIfSpecs,
        Collection<SelfDescribingSpec<TaskInternal>> doNotCacheIfSpecs,
        @Nullable OverlappingOutputs overlappingOutputs
    ) {
        if (cacheIfSpecs.isEmpty()) {

        factory = new TaskNodeFactory(gradle, Stub(BuildTreeWorkGraphController), Stub(NodeValidator), new TestBuildOperationRunner(), Stub(ExecutionNodeAccessHierarchies))
    }

    private TaskInternal task(String name) {
        Mock(TaskInternal) {
            getName() >> name
            compareTo(_) >> { args -> name.compareTo(args[0].name) }
            getProject() >> project
        }
    }

        def taskExecutionContext = new DefaultTaskExecutionContext(
            new LocalTaskNode(task as TaskInternal, workValidationContext, { null }),
            DefaultTaskProperties.resolve(executionServices.get(PropertyWalker), executionServices.get(FileCollectionFactory), task as TaskInternal),
            workValidationContext,
            { context -> }
        )

import groovy.util.ObservableList;
import org.gradle.api.internal.TaskInternal;

import java.beans.PropertyChangeEvent;
import java.util.concurrent.Callable;

import static org.gradle.internal.UncheckedException.uncheckedCall;

public class TaskMutator {
    private final TaskInternal task;

    public TaskMutator(TaskInternal task) {
        this.task = task;
    }