def "methods defined in script are available to used script plugins"() {
        given:
        buildScript """
          def addTask(project) {
            project.tasks.create("hello").doLast { println "hello from method" }
          }

          apply from: "script.gradle"
        """

        file("script.gradle") << "addTask(project)"

        when:
        succeeds "hello"

                id("java")
            }
            println("script log statement")
        """

        when:
        configurationCacheRun("assemble")

        then:
        outputContains("script log statement")

        when:
        configurationCacheRun("assemble")

        then:
        outputDoesNotContain("script log statement")
    }

    private
    fun randomScriptContent() =
        "println(\"${UUID.randomUUID()}\")"
}


private
fun hasBody(script: String) =
    ProgramParser.parse(ProgramSource("script.gradle.kts", script), TopLevel, ProgramTarget.Project).document.let {
        it is Program.Script || it is Program.Staged
    }


private
data class MultiProjectCachedScripts(
    val settingsFile: CachedScript.WholeFile,

    }

    def "same script can be applied from init script, settings script and build script"() {
        root {
            'common.gradle'("""
                ${this.instrument('"common"')}
            """)
            'init.gradle'('''
                // init script
                apply from: 'common.gradle'
            ''')

Plugins can be implemented as *binary plugins*, *precompiled script plugins*, or *script plugins*:

Binary Plugins :: Binary plugins are compiled plugins typically written in Java or Kotlin DSL that are packaged as JAR files.
They are applied to a project using the `plugins {}` block.
They offer better performance and maintainability compared to script plugins or precompiled script plugins.

    def "reports plugin configuration results for remote script plugins"() {
        given:
        toolingApi.requireIsolatedUserHome() // So that the script is not cached
        server.start()
        def scriptUri = server.uri("script.gradle")
        server.expect(server.get("script.gradle").send("""
            apply plugin: 'java'
        """))
        file("build.gradle") << """

import org.junit.Test
import org.junit.experimental.categories.Category
import java.io.File
import kotlin.reflect.KClass
import kotlin.script.dependencies.KotlinScriptExternalDependencies
import kotlin.script.dependencies.ScriptContents
import kotlin.script.dependencies.ScriptContents.Position
import kotlin.script.dependencies.ScriptDependenciesResolver.ReportSeverity


@Category(Flaky::class) // https://github.com/gradle/gradle-private/issues/3717

    def "init script file is a dotfile"() {
        def initScript = file('.empty')
        initScript << 'println "greetings from empty init script"'
        executer.withArguments('--init-script', initScript.absolutePath)

        when:
        run()

        then:
        output.contains("greetings from empty init script")
    }

    private def createExternalJar() {

        applyInlinePlugin(buildFile, 'Project', addProjectListeners('root project plugin'))
        applyScript(buildFile, scriptFile)

        subBuildFile << addGradleListeners('sub project script')
        subBuildFile << addProjectListeners('sub project script', ':')
        subBuildFile << addProjectListeners('sub project script', ':sub')

    String scriptUrl
    TestFile scriptFile
    String scriptName = "remote-script.gradle"
    def configurationCache

    def setup() {
        server.start()

        scriptUrl = "${server.uri}/${scriptName}"
        scriptFile = file("remote-script.gradle") << """
            println 'loaded remote script'
        """
        server.expectGet "/$scriptName", scriptFile

        buildFile << """