doLast { assert false }
            }
        '''
        configurationCacheFails 'fail'

        then: 'flow action reacts to build failure'
        outputContains '(red)'
        configCache.assertStateStored()

        when: 'task from cache fails'
        configurationCacheFails 'fail'

        then: 'flow action reacts to build failure'
        outputContains '(red)'

        buildFile.text = """
        task aTask
        """
        when:
        configurationCacheFails "help", "--task", "bTask"
        then:
        failure.assertHasCause("Task 'bTask' not found in root project")
        configurationCache.assertStateStored()

        when:
        configurationCacheFails "help", "--task", "cTask"
        then:
        failure.assertHasCause("Task 'cTask' not found in root project")

        when:
        runWithEncryption(EncryptionKind.ENV_VAR, ["help"], [], [(GRADLE_ENCRYPTION_KEY_ENV_KEY): invalidEncryptionKey], this::configurationCacheFails)

        then:
        // since the key is not fully validated until needed, we only get an error when encrypting
        failure.assertHasDescription("Error while encrypting")

        given:
        addTasksWithProblems()

        when:
        configurationCacheFails("declared", "notDeclared")

        then:
        result.assertTasksExecuted(":declared", ":notDeclared")
        assertStateStoredAndDiscardedForDeclaredAndNotDeclaredTasks()

        when:
        configurationCacheFails("declared", "notDeclared")

        then:

                    assert countingService.getOrNull() == null
                }
            }
        """
        def configurationCache = newConfigurationCacheFixture()

        when:
        configurationCacheFails(":failedCount")

        then:
        configurationCache.assertStateStored()
        failureDescriptionContains("Execution failed for task ':failedCount'.")

                providers.of(BrokenValueSource) {}.get()
            } catch (Throwable ex) {
                $exceptionHandlerImpl
            }
        """)

        when:
        configurationCacheFails()

        then:
        outputContains("Configuration cache entry discarded with 1 problem.")
        failure.assertHasFailures(expectedFailuresCount)
        problems.assertFailureHasProblems(failure) {

        def configurationCache = newConfigurationCacheFixture()

        when:
        prepareMavenHttpRepository(projectConfig.remoteRepo, new DefaultPasswordCredentials(username, password))
        configurationCacheFails(*(projectConfig.tasks))
        server.resetExpectations()

        then:
        configurationCache.assertStateStoreFailed()
        outputContains("Configuration cache entry discarded")

            task ok(type: my.LambdaTask) {
                addSupplierWithConfiguration()
                addSupplierWithSourceDirectorySet()
            }
        """

        when:
        configurationCacheFails("ok")

        then:
        fixture.assertStateStoredAndDiscarded {
            [Configuration.class, SourceDirectorySet.class].each {
                serializationProblem(

            $command
            def process = $processCreator
            process.waitForProcessOutput(System.out, System.err)
        }

        runStuff()
        """)

        when:
        configurationCacheFails(":help")

        then:
        failure.assertOutputContains("FOOBAR=$expectedEnvVar\nCWD=${cwd.path}")
        problems.assertFailureHasProblems(failure) {
            def line = 7 + command.readLines().size()

            }
        """

        when:
        configurationCacheFails "printString"

        then:
        failureDescriptionContains missingValueMessage { type('Build_gradle.PrintString').property('string') }
        configurationCache.assertStateStored()

        when:
        configurationCacheFails "printString"

        then: