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

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

        annotationProcessorPublisher.publishedPomFile.isFile()

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

        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:

        when:
        run "someTask"

        then:
        skipped(":someTask")
    }

    def "can use null value for task input property"() {
        buildFile << customSerializableType()
        buildFile << customTaskType()

        buildFile << """
task someTask(type: SomeTask) {
    v = null
    f = file("build/out")
}
"""

        given:
        run "someTask"

        when:

    def setup() {
        resolve = new ResolveTestFixture(buildA.buildFile)

        buildA.buildFile << """
            task resolveArtifacts(type: Copy) {
                from configurations.compileClasspath
                into 'libs'
            }
        """

        buildB = multiProjectBuild("buildB", ['b1', 'b2']) {
            buildFile << """
                allprojects {

                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 {

        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'

        given:
        file("input.txt") << "data"
        buildFile << adHocTaskWithInputs()

        expect:
        taskIsNotCached ':adHocTask'
    }

    def "ad hoc tasks are cached when explicitly requested"() {
        given:
        file("input.txt") << "data"
        buildFile << adHocTaskWithInputs()
        buildFile << 'adHocTask { outputs.cacheIf { true } }'

        expect: