abstract class KotlinInitScript(
    private val host: KotlinScriptHost<Gradle>
) : @Suppress("DEPRECATION") InitScriptApi(host.target) {

    /**
     * The [ScriptHandler] for this script.
     */
    val initscript: ScriptHandler
        get() = host.scriptHandler

    /**
     * Applies zero or more plugins or scripts.
     * <p>

        val fileTreeFromMap = """
            fileTree(mapOf("dir" to ".", "include" to listOf("*.txt")))
                .joinToString { it.name }
        """

        withFile("foo.txt")

        val initScript = withFile(
            "init.gradle.kts",
            """
            println("INIT: " + $fileTreeFromMap)
            """
        )

        withSettings(
            """

        then:
        succeeds 'check'

        where:
        source        | sourceFile
        "buildscript" | "build.gradle"
        "settings"    | "settings.gradle"
        "initscript"  | "init.gradle"
    }

    @ToBeFixedForConfigurationCache(because = "remote scripts skipped")
    def "can recover from failure to download cached #source resource by running with --offline"() {
        given:

         * @see org.gradle.internal.cc.impl.DefaultIgnoredConfigurationInputs
         */
        val ignoredFileSystemCheckInputPaths: String?
    ) : ConfigurationCacheFingerprint()

    data class InitScripts(
        val fingerprints: List<InputFile>
    ) : ConfigurationCacheFingerprint()

    data class WorkInputs(
        val workDisplayName: String,
        val fileSystemInputs: FileCollectionInternal,

                id("org.acme.my-other-plugin") version "1.0"
            }
            """
        )

        val initScript =
            withFile(
                "my-init-script.init.gradle.kts",
                """

                initscript {
                    $repositoriesBlock
                    dependencies {
                        classpath("org.acme:plugins:1.0")

sealed class Program {

    /**
     * A program with no observable side-effects.
     */
    object Empty : Program() {

        override fun toString() = "Empty"
    }

    /**
     * A `buildscript` / `initscript` block.
     */
    data class Buildscript(override val fragment: ProgramSourceFragment) : Stage1(), FragmentHolder

    /**
     * A `pluginManagement` block.
     */

    @Rule
    BlockingHttpServer server = new BlockingHttpServer()

    @Issue("https://issues.gradle.org/browse/GRADLE-2032")
    def "can simultaneously run gradle on projects with buildSrc"() {
        initScript """
            import ${BuildOperationListenerManager.name}
            import ${BuildOperationListener.name}
            import ${BuildOperationDescriptor.name}
            import ${OperationStartEvent.name}

    @Issue('gradle/gradle-native#206')
    @ToBeFixedForConfigurationCache
    def 'can define and use source repositories with initscript resolution present'() {
        given:
        def commit = repo.commit('initial commit')
        temporaryFolder.file('initialize.gradle') << """
        initscript {
            dependencies {
                classpath files('classpath.file')
            }
        }

    def "#scriptType script classpath configurations are exposed"() {
        setup:
        def m1 = mavenHttpRepo.module('org.foo', 'root-dep').publish()

        def initScript = file('init.gradle')
        initScript << ''
        executer.usingInitScript(initScript)

        file('scriptPlugin.gradle') << '''
        task foo
        '''

        buildFile << '''
        apply from: 'scriptPlugin.gradle'
        '''

            .withTasks("publish")
            .run()
    }

    private ExecutionResult pluginsAppliedWith(GradleDistribution distribution) {
        file("consumer/init.gradle.kts").text = """
            initscript {
                repositories {
                    maven(url = "${mavenRepo.uri}")
                }
                dependencies {
                    classpath("com.example:plugin:1.0")
                }