path               string
		handler            http.HandlerFunc
		statusCode         int
		contentType        string
		contentDisposition string
		resp               []byte
	}{
		{"/debug/pprof/<script>scripty<script>", Index, http.StatusNotFound, "text/plain; charset=utf-8", "", []byte("Unknown profile\n")},
		{"/debug/pprof/heap", Index, http.StatusOK, "application/octet-stream", `attachment; filename="heap"`, nil},

func newScriptEngine() *script.Engine {
	conds := script.DefaultConds()

	interrupt := func(cmd *exec.Cmd) error { return cmd.Process.Signal(os.Interrupt) }
	gracePeriod := 30 * time.Second // arbitrary

	cmds := script.DefaultCmds()
	cmds["at"] = scriptAt()
	cmds["bzr"] = script.Program("bzr", interrupt, gracePeriod)
	cmds["fossil"] = script.Program("fossil", interrupt, gracePeriod)

/**
 * <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

 * 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;

    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:

    }

    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
    }

        }

        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") << ""

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")