b.artifact.expectGet()

        expect:
        succeeds("checkDebug")

        and:
        server.resetExpectations()
        a.artifact(classifier: 'release').expectGet()
        c.pom.expectGet()
        c.artifact.expectGet()

        and:
        succeeds("checkRelease")

        and:
        succeeds("checkDebug")
        succeeds("checkRelease")
    }

        projectARepo1.artifact.expectGet()

        then:
        succeeds 'retrieve'

        and:
        file('libs').assertHasDescendants('projectA-1.0.jar')
        file('libs/projectA-1.0.jar').assertIsCopyOf(projectARepo1.artifactFile)

        // Check caching
        when:
        server.resetExpectations()
        then:
        succeeds 'retrieve'

        where:

        """

        when:
        executer.withJavaHome AvailableJavaHomes.getLowestSupportedLTS().javaHome
        succeeds "compileJava"
        then:
        executedAndNotSkipped ":compileJava"

        when:
        executer.withJavaHome AvailableJavaHomes.getLowestSupportedLTS().javaHome
        succeeds "compileJava"
        then:
        skipped ":compileJava"

        when:

    def setup() {
        settingsFile << """
            rootProject.name = "myLib"
        """
    }

    def "if no configurations present in project, task reports complete absence"() {
        expect:
        succeeds ':resolvableConfigurations'
        reportsCompleteAbsenceOfResolvableConfigurations()
    }

    def "if only consumable configurations present, task reports complete absence"() {
        given:
        buildFile << """

        when:
        succeeds "t"

        then:
        plugin.assertBuildScanRequest(output, NONE)
        plugin.assertAutoApplied(output, false)
    }

    def "is requested with --scan"() {
        given:
        if (!autoApplied) {
            settingsFile << plugin.plugins()
        }

        when:
        succeeds "t", "--scan"

        then:

            }
        """
        publishJavaModule('moda')
        consumingModuleInfo('requires moda')
        consumingModuleClass('moda.ModaClass')

        when:
        succeeds ':run'

        then:
        outputContains("Module Name: consumer")
        outputContains("Module Version: 1.0-beta2")
    }

    }
    things {
        main(Thing) {
            value = $.broken.value
        }
        test(Thing) {
            value = "12"
        }
    }
}
'''
        when:
        succeeds "show"

        then:
        outputContains("value = 12")
    }

    def "nested configure rule is executed only as required"() {
        buildFile << '''
model {
    tasks {
        show(Task) {

                suites {
                    eagerTest(JvmTestSuite)
                    register("registerTest", JvmTestSuite)
                }
            }
        """

        expect:
        succeeds("eagerTest")
        succeeds("registerTest")
    }

    def "built-in test suite does not have any testing framework set at the test suite level"() {
        buildFile << """
            plugins {
                id 'java'

                }
            }
        """

        when:
        succeeds 'assemble'

        then: "jar is built but not published"
        repoModule.assertNotPublished()
        localModule.assertNotPublished()
        file('build/libs/root-1.0.jar').assertExists()

        when:
        succeeds 'publish'

        then: "jar is published to defined maven repository"

        setupProjectInOriginalLocation()

        when:
        succeeds taskName
        def originalResults = extractResults()
        then:
        executedAndNotSkipped taskName

        when:
        succeeds taskName
        then:
        skipped taskName

        when:
        moveFilesAround()
        succeeds taskName
        then:
        skipped(taskName)

        when: