script << """
            task doStuff
        """

        buildFile << """
            apply from: resources.text.fromInsecureUri("$server.uri/external.gradle")
            defaultTasks 'doStuff'
        """

        then:
        succeeds()
    }

    def "can apply script via https"() {
        applyTrustStore()

        when:
        def script = file('external.gradle')

        given:
        buildFile << """
            project(':app') {
                apply plugin: 'cpp-application'
                dependencies {
                    implementation project(':hello')
                }
            }
            project(':hello') {
                apply plugin: 'cpp-library'
            }
        """
        app.greeter.writeToProject(file("hello"))

        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: