import org.gradle.api.specs.Spec
import org.gradle.groovy.scripts.ScriptSource
import spock.lang.Specification

class SkipOnlyIfTaskExecuterTest extends Specification {
    private final TaskInternal task = Mock(TaskInternal)
    private final DescribingAndSpec<Task> spec = Mock(DescribingAndSpec)
    private final TaskStateInternal state = Mock(TaskStateInternal)

    private final FileCollectionFactory fileCollectionFactory;
    private AndSpec<TaskInternal> upToDateSpec = AndSpec.empty();
    private boolean storeInCache = true;
    private final List<SelfDescribingSpec<TaskInternal>> cacheIfSpecs = new LinkedList<>();
    private final List<SelfDescribingSpec<TaskInternal>> doNotCacheIfSpecs = new LinkedList<>();
    private FileCollection previousOutputFiles;

import java.util.Optional;

public interface TaskCacheabilityResolver {
    Optional<CachingDisabledReason> shouldDisableCaching(
        TaskInternal task,
        TaskProperties taskProperties,
        Collection<SelfDescribingSpec<TaskInternal>> cacheIfSpecs,
        Collection<SelfDescribingSpec<TaskInternal>> doNotCacheIfSpecs,
        @Nullable OverlappingOutputs overlappingOutputs
    );

                nagAboutUndeclaredUsageOf(provider, task);
            }
        });
    }

    private Optional<TaskInternal> currentTask() {
        return taskExecutionTracker.getCurrentTask();
    }

    private static boolean isServiceRequiredBy(TaskInternal task, BuildServiceProvider<?, ?> provider) {
        return task.getRequiredServices().isServiceRequired(provider);
    }

    def setup() {
        _ * gradle.getStartParameter() >> startParameter
    }

    def "print all selected tasks before proceeding when dry run is enabled"() {
        def task1 = Mock(TaskInternal.class)
        def task2 = Mock(TaskInternal.class)
        def category = DryRunBuildExecutionAction.class.name
        def contents = Mock(QueryableExecutionPlan)

        given:
        startParameter.isDryRun() >> true

    }

    private static void checkForCyclesFor(TaskInternal task, Set<TaskInternal> visited, Set<TaskInternal> visiting) {
        if (visited.contains(task)) {
            // Already checked
            return;
        }
        if (!visiting.add(task)) {
            // Visiting dependencies -> have found a cycle

    public TaskExecutionMode getExecutionMode(TaskInternal task, TaskProperties properties) {
        if (task.getReasonNotToTrackState().isPresent()) {
            return DefaultTaskExecutionMode.untracked(task.getReasonNotToTrackState().get());
        }
        // Only false if no declared outputs AND no Task.upToDateWhen spec. We force to true for incremental tasks.
        AndSpec<? super TaskInternal> upToDateSpec = task.getOutputs().getUpToDateSpec();

    void finished(BuildOperationDescriptor buildOperation, OperationFinishEvent finishEvent);

    AbstractTaskResult process(AbstractTaskResult taskResult, TaskInternal taskInternal);

    }

    @Nullable
    private TaskInternal findTaskNode(String taskPath) {
        for (Task task : taskNodeFactory.getTasks()) {
            if (task.getPath().equals(taskPath)) {
                return (TaskInternal) task;
            }
        }
        return null;
    }

public abstract class TaskReportContainer<T extends Report> extends DefaultReportContainer<T> {
    private final TaskInternal task;

    public TaskReportContainer(Class<? extends T> type, final Task task, CollectionCallbackActionDecorator callbackActionDecorator) {
        super(type, locateInstantiator(task), callbackActionDecorator);
        this.task = (TaskInternal) task;
    }

    private static InstanceGenerator locateInstantiator(Task task) {