buildFile << """
            task myTask {
                doLast {
                    throw new RuntimeException("Boom")
                }
            }
        """

        expect:
        runner().withArguments("myTask").buildAndFail()

        where:
        jdk << AvailableJavaHomes.getJdks("1.8")
    }

            import org.gradle.api.tasks.*

            task cacheableTask(type: MyTask) {
                inputFile = file('input.txt')
                outputFile = file('build/output.txt')
                cacheOrigin = file('cache-origin.txt')
            }

            @CacheableTask
            class MyTask extends DefaultTask {

                @OutputFile File outputFile

                @InputFile

) : DefaultTask()
// end::inject-task-constructor[]

{
    @TaskAction
    fun run() =
        println("$message $number")
}

// tag::on-task-container[]
tasks.register<CustomTask>("myTask", "hello", 42)

        // Create and configure the extension
        def extension = project.extensions.create("myExtension", MyExtension)
        // Create and configure the custom task
        project.tasks.register("myTask", MyCustomTask) {
            group = "custom"
            inputParameter = extension.inputParameter
        }
    }
}

            import org.gradle.api.Project

            class PublishedApiTestPlugin implements Plugin<Project> {
                void apply(Project project) {
                    project.tasks.register("myTask", CustomTask) {
                        mapValues = ["alma": 1, "bela": 2]
                        println("Hello from plugin")
                    }
                }
            }
        """

import org.junit.Assume

class PrecompiledGroovyPluginCrossVersionSpec extends CrossVersionIntegrationSpec {

    private static final String PLUGIN_ID = 'foo.bar.my-plugin'
    private static final String PLUGIN_TASK = 'myTask'

    def setup() {
        settingsFile << """
            pluginManagement {
                repositories {
                    maven {
                        url '${mavenRepo.uri}'
                    }

        setup:
        def latch = new AtomicBoolean()

        when:
        def project = buildProject()

        project.getTasksByName('myTask', true)

        project.afterEvaluate {
            latch.getAndSet(true)
        }

        project.evaluate()

        then:
        noExceptionThrown()
        latch.get()
    }

            import org.gradle.api.*

            class ${className} implements Plugin<Project> {
                void apply(Project project) {
                    project.tasks.create("myTask${className}") {
                        doLast {
                            def closure = {
                                println "From ${className}"
                            }
                            closure()

// takes any other value.
func ConstantTimeCopy(v int, x, y []byte) {
	if len(x) != len(y) {
		panic("subtle: slices have different lengths")
	}

	xmask := byte(v - 1)
	ymask := byte(^(v - 1))
	for i := 0; i < len(x); i++ {
		x[i] = x[i]&xmask | y[i]&ymask
	}
}

// ConstantTimeLessOrEq returns 1 if x <= y and 0 otherwise.
// Its behavior is undefined if x or y are negative or > 2**31 - 1.
func ConstantTimeLessOrEq(x, y int) int {

		{regAddr(REG_GS), Ygs},
		{regAddr(REG_TLS), Ytls},
		{regAddr(REG_GDTR), Ygdtr},
		{regAddr(REG_IDTR), Yidtr},
		{regAddr(REG_LDTR), Yldtr},
		{regAddr(REG_MSW), Ymsw},
		{regAddr(REG_TASK), Ytask},
		{regAddr(REG_CR0), Ycr0},
		{regAddr(REG_CR5), Ycr5},
		{regAddr(REG_CR8), Ycr8},
		{regAddr(REG_DR0), Ydr0},
		{regAddr(REG_DR5), Ydr5},
		{regAddr(REG_DR7), Ydr7},
		{regAddr(REG_TR0), Ytr0},