buildFile << """
            ${requiresPlugins ? requiresPlugins.collect { "apply plugin: '${it}'" }.join('\n') : ''}
            ${callbackClass(containerAccess, callbackName)}
            ${addingPluginClass(containerItemCreation)}
            apply plugin: CallbackPlugin
            apply from: 'callbackScript.gradle'
            apply plugin: AddingPlugin
        """

        when:
        run('help')

        then:

                @ComponentType
                private void broken(TypeBuilder<?> builder) {
                }
            }
            apply plugin: Broken
        """

        expect:
        fails "help"
        failure.assertHasCause("Failed to apply plugin class 'Broken'")
        failure.assertHasCause("""Type Broken is not a valid rule source:

        file("buildSrc/build.gradle") << """
            allprojects {
                apply plugin: 'java'
            }
        """
        buildFile << """
            allprojects {
                apply plugin: 'java'
            }
        """
        file("included/build.gradle") << """
            allprojects {
                apply plugin: 'java'
            }
        """

        when:

        toggleCompileClasspathPackaging(compileClasspathPackaging)

        given:
        subproject('a') {
            'build.gradle'('''
                apply plugin: 'java-library'
                dependencies {
                    api project(':b')
                }
            ''')
            src {
                main {
                    java {

        buildFile << """
        apply plugin: 'language-base'

        model {
            functionalSources(FunctionalSourceSet)
        }
        """

        expect:
        succeeds "model"
    }

    def "model report renders a functional source set and elements"() {
        buildFile << """
        apply plugin: 'language-base'

        ${registerJavaLanguage()}

            class MyPlugin implements Plugin<Project> {
                public void apply(Project project) {
                    project.getPlugins().apply(ComponentModelBasePlugin.class);
                    project.getPlugins().apply(JavaBasePlugin.class);
                }

                static class Rules extends RuleSource {
                    @Model("android")

        val previous = resolvedScriptDependencies(editedScript).apply {
            assertContainsBasicDependencies()
        }

        val wrongEnv = arrayOf("gradleHome" to existing("absent"))
        resolvedScriptDependencies(editedScript, previous, *wrongEnv).apply {
            assertSame(previous, this)
        }

        recorder.apply {
            assertLastEventIsInstanceOf(ResolutionFailure::class)

            project(":c") {
                apply plugin: 'java'
                dependencies {
                    implementation project(':d')
                    compileOnly project(':e')
                }
            }
            project(":d") {
                apply plugin: 'java'
            }
            project(":e") {
                apply plugin: 'java'
            }
        """

        when:

            rootProject.name = 'app'
            include 'one', 'two', 'three'
        """
        buildFile << """
            apply plugin: 'cpp-application'

            project(':one') {
                apply plugin: 'cpp-application'
            }
            project(':two') {
                apply plugin: 'cpp-library'
            }
        """

        and:
        run ":visualStudio"

        then:

                }
            }
            apply plugin: CustomManagedLSSPlugin

            class TestRules extends RuleSource {
                @Defaults
                void useInternalView(@Path("components.sampleLib.sources.managed") CustomManagedLSS lss) {
                    lss.setSomeProperty("default value")
                }
            }
            apply plugin: TestRules

            model {