buildFile << """
            task unspecified(type: UnspecifiedCacheabilityTask) {}
        """
        when:
        withBuildCache().run "unspecified"
        then:
        assertCachingDisabledFor NOT_ENABLED_FOR_TASK, "Caching has not been enabled for the task"
    }

    def "cacheability for a cacheable task is null"() {
        buildFile << """

        buildFile """
            unknown(12, "things")
        """

        expect:
        fails()
        failure.assertHasLineNumber(2)
        failure.assertHasCause("Could not find method unknown() for arguments [12, things] on root project 'test' of type ${Project.name}.")
    }

    def failsWhenGettingUnknownPropertyOnTask() {
        buildFile """
            task p

        }
    }

    def "reports task action execution fails with error"() {
        buildFile << """
            task('do-stuff').doFirst {
                throw new ArithmeticException('broken')
            }
        """
        expect:
        fails "do-stuff"

        failure.assertHasFileName(String.format("Build file '%s'", buildFile))
        failure.assertHasLineNumber(3)

    def "setup"() {
        buildFile << """
@Managed
interface SampleBinary extends BinarySpec {
    String getVersion()
    void setVersion(String version)
}
"""
    }

    def "custom managed binary type can be registered and created"() {
        when:
        buildWithCustomBinaryPlugin()

        and:
        buildFile << '''
model {
    tasks {
        checkModel(Task) {

 */
class ResolveFailureTestFixture {
    String config
    private final TestFile buildFile

    ResolveFailureTestFixture(TestFile buildFile, String config = "compile") {
        this.buildFile = buildFile
        this.config = config
    }

    void prepare(String config = this.config) {
        buildFile << """
            allprojects {
                tasks.register("checkDeps") {

        module = getMavenS3Repo().module("org.gradle", "test", artifactVersion)
    }

    def "resolves a maven snapshot module stored in S3"() {
        setup:
        module.publish()

        buildFile << mavenAwsRepoDsl()
        buildFile << """
configurations { compile }

dependencies{
    compile 'org.gradle:test:1.45-SNAPSHOT'
}

task retrieve(type: Sync) {
    from configurations.compile
    into 'libs'
}
"""

    }

    def "Gradle API and TestKit are compatible regardless of order #dependencyPermutations"() {
        when:
        buildFile << applyGroovyPlugin()
        buildFile << mavenCentralRepository()
        buildFile << """
            testing {
                suites {
                    test {
                        useSpock()
                    }
                }

    void withMainSourceSet() {
        buildFile << """
            model {
                testSuites {
                    main {
                        sources {
                            main(CustomLanguageSourceSet)
                        }
                    }
                }
            }
        """
    }

    void withTestBinaryFactory() {
        buildFile << """

@Requires(UnitTestPreconditions.StableGroovy)
class CodeNarcPluginVersionIntegrationTest extends MultiVersionIntegrationSpec implements CodeNarcTestFixture {
    def setup() {
        buildFile << """
            apply plugin: "groovy"
            apply plugin: "codenarc"

            ${mavenCentralRepository()}

            codenarc {
                toolVersion = '${version}'
            }

class TaskPropertiesIntegrationTest extends AbstractIntegrationSpec {
    def "can define task with abstract read-only Property<T> property"() {
        given:
        buildFile << """
            abstract class MyTask extends DefaultTask {
                @Internal
                abstract Property<Integer> getCount()

                @TaskAction
                void go() {