/**
 * <p>This interface is implemented by all Gradle Groovy DSL scripts to add in some Gradle-specific methods. As your compiled
 * script class will implement this interface, you can use the methods and properties declared by this interface
 * directly in your script.</p>
 *
 * <p>Generally, a {@code Script} object will have a delegate object attached to it. For example, a build script will

	55:   {region: 0x166, script: 0x5b, flags: 0x0},
	56:   {region: 0x166, script: 0x5b, flags: 0x0},
	57:   {region: 0x166, script: 0x5b, flags: 0x0},
	58:   {region: 0x6c, script: 0x5, flags: 0x0},
	59:   {region: 0x0, script: 0x3, flags: 0x1},
	60:   {region: 0x166, script: 0x5b, flags: 0x0},
	61:   {region: 0x51, script: 0x5b, flags: 0x0},
	62:   {region: 0x3f, script: 0x5b, flags: 0x0},
	63:   {region: 0x68, script: 0x5, flags: 0x0},

    def "can use apply block syntax to apply multiple scripts"() {
        given:
        buildScript """
          apply {
            from "script1.gradle"
            from "script2.gradle"
          }
        """

        file("script1.gradle") << "task hello1 { doLast { println 'hello from script1' } }"
        file("script2.gradle") << "task hello2 { doLast { println 'hello from script2' } }"

        when:

 * limitations under the License.
 */

package org.gradle.groovy.scripts;

import org.gradle.internal.logging.StandardOutputCapture;
import org.gradle.internal.service.ServiceRegistry;

/**
 * The base class for all scripts executed by Gradle.
 */
public abstract class Script extends groovy.lang.Script {
    private ScriptSource source;
    private ClassLoader contextClassloader;

    }

    void scriptsAreReused(List<ClassDetails> before, List<ClassDetails> after) {
        assert before.size() == after.size()
        for (int i = 0; i < before.size(); i++) {
            def script1 = before[i]
            def script2 = after[i]
            assert script1.path == script2.path
            assert script1.className == script2.className
            assert script1.classpath == script2.classpath

        def scripts = []

        given:
        def script1 = distDir.createFile("init.d/script1.gradle")
        def script2 = distDir.createFile("init.d/script2.gradle")
        distDir.createFile("init.d/readme.txt")
        distDir.createFile("init.d/lib/test.jar")

        when:
        finder.findScripts(scripts)

        then:
        scripts.size() == 2
        script1 in scripts
        script2 in scripts
    }

File: script.kts

    def "does nothing when there are no init scripts"() {
        given:
        startParameter.allInitScripts >> []

        when:
        handler.executeScripts(gradle)

        then:
        0 * executor._
        0 * processor._
    }

    def "finds and processes init scripts"() {
        File script1 = testDirectoryProvider.createFile("script1.gradle")
        File script2 = testDirectoryProvider.createFile("script2.gradle")

        }

        op.details.file == script.absolutePath
        op.details.targetPath == null
        op.details.buildPath == null
    }

    @Rule
    HttpServer httpServer = new HttpServer()


    def "captures for http scripts"() {
        given:
        println testDirectory.absolutePath
        httpServer.start()
        def script = file("script.gradle") << ""

}

// scriptCC runs the C compiler along with platform specific options.
func scriptCC(cmdExec script.Cmd) script.Cmd {
	return script.Command(
		script.CmdUsage{
			Summary: "run the platform C compiler",
			Args:    "args...",
		},
		func(s *script.State, args ...string) (script.WaitFunc, error) {
			b := work.NewBuilder(s.Getwd())
			wait, err := cmdExec.Run(s, append(b.GccCmd(".", ""), args...)...)
			if err != nil {