env GO111MODULE=off

# smoke test for complex build configuration
go build -o complex.exe complex
[!cross] [exec:gccgo] go build -compiler=gccgo -o complex.exe complex

-- complex/main.go --
package main

import (
	_ "complex/nest/sub/test12"
	_ "complex/nest/sub/test23"
	"complex/w"
	"v"
)

func main() {
	println(v.Hello + " " + w.World)
}

-- complex/nest/sub/test12/p.go --
package test12

// arExportData takes an archive file and returns a ReadSeeker for the
// export data in that file. This assumes that there is only one
// object in the archive containing export data, which is not quite
// what gccgo does; gccgo concatenates together all the export data
// for all the objects in the file.  In practice that case does not arise.
func arExportData(archive io.ReadSeeker) (io.ReadSeeker, error) {

// run

//go:build !nacl && !js && !wasip1 && !gccgo

// Copyright 2019 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.
//
// Ensure that deadlock detection can still
// run even with an import of "_ os/signal".

package main

import (
	"bytes"
	"context"
	"io/ioutil"
	"log"
	"os"
	"os/exec"
	"path/filepath"
	"time"
)

[compiler:gccgo] skip 'gccgo has no standard packages'
[short] skip

[!GOOS:windows] env NONEXE='.exe'
[GOOS:windows] env NONEXE=''

env GOBIN=$WORK/tmp/bin
go install m/isarchive &

go build x.go
exists -exec x$GOEXE
rm x$GOEXE
! exists x$NONEXE

go build -o myprog x.go
! exists x
! exists x.exe
exists -exec myprog
! exists myprogr.exe

! exists bin
go build -o bin/x x.go
exists -exec bin/x
rm bin

	"internal/goversion",
	// internal/lazyregexp is provided by Go 1.17, which permits it to
	// be imported by other packages in this list, but is not provided
	// by the Go 1.17 version of gccgo. It's on this list only to
	// support gccgo, and can be removed if we require gccgo 14 or later.
	"internal/lazyregexp",
	"internal/pkgbits",
	"internal/platform",
	"internal/profile",
	"internal/race",
	"internal/saferio",
	"internal/syscall/unix",

[compiler:gccgo] skip # gccgo does not have standard packages
[short] skip

env GOCACHE=$WORK/tmp

# Run go test -json on errors m/empty/pkg and m/skipper
# It would be nice to test that the output is interlaced
# but it seems to be impossible to do that in a short test
# that isn't also flaky. Just check that we get JSON output.
go test -json -short -v errors m/empty/pkg m/skipper

# Check errors for run action
stdout '"Package":"errors"'

	if err != nil {
		t.Fatalf("go list %s: %v\n%s", thePackage, err, out)
	}
	export := strings.TrimSpace(string(out))
	compiler, target, _ := strings.Cut(export, ":")

	if compiler == "gccgo" {
		t.Skip("golang.org/issue/22500")
	}

	fset := token.NewFileSet()

	t.Run("LookupDefault", func(t *testing.T) {
		imp := ForCompiler(fset, compiler, nil)
		pkg, err := imp.Import(thePackage)

	raddr    string

	mu   sync.Mutex // guards conn
	conn serverConn
}

// This interface and the separate syslog_unix.go file exist for
// Solaris support as implemented by gccgo. On Solaris you cannot
// simply open a TCP connection to the syslog daemon. The gccgo
// sources have a syslog_solaris.go file that implements unixSyslog to
// return a type that satisfies this interface and simply calls the C
// library syslog function.

		s = strings.Replace(s, "MKPOSTIFIPAD", "X__ifi_pad", 1)
		s = strings.Replace(s, "MKPOSTSYSINFOTF", "X_f", 1)

		// Force the type of RawSockaddr.Data to [14]int8 to match
		// the existing gccgo API.
		re = regexp.MustCompile("(Data\\s+\\[14\\])uint8")
		s = re.ReplaceAllString(s, "${1}int8")

	case goos == "freebsd":
		// Keep pre-FreeBSD 10 / non-POSIX 2008 names for timespec fields

stdout '^\tbuild\t-ldflags=example\.com/m=-w$'

go build -trimpath
go version -m m$GOEXE
stdout '\tbuild\t-trimpath=true$'

# gccgoflags are not added when gc is used, and vice versa.
# TODO: test gccgo.
go build -gccgoflags=all=UNUSED
go version -m m$GOEXE
! stdout gccgoflags

# Build and tool tags are added but not release tags.
# "race" is included with build tags but not "cgo".
go build -tags=a,b