then:
        result.method == method
        result.arguments == [1, 2] as Object[]
    }

    interface Thing {
        String doStuff(Thing[] things)
    }

    def "serializes a method invocation with array type parameters"() {
        def method = Thing.class.getMethod("doStuff", Thing[].class)
        def invocation = new MethodInvocation(method, [[] as Thing[]] as Object[])

        when:

        server.expectGet('/external.gradle', script)

        script << """
            task doStuff
            assert buildscript.sourceFile == null
            assert "${server.uri}/external.gradle" == buildscript.sourceURI as String
"""

        buildFile << """
            apply from: '$server.uri/external.gradle'
            defaultTasks 'doStuff'
"""

        when:

} finally {
    if (initscript.classLoader instanceof Closeable) {
        initscript.classLoader.close()
    }
}
"""

        and:
        buildFile << 'task doStuff'

        when:
        result = executer.usingInitScript(initScript).withTasks('doStuff').run()

        then:
        outputContains('quiet message')
        result.assertHasErrorOutput('error message')
    }

            task build(type: GradleBuild) {
                dir = 'other'
                tasks = ['dostuff']
            }
'''

        and:
        file('other/settings.gradle') << "rootProject.name = 'other'"
        file('other/build.gradle') << '''
            assert gradle.parent != null
            task dostuff {
                doLast {
                    assert gradle.parent != null
                }
            }

package org.gradle.groovy.compile.GroovyCompilerIntegrationSpec.canUseBuiltInAstTransform.src.test.groovy

class TestDelegate {
    def doStuff(String value) {
        return "[$value]"
    }

try {
    buildscript.classLoader.loadClass('${implClassName}')
    assert false: 'should fail'
} catch (ClassNotFoundException e) {
    // expected
}

            task doStuff
"""

        ExecutionResult result = inTestDirectory().withTasks('doStuff').run()
        result.assertOutputContains('quiet message')
        result.assertHasErrorOutput('error message')
    }

    @Test

import org.junit.Test

class UseBuiltInTransformTest {
    @Delegate final TestDelegate delegate = new TestDelegate()

    @Test
    void transformHasBeenApplied() {
        assert doStuff("hi") == "[hi]"
    }

// license that can be found in the LICENSE file.

package p

func hashBytesRaw(b0, b1, b2, b3, b7 byte) uint64 {
	return (uint64(b0) | uint64(b1)<<8 | uint64(b2)<<16 | uint64(b3)<<24)
}

func doStuff(data []byte) uint64 {
	return hashBytesRaw(data[0], data[1], data[2], data[3], data[7])

        file('settings.gradle') << 'include "a", "b"'
        file('a/build.gradle') << '''
configurations { compile }
dependencies { compile project(path: ':b', configuration: 'archives') }

task doStuff(type: InputTask) {
    src = configurations.compile + fileTree('src/java')
}

class InputTask extends DefaultTask {
    @InputFiles
    def FileCollection src
}
'''

import javax.xml.transform.TransformerFactory;
import javax.xml.validation.SchemaFactory;
import javax.xml.xpath.XPathFactory;

public class DefaultClassLoaderFactoryTestHelper {
    public void doStuff() throws Exception {
        SAXParserFactory.newInstance().newSAXParser();
        DocumentBuilderFactory.newInstance().newDocumentBuilder();
        DatatypeFactory.newInstance().newXMLGregorianCalendar();