stdout foo

exec echo foo &
exec echo bar &
! exec false &

# Starting a background process should clear previous output.
! stdout foo

# Wait should set the output to the concatenated outputs of the background
# programs, in the order in which they were started.
wait
stdout 'foo\nbar'

# The end of the test should interrupt or kill any remaining background
# programs, but that should not cause the test to fail if it does not

# Regression test for https://go.dev/issue/24050:
# a test that exits with an I/O stream held open
# should fail after a reasonable delay, not wait forever.
# (As of the time of writing, that delay is 10% of the timeout,
# but this test does not depend on its specific value.)

[short] skip 'runs a test that hangs until its WaitDelay expires'

! go test -v -timeout=1m .

	# After the test process itself prints PASS and exits,

			panic(err)
		}
		// signal may not be received immediately. Wait for it.
		select{}
	})
}

func FuzzKill(f *testing.F) {
	f.Fuzz(func(*testing.T, bool) {
		pid := syscall.Getpid()
		if err := syscall.Kill(pid, syscall.SIGKILL); err != nil {
			panic(err)
		}
		// signal may not be received immediately. Wait for it.
		select{}
	})
}

func FuzzCrash(f *testing.F) {

! stderr $WORK # make sure temporary directory isn't in error

cp stderr $WORK/stderr.txt

# Get errors from coverage into stderr2.txt
! go test -cover coverbad
cp stderr $WORK/stderr2.txt

wait # for go run above

cmp $WORK/stderr.txt $WORK/stderr2.txt

-- go.mod --
module coverbad

go 1.16
-- p.go --
package p

func f() {
	g()
}
-- p1.go --
package p

import "C"

env GO111MODULE=on

# Concurrent builds should succeed, even if they need to download modules.
go get ./x ./y
go build ./x &
go build ./y
wait

# Concurrent builds should update go.sum to the union of the hashes for the
# modules they read.
cmp go.sum go.sum.want

-- go.mod --
module golang.org/issue/26794

require (
	golang.org/x/text v0.3.0
	rsc.io/sampler v1.0.0
)
-- x/x.go --
package x

# Hard-wire new coverage for this test.
env GOEXPERIMENT=coverageredesign

# Build for coverage.
go build -gcflags=-m -o example.exe -cover example/main &
[race] go build -o examplewithrace.exe -race -cover example/main &
wait

# First execute without GOCOVERDIR set...
env GOCOVERDIR=
exec ./example.exe normal
stderr '^warning: GOCOVERDIR not set, no coverage data emitted'

# ... then with GOCOVERDIR set.
env GOCOVERDIR=data/normal

  - Select `Synchronization enabled` - `use settings from VCS` - `MyNewVcsRoot`(the one you just created) - `Settings format: Kotlin`, then `Apply`.
- At the popup window, click `Import Settings from VCS`. Wait a few seconds. 
  - If the error says "Context Parameter 'Branch' missing", it's ok. Click into the error and add a context parameter `Branch` with value `myTestBranch`. Go back and it automatically reloads.

# Instead, we build a fresh copy of the binary with known settings.
go build -trimpath -o $WORK/new/bin/go$GOEXE cmd/go &
go build -trimpath -o $WORK/bin/check$GOEXE check.go &
wait

env TESTGOROOT=$GOROOT
env GOROOT=

# Unset GOPATH and any variables that its default may be derived from,
# so that we can check for a spurious warning.
env GOPATH=
env HOME=''
env USERPROFILE=''

aurai
auras
aura
aurons
aurez
auront
aurais
aurait
aurions
auriez
auraient
avais
avait
avions
aviez
avaient
eut
eûmes
eûtes
eurent
aie
aies
ait
ayons
ayez
aient
eusse
eusses
eût
eussions
eussiez
eussent
ceci
cela
celà
cet
cette
ici
ils
les
leurs
quel
quels
quelle
quelles
sans

[!cgolinkext] go build '-ldflags=-tmpdir=tmp5 -linkmode=internal' -o $devnull ./usesInternalCgo &

# Sixth build: explicit CGO use in a non-main package.
go build -o p.a ./nonMainPackageUsesExplicitCgo &

wait

# Check first build: no external linking expected
! exists tmp1/go.o

# Check second build: using only "runtime/cgo", expect internal linking.
[!cgolinkext] ! exists tmp2/go.o
[cgolinkext] exists tmp2/go.o