}
}

func mustHaveSwigOnce(t *testing.T) {
	swig, err := exec.LookPath("swig")
	if err != nil {
		t.Skipf("swig not in PATH: %s", err)
	}

	// Check that swig was installed with Go support by checking
	// that a go directory exists inside the swiglib directory.
	// See https://golang.org/issue/23469.
	output, err := exec.Command(swig, "-go", "-swiglib").Output()
	if err != nil {

            it.assertExists()
            it.assertDebugFileExists()
            it.exec().out == helloWorldApp.englishOutput
        }
        with (executable("build/exe/main/integration/main")) {
            it.assertExists()
            it.assertDebugFileExists()
            it.exec().out == helloWorldApp.frenchOutput
        }
        with (executable("build/exe/main/release/main")) {

// Use an external test to avoid os/exec -> net/http -> crypto/x509 -> os/exec
// circular dependency on non-cgo darwin.

package exec_test

import (
	"bufio"
	"bytes"
	"context"
	"errors"
	"flag"
	"fmt"
	"internal/poll"
	"internal/testenv"
	"io"
	"log"
	"net"
	"net/http"
	"net/http/httptest"
	"os"
	"os/exec"
	"os/exec/internal/fdtest"
	"os/signal"
	"path/filepath"

[!GOOS:windows] [short] stop 'this test only applies to Windows'
env GO111MODULE=off

go build run_go.go
exec ./run_go$GOEXE $GOPATH $GOPATH/src/vend/hello
stdout 'hello, world'

-- run_go.go --
package main

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
)

func changeVolume(s string, f func(s string) string) string {
	vol := filepath.VolumeName(s)
	return f(vol) + s[len(vol):]
}

func main() {

fuzz: elapsed: 0s, gathering baseline coverage: 0/390 completed
fuzz: elapsed: 0s, gathering baseline coverage: 390/390 completed, now fuzzing with 16 workers
fuzz: elapsed: 3s, execs: 438666 (146173/sec), new interesting: 12 (total: 402)
fuzz: elapsed: 4s, execs: 558467 (147850/sec), new interesting: 15 (total: 405)
--- PASS: FuzzParse (3.85s)
=== NAME

        then:
        executable("build/exe/main/alwaysFrench/main").exec().out == helloWorldApp.frenchOutput
        executable("build/exe/main/alwaysCPlusPlus/main").exec().out == helloWorldApp.englishOutput
        executable("build/exe/execTest/alwaysCPlusPlus/execTest").exec().out == "C++ compiler used"
        executable("build/exe/execTest/alwaysFrench/execTest").exec().out == "C compiler used"
    }

go fmt -n exclude
stdout 'exclude[/\\]x\.go'
stdout 'exclude[/\\]x_linux\.go'

# Test edge cases with gofmt.

! exec $GOROOT/bin/gofmt does-not-exist

exec $GOROOT/bin/gofmt gofmt-dir/no-extension
stdout 'package x'

exec $GOROOT/bin/gofmt gofmt-dir
! stdout 'package x'

! exec $GOROOT/bin/gofmt empty.go nopackage.go
stderr -count=1 'empty\.go:1:1: expected .package., found .EOF.'

        and:
        executable(cppExe.dir.file("build/exe/main/main")).exec().out == "Hello, World!\n"
        installation(cppExe.dir.file("build/install/main")).exec().out == "Hello, World!\n"

        cleanup:
        toolChain.resetEnvironment()
    }

    @ToBeFixedForConfigurationCache
    def "lib"() {
        given:

import _ "unsafe" // for go:linkname

//go:cgo_import_dynamic libc_chdir chdir "libc.so"
//go:cgo_import_dynamic libc_chroot chroot "libc.so"
//go:cgo_import_dynamic libc_close close "libc.so"
//go:cgo_import_dynamic libc_execve execve "libc.so"
//go:cgo_import_dynamic libc_fcntl fcntl "libc.so"
//go:cgo_import_dynamic libc_forkx forkx "libc.so"
//go:cgo_import_dynamic libc_gethostname gethostname "libc.so"
//go:cgo_import_dynamic libc_getpid getpid "libc.so"

exec $WORK/bin/check$GOEXE $WORK/new/bin/${GOOS}_${GOARCH}/go$GOEXE $WORK/new
! stderr 'GOPATH set to GOROOT'

-- check.go --
package main

import (
	"fmt"
	"os"
	"os/exec"
	"path/filepath"
	"strings"
)

func main() {
	exe := os.Args[1]
	want := os.Args[2]
	cmd := exec.Command(exe, "env", "GOROOT")
	out, err := cmd.CombinedOutput()
	if err != nil {
		fmt.Fprintf(os.Stderr, "%s env GOROOT: %v, %s\n", exe, err, out)