when:
        succeeds ":extractSymbolsDebug"

        then:
        executedAndNotSkipped":extractSymbolsDebug"
        fixture("build/symbols").assertHasDebugSymbolsFor(withoutHeaders(app.original))
    }

    @ToBeFixedForConfigurationCache
    def "extract is skipped when there are no changes"() {
        when:
        succeeds ":extractSymbolsDebug"

        then:

    }

    @ToBeFixedForConfigurationCache
    def "strip is skipped when there are no changes"() {
        when:
        succeeds ":stripSymbolsDebug"

        then:
        executedAndNotSkipped":stripSymbolsDebug"

        when:
        succeeds ":stripSymbolsDebug"

        then:
        skipped":stripSymbolsDebug"

    }
    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) {

        and:
        def fileRepo = maven(sampleDir.file("build/repo"))
        def module = fileRepo.module("org.gradle.sample", "quickstart", "1.0").withModuleMetadata()

        when:
        succeeds "publish"

        then:
        def pom = module.parsedPom
        module.assertPublishedAsJavaModule()
        pom.scopes.isEmpty()

        where:
        dsl << ['groovy', 'kotlin']
    }

            }
        """

        expect:
        succeeds 'help'
    }


    def "other blocks can follow the pluginManagement block"() {
        given:
        settingsFile << """
            pluginManagement {}
            rootProject.name = 'rumpelstiltskin'
        """

        expect:
        succeeds 'help'
    }

        when:
        server.resetExpectations()
        module.pom.expectGet()
        module.artifact.expectGet()

        then:
        succeeds('showMissing')

        when:
        server.resetExpectations()

        then:
        succeeds('showMissing')
    }

    void "reports and recovers from multiple missing modules"() {
        given:
        def repo = mavenHttpRepo("repo1")

                includeBuild("${build1.buildName}")
            }
        """
        build1.settingsFile << """
            includeBuild("../${build2.buildName}")
        """

        then:
        succeeds()
    }

    def "can nest early included plugin builds"() {
        when:
        settingsFile << """
            pluginManagement {
                includeBuild("${build1.buildName}")
            }

                    }
                }
            }

            ${printClasspathTask()}
        """
        def repoModule = javaLibrary(mavenRepo.module('org', "root", '1.0'))

        when:
        succeeds "publish"

        then:
        // POM uses resolved variant coordinates
        def dependencies = repoModule.parsedPom.scopes.runtime.dependencies
        dependencies.size() == 1

            }
        '''
        expect:
        succeeds(':consumer:resolve')
    }

    def 'consumer resolves javadoc variant of producer'() {
        file('consumer/build.gradle') << '''
            resolveJavadoc {
                expectations = [ 'producer-javadoc.txt' ]
            }
        '''
        expect:
        succeeds(':consumer:resolveJavadoc')
    }

                            url = "${repo.url}"
                        }
                    }
                }
            }
        """

        expect:
        succeeds('assemble')

        when:
        succeeds('clean', 'assemble')

        then:
        // Git repo is cloned
        def gitCheckout = checkoutDir(repo.name, commit.id.name, repo.id)
        gitCheckout.file('.git').assertExists()