}

    public boolean isRequired() {
        return state == ExecutionState.SHOULD_RUN;
    }

    public boolean isDoNotIncludeInPlan() {
        return filtered || state == ExecutionState.NOT_SCHEDULED || isCannotRunInAnyPlan();
    }

    public boolean isCannotRunInAnyPlan() {
        return state == ExecutionState.EXECUTED || state == ExecutionState.FAILED_DEPENDENCY;
    }

    /**

        store.put(key, new DefaultPreviousExecutionState(
            executionState.getOriginMetadata(),
            executionState.getCacheKey(),
            executionState.getImplementation(),
            executionState.getAdditionalImplementations(),
            executionState.getInputProperties(),
            prepareForSerialization(executionState.getInputFileProperties()),

    @Override
    public void store(String key, AfterExecutionState executionState) {
        executionHistory.put(key, new DefaultPreviousExecutionState(
            executionState.getOriginMetadata(),
            executionState.getCacheKey(),
            executionState.getImplementation(),
            executionState.getAdditionalImplementations(),
            executionState.getInputProperties(),

            for (WorkerState worker : workers) {
                ExecutionState currentState = worker.state.get();
                if (currentState == ExecutionState.Running) {
                    return null;
                } else if (currentState == ExecutionState.Waiting) {
                    waitingWorkers++;
                } else if (currentState == ExecutionState.Stopped) {
                    stoppedWorkers++;
                }

        1 * workerLease.tryLock() >> true
        1 * workSource.executionState() >> WorkSource.State.MaybeWorkReadyToStart
        1 * workSource.selectNext() >> WorkSource.Selection.of(node)
        1 * worker.execute(node)
        1 * workSource.finishedExecuting(node, null)

        then:
        1 * cancellationHandler.isCancellationRequested() >> false
        1 * workSource.executionState() >> WorkSource.State.NoMoreWorkToStart

        then:

    {
      tensorflow::mutex_lock l(execution_mutex_);
      while (execution_state_ == ExecutionState::kIdle ||
             execution_state_ == ExecutionState::kHasResult) {
        start_execute_.wait(l);
      }
      if (execution_state_ == ExecutionState::kShuttingDown) {
        return;
      } else if (execution_state_ == ExecutionState::kReadyToExecute) {
        // op_outputs_ may have been std::moved

        1 * executionHistoryStore.store(
            identity.uniqueId,
            { AfterExecutionState executionState ->
                executionState.outputFilesProducedByWork == finalOutputs
                executionState.originMetadata == originMetadata
                executionState.successful >> successful
            }
        )
    }

package org.gradle.internal.execution.history;

import java.util.Optional;

public interface ExecutionHistoryStore {
    Optional<PreviousExecutionState> load(String key);

    void store(String key, AfterExecutionState executionState);

    void remove(String key);

    }

    @Override
    protected ExecutionState getInitialState() {
        switch (getTarget().getTaskState()) {
            case Scheduled:
            case NotScheduled:
                return null;
            case Success:
                return ExecutionState.EXECUTED;
            case Failed:
                return ExecutionState.FAILED_DEPENDENCY;
            default:

                BeforeExecutionState executionState = captureExecutionStateWithOutputs(work, context, unfilteredOutputSnapshots, overlappingOutputs);
                operationContext.setResult(Operation.Result.INSTANCE);
                return executionState;
            },
            BuildOperationDescriptor