}
            
            task silence {}
            
            task all {
                dependsOn helloWorld, byeWorld, silence
            }
        """
        when:
        succeeds('all')

        then:
        result.groupedOutput.task(':helloWorld').output == helloWorldMessage
        result.groupedOutput.task(':byeWorld').output == byeWorldMessage

                }

                def "execute helloWorld task"() {
                    given:
                    buildFile << 'apply plugin: "$plugin.id"'

                    when:
                    def result = GradleRunner.create()
                        .withProjectDir(testProjectDir)
                        .withArguments('helloWorld')
                        .withDebug($debug)

env GOPATH= # reset to default ($HOME/go, which does not exist)
env GOBIN=
! go install go-cmd-test/helloworld.go
stderr '^go: no install location for \.go files listed on command line \(GOBIN not set\)$'

# With $GOBIN set, should install there.
env GOBIN=$WORK/bin1
go install go-cmd-test/helloworld.go
exists $GOBIN/helloworld$GOEXE

# We can't assume that we can write to GOROOT, because it may not be writable.

                void apply(Project project) {
                    project.task('helloWorld$suffix', type: HelloWorld$suffix)
                }
            }
        """

        projectDir.file("src/main/groovy/org/gradle/test/HelloWorld${suffix}.groovy") << """
            package org.gradle.test

            import org.gradle.api.DefaultTask

        given:
        buildFile << """
            task helloWorld

            task byeWorld {
                onlyIf {
                    false
                }
            }
        """

        when:
        def result = runner('helloWorld', 'byeWorld')
            .build()

        then:
        result.tasks.collect { it.path } == [':helloWorld', ':byeWorld']
        result.taskPaths(SUCCESS) == []

        given:
        def standardOutput = new StringWriter()
        def standardError = new StringWriter()
        buildScript helloWorldWithStandardOutputAndError()

        when:
        def result = runner('helloWorld', "-d", "-s")
            .forwardStdOutput(standardOutput)
            .forwardStdError(standardError)
            .build()

        then:
        result.output.findAll(OUT).size() == 1

package main

import "C"
import (
	"fmt"
)

//export HelloWorld
func HelloWorld() {
	fmt.Println("Hello World")
}

func main() {}
`
	dllsrc := filepath.Join(tmpdir, "helloworld.go")
	err := os.WriteFile(dllsrc, []byte(dlltext), 0644)
	if err != nil {
		t.Fatal(err)
	}
	dll := filepath.Join(tmpdir, "helloworld.dll")

                        project.tasks.create('helloWorld', HelloWorld)
                    }
                }
            """

            file('src/main/groovy/org/gradle/hello/HelloWorld.groovy') << """
                package org.gradle.hello

                import org.gradle.api.DefaultTask
                import org.gradle.api.tasks.TaskAction

                class HelloWorld extends DefaultTask {

# This folder is then passed as the docker context. This avoids complex .dockerignore or large context loads.

# Example image config
example:
- name: helloworld # Name of the image. Will end up pushed to <HUB>/helloworld:<TAG>
  dockerfile: helloworld/Dockerfile.proxyv2
  files:
  # Include a static file
  # Inside the Dockerfile, this is referenced by the base name (README.md), not the full name.
  - samples/README.md

        os.Exit(1)
    }
    os.WriteFile(tmp("importcfg"), importcfg, 0644)

	// helloworld.go is package main
    run("go tool compile -p=main -importcfg", tmp("importcfg"), "-o", tmp("linkmain.o"), "helloworld.go")
	run("go tool compile -p=main -importcfg", tmp("importcfg"), " -pack -o", tmp("linkmain.a"), "helloworld.go")
	run("go tool link -importcfg", tmp("importcfg"), "-o", tmp("linkmain.exe"), tmp("linkmain.o"))