@Inject
                CustomTask(WorkerExecutor executor) {
                    this.executor = executor
                }

                @TaskAction
                void printIt() {
                    println(executor != null ? "got it" : "NOT IT")
                }
            }

            task myTask(type: CustomTask)
        """

        when:
        run 'myTask'

        then:

// Test simultaneous assignment.

package main

var a, b, c, d, e, f, g, h, i int

func printit() {
	println(a, b, c, d, e, f, g, h, i)
}

func testit(permuteok bool) bool {
	if a+b+c+d+e+f+g+h+i != 45 {
		print("sum does not add to 45\n")
		printit()
		return false
	}
	return permuteok ||
		a == 1 &&
			b == 2 &&
			c == 3 &&
			d == 4 &&
			e == 5 &&
			f == 6 &&

                @Internal
                Set<File> classpath = project.configurations["myconf"].files
                BadTask() {
                    println("creating bad task")
                }
                @TaskAction
                void printIt() {
                    def outputFile = getOutputFile().get().asFile
                    outputFile.text = "bad"
                }
            }

                @Internal
                Set<File> classpath = project.configurations["myconf"].files
                BadTask() {
                    println("creating bad task")
                }
                @TaskAction
                void printIt() {
                    def outputFile = getOutputFile().get().asFile
                    outputFile.text = "bad"
                }
            }

    @Inject
    CustomTask(String message, int number) {
        this.message = message
        this.number = number
    }
// end::inject-task-constructor[]

    @TaskAction
    void printIt() {
        println("$message $number")
    }
// tag::inject-task-constructor[]
}
// end::inject-task-constructor[]

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

        buildFile << '''
            tasks.register("task1", SomeTask) {
                println "Configure ${path}"
            }
            tasks.register("task2", SomeOtherTask) {
                println "Configure ${path}"
            }
            tasks.create("other")
            tasks.withType(SomeTask) {
                println "Matched ${path}"
            }
        '''

        when:
        run("other")

                this.number = number
            }

            @TaskAction
            void printIt() {
                println("\$message \$number")
            }
        }
    """

    def setup() {
        buildFile << '''
            class SomeTask extends DefaultTask {
                SomeTask() {
                    println("Create ${path}")
                }
            }

        given:
        buildFile << """
            class LoggingTask extends DefaultTask {
                LoggingTask() {
                    println("name = " + name)
                    println("path = " + path)
                    println("toString() = " + this)
                }
            }

            task one(type: LoggingTask)
        """

        when:
        run("one")

package main

/*
int meaningOfLife() { return 42; }
*/
import "C"

func main() {
     println(C.meaningOfLife())
}

-- nonMainPackageUsesExplicitCgo/main.go --

package p

/*
int meaningOfLife() { return 42; }
*/
import "C"

func PrintIt() {
     println(C.meaningOfLife())

	println("one", "two")       // printsp

	// test goprintf
	defer println((interface{})(nil))
	defer println((interface {
		f()
	})(nil))
	defer println((map[int]int)(nil))
	defer println(([]int)(nil))
	defer println(int64(-11))
	defer println(uint64(12))
	defer println(uint32(12))
	defer println(uint16(12))
	defer println(uint8(12))
	defer println(uint(12))
	defer println(uintptr(12))
	defer println(13.0)