// to unsafe.Pointer can't be combined with the
	// uintptr cast above.
	var z uintptr
	if always {
		z = y
	} else {
		z = 0
	}
	return (*[7]uint)(unsafe.Pointer(z))
}

func testf(t *testing.T) {
	a = new([8]uint)
	for i := 0; i < 8; i++ {
		a[i] = 0xabcd
	}
	c := f_ssa()
	for i := 0; i < 8; i++ {
		if c[i] != 0xabcd {
			t.Fatalf("%d:%x\n", i, c[i])
		}
	}
}

	{"AVI video #2", []byte("RIFF,\n\x00\x00AVI LISTÀ"), "video/avi"},

	// Font types.
	// {"MS.FontObject", []byte("\x00\x00")},
	{"TTF sample  I", []byte("\x00\x01\x00\x00\x00\x17\x01\x00\x00\x04\x01\x60\x4f"), "font/ttf"},
	{"TTF sample II", []byte("\x00\x01\x00\x00\x00\x0e\x00\x80\x00\x03\x00\x60\x46"), "font/ttf"},

	{"OTTO sample  I", []byte("\x4f\x54\x54\x4f\x00\x0e\x00\x80\x00\x03\x00\x60\x42\x41\x53\x45"), "font/otf"},

	// On return, R20 points to the last zeroed dword.
	fmt.Fprintln(w, "TEXT runtime·duffzero<ABIInternal>(SB), NOSPLIT|NOFRAME, $0-0")
	for i := 0; i < 63; i++ {
		fmt.Fprintln(w, "\tSTP.P\t(ZR, ZR), 16(R20)")
	}
	fmt.Fprintln(w, "\tSTP\t(ZR, ZR), (R20)")
	fmt.Fprintln(w, "\tRET")
}

func copyARM64(w io.Writer) {
	// R20: ptr to source memory
	// R21: ptr to destination memory

func (TL) Method1() {}
func (TL) Method2() {}

type T8 uint8
type T16 uint16
type T32 uint32
type T64 uint64
type Tstr string
type Tslice []byte

func (T8) Method1()     {}
func (T16) Method1()    {}
func (T32) Method1()    {}
func (T64) Method1()    {}
func (Tstr) Method1()   {}
func (Tslice) Method1() {}

var (
	e  any
	e_ any
	i1 I1
	i2 I2
	ts TS
	tm TM
	tl TL
	ok bool
)

		{name: "TST", argLength: 2, reg: gp2flags, asm: "TST", typ: "Flags", commutative: true},   // arg0 & arg1 compare to 0
		{name: "TSTconst", argLength: 1, reg: gp1flags, asm: "TST", aux: "Int64", typ: "Flags"},   // arg0 & auxInt compare to 0
		{name: "TSTW", argLength: 2, reg: gp2flags, asm: "TSTW", typ: "Flags", commutative: true}, // arg0 & arg1 compare to 0, 32 bit

					continue
				}
				if !tested.Contains(rec) {
					t.Errorf("CRD does not have a validation test: %v", rec)
				}
			}

			for tst := range tested {
				if _, found := recognized[tst]; !found {
					t.Errorf("Unrecognized validation test data found: %v", tst)
				}
			}
		})

			},
		},
	}

	for i := range tests {
		tst := tests[i]
		t.Run(tst.desc, func(t *testing.T) {
			// plug in schemas
			manifest := strings.NewReplacer(
				"GLOBAL_SCHEMA", toValidationJSON(tst.globalSchema),
				"V1BETA1_SCHEMA", toValidationJSON(tst.v1beta1Schema),
				"V1_SCHEMA", toValidationJSON(tst.v1Schema),
				"PRESERVE_UNKNOWN_FIELDS", tst.preserveUnknownFields,
			).Replace(tmpl)

	if err := yaml.Unmarshal([]byte(metaDefaultingFooInstance), &returnedFoo.Object); err != nil {
		t.Fatal(err)
	}
	for _, tst := range tests {
		if tst.value != nil {
			if err := unstructured.SetNestedField(returnedFoo.Object, tst.value, tst.path...); err != nil {
				t.Fatal(err)
			}
		}
	}
	returnedFoo, err = fooClient.Create(context.TODO(), returnedFoo, metav1.CreateOptions{})

}
-- vetfail/p2/p2.go --
package p2

import _ "m/vetfail/p1"

func F() {
}
-- vetfail/p2/p2_test.go --
package p2

import "testing"

func TestF(t *testing.T) {
	F()

package arm

import "cmd/internal/obj"

var Anames = []string{
	obj.A_ARCHSPECIFIC: "AND",
	"EOR",
	"SUB",
	"RSB",
	"ADD",
	"ADC",
	"SBC",
	"RSC",
	"TST",
	"TEQ",
	"CMP",
	"CMN",
	"ORR",
	"BIC",
	"MVN",
	"BEQ",
	"BNE",
	"BCS",
	"BHS",
	"BCC",
	"BLO",
	"BMI",
	"BPL",
	"BVS",
	"BVC",
	"BHI",
	"BLS",
	"BGE",
	"BLT",