public class ValidationFinishedContext extends BeforeExecutionContext {

    private final List<? extends Problem> validationProblems;

    public ValidationFinishedContext(BeforeExecutionContext parent, List<? extends Problem> validationProblems) {
        super(parent);
        this.validationProblems = validationProblems;
    }

    protected ValidationFinishedContext(ValidationFinishedContext parent) {

        FileCollection destroyableFiles,
        List<ValidatingProperty> validatingProperties,
        ReplayingTypeValidationContext validationProblems
    ) {
        this.validatingProperties = validatingProperties;
        this.validationProblems = validationProblems;

        this.inputProperties = inputProperties;
        this.inputFileProperties = inputFileProperties;

        when:
        step.execute(work, context)
        then:
        _ * buildCache.enabled >> false
        _ * context.beforeExecutionState >> Optional.empty()
        _ * context.validationProblems >> ImmutableList.of()
        1 * delegate.execute(work, { CachingContext context ->
            context.cachingState.whenDisabled().map { it.disabledReasons*.category }.get() == [CachingDisabledReasonCategory.BUILD_CACHE_DISABLED]

        testFile << """$header
            import org.gradle.integtests.fixtures.validation.ValidationProblem
            import org.gradle.api.problems.Severity

            abstract class SomeTask extends DefaultTask {
                @ValidationProblem(value=Severity.ERROR)
                abstract Property<String> getInput()

                @OutputFile

        );
    }

    private Severity annotationValue(PropertyMetadata propertyMetadata) {
        return propertyMetadata.getAnnotationForCategory(AnnotationCategory.TYPE)
            .map(ValidationProblem.class::cast)
            .map(ValidationProblem::value)
            .orElse(Severity.WARNING);
    }

        _ * context.previousExecutionState >> Optional.of(previousExecutionState)
        _ * previousExecutionState.cacheKey >> cacheKey
        _ * context.validationProblems >> ImmutableList.of()
        1 * delegate.execute(work, { CachingContext context ->
            def buildCacheKey = context.cachingState.cacheKeyCalculatedState.get().key

        _ * context.beforeExecutionState >> Optional.of(beforeExecutionState)
        _ * context.previousExecutionState >> Optional.of(previousExecutionState)
        _ * context.validationProblems >> ImmutableList.of(Mock(Problem))
        _ * context.previousExecutionState >> Optional.empty()
        0 * _
    }

    def "provides input file changes when history is available"() {

            @Provides
            ExecutionGlobalServices.AnnotationHandlerRegistration createAnnotationRegistration() {
                return () -> ImmutableList.of(ValidationProblem.class);
            }

            @Provides
            PropertyAnnotationHandler createValidationProblemAnnotationHandler() {
                return new ValidationProblemPropertyAnnotationHandler();
            }

        when:
        step.execute(work, context)
        then:
        _ * buildCache.enabled >> buildCacheEnabled
        _ * context.beforeExecutionState >> Optional.of(beforeExecutionState)

        _ * context.validationProblems >> ImmutableList.of()
        1 * delegate.execute(work, { CachingContext context ->
            context.cachingState.cacheKeyCalculatedState.isPresent()
        }) >> delegateResult

        where:

    def "work validation warnings are mentioned in summary"() {
        buildFile << """
            import org.gradle.integtests.fixtures.validation.ValidationProblem

            class InvalidTask extends DefaultTask {
                @ValidationProblem String dummy

                @TaskAction void execute() {
                    // Do nothing
                }
            }