package main

import "testing"

func TestFoo(t *testing.T) {
  Foo()
}

-- $GOPATH/src/example.com/cov/xtest/x.go --
package x

-- $GOPATH/src/example.com/cov/xtest/x_test.go --
package x_test

import "testing"

stderr 'no non-test Go files in '

! go build ./empty/xtest
stderr 'no non-test Go files in '

! go build ./empty/testxtest
stderr 'no non-test Go files in '

! go build ./exclude
stderr 'build constraints exclude all Go files in '

! go build ./exclude/ignore
stderr 'no Go files in '

! go build ./exclude/empty
stderr 'no Go files in '

-- go.mod --
module m

go 1.16

//
// 1. Tests use the signature "XTest<name>(t TestingT)". Since runtime can't import
// testing, test functions can't use testing.T, so instead we have the T
// interface, which *testing.T satisfies. And we start names with "XTest"
// because otherwise go test will complain about Test functions with the wrong
// signature. To actually expose these as test functions, this file contains
// trivial wrappers.
//

go mod vendor
cmp vendor/example.com/a/samedir_embed.txt a/samedir_embed.txt
cmp vendor/example.com/a/subdir/embed.txt a/subdir/embed.txt
cmp vendor/example.com/a/subdir/test/embed.txt a/subdir/test/embed.txt
cmp vendor/example.com/a/subdir/test/xtest/embed.txt a/subdir/test/xtest/embed.txt

cd broken_no_matching_files
! go mod vendor
stderr '^go: resolving embeds in example.com/brokendep: pattern foo.txt: no matching files found$'
go mod vendor -e

cd $GOPATH/src/empty/pkg
go test -cover -coverpkg=. -race

[short] stop # Only run first case in short mode

cd $GOPATH/src/empty/test
go test -cover -coverpkg=. -race

cd $GOPATH/src/empty/xtest
go test -cover -coverpkg=. -race

cd $GOPATH/src/empty/pkgtest
go test -cover -coverpkg=. -race

cd $GOPATH/src/empty/pkgxtest
go test -cover -coverpkg=. -race

cd $GOPATH/src/empty/pkgtestxtest
go test -cover -coverpkg=. -race

# ... even if that package's test is an xtest.
go build p3
! go test p3
stderr 'import "x" is a program, not an importable package'

# ... even if that package is a package main
go build p4
! go test -c p4
stderr 'import "x" is a program, not an importable package'

# ... even if that package is a package main using an xtest.
go build p5
! go test -c p5

[short] skip
[compiler:gccgo] skip

# coverdep2/p1's xtest imports coverdep2/p2 which imports coverdep2/p1.
# Make sure that coverage on coverdep2/p2 recompiles coverdep2/p2.

go test -short -cover coverdep2/p1
stdout 'coverage: 100.0% of statements' # expect 100.0% coverage

-- go.mod --
module coverdep2

go 1.16
-- p1/p.go --
package p1

func F() int { return 1 }
-- p1/p_test.go --
package p1_test

import (

# Run go test -json on errors and check it's cached
go test -json -short -v errors
stdout '"Action":"output","Package":"errors","Output":".*\(cached\)'

go test -json -bench=NONE -short -v errors
stdout '"Package":"errors"'
stdout '"Action":"run"'

# Test running test2json
go test -o $WORK/tmp/errors.test$GOEXE -c errors

		b = a % 60
		u8test(a, b, 60)
		b = a % 64
		u8test(a, b, 64)
		b = a % 127
		u8test(a, b, 127)
	}
}

func main() {
	xtest()
	i64run()
	u64run()
	i32run()
	u32run()
	i16run()
	u16run()
	i8run()
	u8run()
}

func xtest() {

		b = a / 64
		u8test(a, b, 64)
		b = a / 128
		u8test(a, b, 128)
		b = a / 184
		u8test(a, b, 184)
	}
}

func main() {
	xtest()
	i64run()
	u64run()
	i32run()
	u32run()
	i16run()
	u16run()
	i8run()
	u8run()
}

func xtest() {