c128 := types.Types[types.TCOMPLEX128]

	s := mkstruct(i8, i8, mkstruct(), i8, i16)
	a := mkstruct(s, s, s)

	nrtest(t, i8, 1)
	nrtest(t, i16, 1)
	nrtest(t, i32, 1)
	nrtest(t, i64, 1)
	nrtest(t, f32, 1)
	nrtest(t, f64, 1)
	nrtest(t, c64, 2)
	nrtest(t, c128, 2)
	nrtest(t, s, 4)
	nrtest(t, a, 12)
}

func TestABIUtilsComputePadding(t *testing.T) {

	for i := 0; i < len(etoks); i++ {
		if etoks[i] == atoks[i] {
			continue
		}

		return fmt.Sprintf("diff at token %d: expected %q got %q",
			i, etoks[i], atoks[i])
	}
	return ""
}

func nrtest(t *testing.T, ft *types.Type, expected int) {
	types.CalcSize(ft)
	got := configAMD64.NumParamRegs(ft)
	if got != expected {
		t.Errorf("]\nexpected num regs = %d, got %d, type %v", expected, got, ft)
	}
}

-- b/b.go --
package b

-- b/b_test.go --
package b_test

import "testing"

func Test(t *testing.T) {}

-- c_test/go.mod --
module example.com/c_test

-- c_test/umm.go --
// Package c_test is the non-test package for its import path!
package c_test

-- c_test/c_test_test.go --
package c_test_test

import "testing"

func Test(t *testing.T) {}

-- d_test/go.mod --

        addEmptyTestClass("ACTest")
        addEmptyTestClass("AÄTest")
        addEmptyTestClass("AZTest")
        addEmptyTestClass("AbTest")

        String expectedTestMessages = """
executed Test ${maybeParentheses('test')}(AATest)
executed Test ${maybeParentheses('test')}(ACTest)
executed Test ${maybeParentheses('test')}(AZTest)
executed Test ${maybeParentheses('test')}(AbTest)
executed Test ${maybeParentheses('test')}(AdTest)

! go vet a/a_test.go
stderr '^package command-line-arguments \(test\)\n\ta[/\\]a_test.go:4:3: use of internal package'

! go vet a
stderr '^package a\n\ta[/\\]a.go:5:3: use of internal package'

go vet b/b.go
! stderr 'use of internal package'

! go vet b/b_test.go
stderr '^package command-line-arguments \(test\)\n\tb[/\\]b_test.go:4:3: use of internal package'

# This file demonstrates the effect of lazy loading on the selected
# versions of test dependencies.

# The package import graph used in this test looks like:
#
# m ---- a
#  \     |
#   \    a_test ---- b
#    \               |
#     x              b_test
#     |                    \
#     x_test -------------- c
#
# And the module dependency graph looks like:
#
# m -- a.1 -- b.1 -- c.2
#  \
#   x.1 ------------ c.1

[short] skip

# test fail fast
! go test ./failfast_test.go -run='TestFailingA' -failfast=true
stdout -count=1 'FAIL - '
! go test ./failfast_test.go -run='TestFailing[AB]' -failfast=true
stdout -count=1 'FAIL - '
! go test ./failfast_test.go -run='TestFailing[AB]' -failfast=false
stdout -count=2 'FAIL - '

# mix with non-failing tests
! go test ./failfast_test.go -run='TestA|TestFailing[AB]' -failfast=true
stdout -count=1 'FAIL - '

-- go.mod.empty --
module m

-- a/a.go --
package a

-- a/a_test.go --
package a_test

import _ "rsc.io/quote"

-- b/b.go --
package b

import _ "m/a"

-- b/b_test.go --
package b_test

module example.com/a

go 1.17

require example.com/b v0.1.0
-- a/a.go --
package a
-- a/a_test.go --
package a_test

import _ "example.com/b"

-- b1/go.mod --
module example.com/b

go 1.17

require example.com/c v0.1.0
-- b1/b.go --
package b
-- b1/b_test.go --
package b_test
import _ "example.com/c"

-- b2/go.mod --
module example.com/b

go 1.17

package a_test

import (
	"cfg/a"
	"testing"
)

func TestA(t *testing.T) {
	a.A(0)
	var aat a.Atyp
	at := &aat
	at.Set(42)
	println(at.Get())