when:
        failure = executer
                .withTasks("compileJava")
                .requireOwnGradleUserHomeDir()
                .withToolchainDownloadEnabled()
                .runWithFailure()

        then:
        failure.assertHasDescription("Could not determine the dependencies of task ':compileJava'.")

        executer.withTasks(tasks)
        executer.run()
    }

    ExecutionFailure fails(String... tasks) {
        executer.withTasks(tasks)
        executer.runWithFailure()
    }

        server.start()

        prepareWrapperWithGradleBin()

        when:
        def failure = wrapperExecuter
            .withStackTraceChecksDisabled()
            .runWithFailure()

        then:
        failure.error.matches(/[\S\s]*Downloaded distribution file .* is no valid zip file\.[\S\s]*/)
    }

    def "wrapper gets bad archive on 1 attempt and good hash"() {
        given:

        prepareWrapper(malformedDistZip.toURI())

        when:
        failure = wrapperExecuter
            .withTasks("emptyTask")
            .withStackTraceChecksDisabled()
            .runWithFailure()

        then:
        failure.assertOutputContains("Could not unzip")
        failure.assertNotOutput("Could not set executable permissions")
    }

            .withStackTraceChecksDisabled()
            .runWithFailure()
            .assertions()

        gradleExecuterFor(arrayOf("--rerun-tasks", "classes", "-Dorg.gradle.kotlin.dsl.precompiled.accessors.strict=true"))
            .withStackTraceChecksDisabled()
            .runWithFailure()
            .assertions()
    }

    @Test

                    println "remove me!"
                }
            }
        """.stripIndent()

        when:
        def failure = executer.withTasks('test').runWithFailure()

        then:
        failure.output.contains("Test ${maybeParentheses('showsOutputWhenPassing')}(SomeTest) StdOut out passing")

                //  We need to figure out how to separate expected failure from the CC store failure.
                ExecutionFailure result = executer.runWithFailure();
                outputStream.write((result.getOutput() + result.getError()).getBytes());
            } else {
                ExecutionResult result = executer.run();

           ${imports()}
           ${waitForExpirationTask()}
        """
        openJpmsModulesForConfigurationCache()
        def waitForExpirationResult = executer.withArgument('waitForExpiration').runWithFailure()

        then:
        waitForExpirationResult.assertHasCause("Timed out waiting for expiration event")

        and:
        !file(EXPIRATION_EVENT).exists()
    }

        when:
        def projectA = ivySftpRepo.module('org.group.name', 'projectA', '1.2')
        projectA.ivy.expectMetadataRetrieveBroken()

        and:
        failure = executer.withTasks('retrieve').runWithFailure()

        then:
        assertTaskFailureDescription(":retrieve")
        failure.assertHasCause("Could not resolve all files for configuration ':compile'.")

        ExecutionFailure failure = inTestDirectory().withTasks("test").runWithFailure();
        failure.assertHasCause("broken");
    }

    @Test
    public void gradleImplementationClassesDoNotLeakOntoBuildScriptClassPathWhenUsingBuildSrc() {