func wantIntReg(ctxt *obj.Link, ins *instruction, pos string, r uint32) {
	wantReg(ctxt, ins, pos, "integer", r, REG_X0, REG_X31)
}

// wantFloatReg checks that r is a floating-point register.
func wantFloatReg(ctxt *obj.Link, ins *instruction, pos string, r uint32) {
	wantReg(ctxt, ins, pos, "float", r, REG_F0, REG_F31)
}

// wantEvenOffset checks that the offset is a multiple of two.

	}
	res.Body.Close()

	wantFoo := "bar"
	wantLen := int64(-1)
	if method == "OPTIONS" {
		wantFoo = ""
		wantLen = 0
	}
	if res.StatusCode != 200 {
		t.Errorf("status code = %v; want %d", res.Status, 200)
	}
	if res.ContentLength != wantLen {
		t.Errorf("content length = %v; want %d", res.ContentLength, wantLen)
	}
	if got := res.Header.Get("foo"); got != wantFoo {

func TestSplitEqual(t *testing.T) {
	tests := []struct {
		arg       string
		wantKey   string
		wantValue string
	}{
		{arg: "key=value", wantKey: "key", wantValue: "value"},
		{arg: "key==value", wantKey: "key", wantValue: "=value"},
		{arg: "key=", wantKey: "key", wantValue: ""},
		{arg: "key", wantKey: "key", wantValue: ""},
		{arg: "", wantKey: "", wantValue: ""},
	}
	for _, tt := range tests {

		"any enabled with volume ds": {
			dataSource: volumeDataSource,
			anyEnabled: true,
			want:       volumeDataSource,
			wantRef:    volumeDataSourceRef,
		},
		"any enabled with snapshot ds": {
			dataSource: snapshotDataSource,
			anyEnabled: true,
			want:       snapshotDataSource,
			wantRef:    snapshotDataSourceRef,
		},
		"any enabled with generic ds": {
			dataSource: genericDataSource,
			anyEnabled: true,

			want:    snapshotDataSource,
			wantRef: snapshotDataSourceRef,
		},
		"generic ds": {
			spec:    core.PersistentVolumeClaimSpec{DataSource: genericDataSource},
			want:    genericDataSource,
			wantRef: genericDataSourceRef,
		},
		"core ds": {
			spec:    core.PersistentVolumeClaimSpec{DataSource: coreDataSource},
			want:    coreDataSource,
			wantRef: coreDataSourceRef,
		},
		"volume ds ref": {

		if contained != types.True {
			t.Errorf("got %v, wanted list contains elem[%v] %v == true", contained, i, e)
		}
	}
	if lv.Contains(types.String("fourth")) != types.False {
		t.Errorf("got %v, wanted false 'fourth'", lv.Contains(types.String("fourth")))
	}
	if !types.IsError(lv.Contains(types.Int(-1))) {
		t.Errorf("got %v, wanted error for invalid type", lv.Contains(types.Int(-1)))
	}
}

		t.Fatal("got field not found for 'CustomObject.nested', wanted found")
	}
	if nestedFieldType.Type.GetMessageType() != "CustomObject.nested" {
		t.Errorf("got field type %v, wanted mock_template.nested", nestedFieldType.Type)
	}
	subnameFieldType, found := rt.FindFieldType("CustomObject.nested", "subname")
	if !found {
		t.Fatal("got field not found for 'CustomObject.nested.subname', wanted found")
	}

		// that *i crashes for some reason. Still, why not check it.
		log.Fatalf("bad i value: got %d, want %d", *i, iValue)
	}

	const wantLen = 125
	const wantCap = 1912

	sl := arena.MakeSlice[*int](a, wantLen, wantCap)
	if len(sl) != wantLen {
		log.Fatalf("bad arena slice length: got %d, want %d", len(sl), wantLen)
	}
	if cap(sl) != wantCap {
		log.Fatalf("bad arena slice capacity: got %d, want %d", cap(sl), wantCap)
	}
	sl = sl[:cap(sl)]

	a += 2
	if got := i.(int); got != 5 {
		t.Errorf("wanted 5, got %d\n", got)
	}
}

func TestEfaceConv2(t *testing.T) {
	a := 5
	sink = &a
	i := interface{}(a)
	a += 2
	if got := i.(int); got != 5 {
		t.Errorf("wanted 5, got %d\n", got)
	}
}

func TestEfaceConv3(t *testing.T) {
	x = 5
	if got := e2int3(x); got != 5 {
		t.Errorf("wanted 5, got %d\n", got)
	}
}

//go:noinline

				}
				if (ss.ClusterSent != "") != wantSent {
					errorHandler("wanted ClusterSent set %v got %v for %v", wantSent, ss.ClusterSent, nodeID)
				}
				if (ss.ClusterAcked != "") != wantAcked {
					errorHandler("wanted ClusterAcked set %v got %v for %v", wantAcked, ss.ClusterAcked, nodeID)
				}
				if (ss.ListenerSent != "") != wantSent {
					errorHandler("wanted ListenerSent set %v got %v for %v", wantSent, ss.ListenerSent, nodeID)
				}