* See the License for the specific language governing permissions and
 * limitations under the License.
 */

package org.gradle.api.internal.tasks.execution;

import org.gradle.api.internal.TaskInternal;
import org.gradle.api.internal.tasks.TaskExecuter;
import org.gradle.api.internal.tasks.TaskExecuterResult;
import org.gradle.api.internal.tasks.TaskExecutionContext;
import org.gradle.api.internal.tasks.TaskStateInternal;

        }
    }

    private
    suspend fun ReadContext.readUpToDateSpec(task: TaskInternal) {
        if (readBoolean()) {
            task.outputs.upToDateWhen(readNonNull<Spec<Task>>())
        }
    }

    private
    fun WriteContext.writeReasonNotToTrackState(task: TaskInternal) {
        writeNullableString(task.reasonNotToTrackState.orElse(null))
    }

    private

        given:
        TaskInternal finalizerA = createTask("finalizerA", project, Async)
        TaskInternal finalizerB = createTask("finalizerB", project, Async)
        TaskInternal finalizerC = createTask("finalizerC", project, Async)
        TaskInternal finalizerDepA = task("finalizerDepA", type: Async, finalizedBy: [finalizerA, finalizerB, finalizerC])

package org.gradle.api.internal.tasks;

import org.gradle.api.internal.TaskInternal;

/**
 * Checks for tasks accessing the model at execution time, which might be a problem that needs reporting e.g. with configuration cache enabled.
 */
public interface TaskExecutionAccessChecker {
    void notifyProjectAccess(TaskInternal task);
    void notifyTaskDependenciesAccess(TaskInternal task, String invocationDescription);

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;

    }

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

 * 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;