def "setup"() {
        withCustomComponentType()
        buildFile << """
            model {
                components {
                    main(CustomComponent)
                }
            }
        """
    }

    void withMainSourceSet() {
        withCustomLanguageType()
        buildFile << """
            model {
                components {
                    main {

        given:
        buildFile << """
            ${keyInfo.addAsPropertiesScript()}
            signing {
                ${signingConfiguration()}
                sign(jar)
            }
        """

        when:
        run "signJar"

        then:
        executedAndNotSkipped(":signJar")

        when:
        buildFile << """
            signing {

        annotationProcessorPublisher.publishedPomFile.isFile()

        when:
        buildFile << basicScalaProject()
        buildFile << annotationProcessorDependency(annotationProcessorPublisher.repoDir, annotationProcessorPublisher.dependencyCoordinates)
        buildFile << """
            configurations.annotationProcessor.extendsFrom configurations.compileOnly
        """

    }

    def "can depend on task with name in all included builds"() {
        when:
        BuildTestFile buildC = singleProjectBuild("buildC") {
            buildFile.text = buildB.buildFile.text
        }
        includedBuilds << buildC

        buildA.buildFile << """
    task delegate {
        dependsOn gradle.includedBuilds*.task(':logProject')
    }
"""

        execute(buildA, ":delegate")

        mainSources*.writeToDir(file("src/main"))
        asmSources*.writeToDir(file("src/input"))
        degenerateInputSources()

        when:
        buildFile << app.pluginScript
        buildFile << app.extraConfiguration
        buildFile << """
task generateAsmSources(type: GenerateSources) {
    inputDir project.file("src/input")
    sourceDir project.file("build/src/generated/asm")
}

model {

                }
            }
        }

        apply type: RulePlugin
        '''

    void 'only CharSequence input values are supported - #varname'() {
        when:
        buildFile << CLASSES
        buildFile << """
            model {
                props {
                    $varname = new Object()
                }
            }
            """

        then:

                sampleLibOtherBinary()
            }
        }
    }

    def "can register binaries using @ComponentBinaries rule"() {
        when:
        buildFile << withSimpleComponentBinaries()
        buildFile << '''

        model {
            tasks {
                checkModel(Task) {
                    doLast {
                        def binaries = $.binaries

        where:
        linkage << ["static", "shared"]
    }

    @Issue("GRADLE-3332")
    @NotYetImplemented
    def "can create helper task to install buildable executables"() {
        def helloWorldApp = new CppHelloWorldApp()
        given:
        buildFile << '''
apply plugin: 'cpp'

model {
    components {
        main(NativeExecutableSpec)
    }
}
task installDeveloperImage {

    def "project.buildFile is non null when build file does not exist"() {
        expect:
        !buildFile.exists()

        when:
        createDirs("child")
        settingsFile << "include 'child'"
        def initScript = file("init.gradle") << """
            rootProject { 
                assert buildFile.canonicalPath == '${buildFile.canonicalPath.replace("\\", "\\\\")}'

        buildFile << """
            javadoc {
                options.stylesheetFile = file('src/not-docs/custom.css')
            }
        """
        succeeds("javadoc")
        then:
        skipped(":javadoc")
    }

    def "can exclude a package by source path"() {
        buildFile << """
            plugins {
                id 'java'