when:
        def result = step.execute(work, context)

        then:
        result == delegateResult

        _ * work.executionBehavior >> UnitOfWork.ExecutionBehavior.NON_INCREMENTAL
        1 * delegate.execute(work, _ as IncrementalChangesContext) >> { UnitOfWork work, IncrementalChangesContext delegateContext ->
            def changes = delegateContext.changes.get()

    def result = Mock(Result)


    def "resolves input changes when required"() {
        when:
        def returnedResult = step.execute(work, context)
        then:
        _ * work.executionBehavior >> UnitOfWork.ExecutionBehavior.INCREMENTAL
        _ * context.changes >> optionalChanges
        1 * changes.createInputChanges() >> inputChanges
        1 * inputChanges.incremental >> true

        return new File(workspace, "results.bin");
    }

    @Override
    public ExecutionBehavior getExecutionBehavior() {
        return transform.requiresInputChanges()
            ? ExecutionBehavior.INCREMENTAL
            : ExecutionBehavior.NON_INCREMENTAL;
    }

    @Override
    public void visitImplementations(ImplementationVisitor visitor) {

import org.gradle.internal.execution.history.changes.InputChangesInternal;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;

import javax.annotation.Nullable;

import static org.gradle.internal.execution.UnitOfWork.ExecutionBehavior.NON_INCREMENTAL;

public class ResolveInputChangesStep<C extends IncrementalCachingContext, R extends Result> implements Step<C, R> {

    }

    @Override
    public ExecutionBehavior getExecutionBehavior() {
        for (InputChangesAwareTaskAction taskAction : task.getTaskActions()) {
            if (taskAction instanceof IncrementalTaskAction) {
                return ExecutionBehavior.INCREMENTAL;
            }
        }
        return ExecutionBehavior.NON_INCREMENTAL;
    }

    @Override

     */
    default ExecutionBehavior getExecutionBehavior() {
        return ExecutionBehavior.NON_INCREMENTAL;
    }

    /**
     * The execution capability of the work: can be incremental, or non-incremental.
     * <p>
     * Note that incremental work can be executed non-incrementally if input changes
     * require it.
     */
    enum ExecutionBehavior {
        /**