class GradlePluginIntegrationTest extends AbstractIntegrationSpec {
    File initFile;

    def setup() {
        initFile = temporaryFolder.createFile("initscripts/init.gradle")
        executer.usingInitScript(initFile);
    }

    @ToBeFixedForConfigurationCache(because = "Gradle.buildFinished")
    def "can apply binary plugin from init script"() {
        when:
        initFile << """

        def initScriptFile = testDirectory.file(file)
        initScriptFile << """
            ${snippets.imports}
            ${snippets.body}
        """
        executer.usingInitScript(initScriptFile)

        when:
        configurationCacheFails(":help")

        then:
        failure.assertOutputContains("Hello")
        problems.assertFailureHasProblems(failure) {

                        gradlePluginPortal()
                    }
                }
            }
            """
        )
        executer.beforeExecute {
            usingInitScript(setupScript)
        }
    }

    protected
    fun doForceLocallyBuiltKotlinDslPlugins() {
        file(".integTest/force-local-plugins.init.gradle").apply {
            parentFile.mkdirs()

    def "produces reasonable error when Gradle.allprojects action fails"() {
        def initScript = initScript """
allprojects {
    throw new RuntimeException("broken")
}
"""
        when:
        executer.usingInitScript(initScript)
        fails "a"

        then:
        failure.assertHasDescription("broken")
                .assertHasNoCause()
                .assertHasFileName("Initialization script '$initScript'")

class GradleRunnerDefaultTestKitDirIntegrationTest extends BaseGradleRunnerIntegrationTest implements TestKitDependencyBlock {

    def setup() {
        executer.beforeExecute {
            usingInitScript(file("tempDirInit.gradle") << """
                allprojects {
                    tasks.withType(Test) {

        def initScript = file("init.gradle")
        initScript << IdeCommandLineUtil.generateGradleProbeInitFile('xcode', 'xcodebuild')

        executer.beforeExecute({
            usingInitScript(initScript)
        })
    }

    // TODO: Use AbstractInstalledToolChainIntegrationSpec instead once Xcode test are sorted out
    void requireSwiftToolChain() {

                            }
                        }
                    }
                }
            """
        }

        executer.beforeExecute({
            usingInitScript(initScript)
        })
    }

    NativeInstallationFixture installation(Object installDir, OperatingSystem os = OperatingSystem.current()) {
        return new NativeInstallationFixture(file(installDir), os)
    }

                }
            }
            beforeSettings {
                it.plugins.apply(test.SettingsPlugin)
            }
        """

        settingsFile.touch()

        executer.usingInitScript(initScriptFile)
        executer.withArgument("--profile")

        when:
        succeeds 'help'
        then:
        output.contains("Hello from settings plugin")
        findReport()
    }

    apply plugin: ${toolChain.pluginClass}

    model {
          toolChains {
            ${toolChain.buildScriptConfig}
          }
    }
}
"""
        executer.beforeExecute({
            usingInitScript(initScript)
        })

        settingsFile << "rootProject.name = 'app'"
        buildFile << """
            apply plugin: 'xctest'
        """
    }

    @Override

        this.initScript = projectDir.testDirectory.file(FIXTURE_SCRIPT_NAME)
        this.initScript.text = injectNotificationListenerBuildLogic()
        executer.beforeExecute {
            it.usingInitScript(this.initScript)
        }
    }

    static String injectNotificationListenerBuildLogic() {
        """
            rootProject {
                if(gradle.isRootBuild()) {