{Name: "FLOAT32", DBName: "ffloat32", BindNames: []string{"FLOAT32"}, DataType: schema.Float, Creatable: true, Updatable: true, Readable: true, Size: 32, Tag: `gorm:"column:ffloat32"`},

`)

	abitest(t, ft, exp)
}

func TestABIUtilsBasic2(t *testing.T) {
	// func(p1 int8, p2 int16, p3 int32, p4 int64,
	//      p5 float32, p6 float32, p7 float64, p8 float64,
	//      p9 int8, p10 int16, p11 int32, p12 int64,
	//      p13 float32, p14 float32, p15 float64, p16 float64,
	//      p17 complex128, p18 complex128, p19 complex12, p20 complex128,
	//      p21 complex64, p22 int8, p23 in16, p24 int32, p25 int64,

	}
}

type ChildToEmbed struct {
	X bool
}

type Parent struct {
	I        int
	IPtr     *int
	Is       []int
	IPtrs    []*int
	F        float32
	FPtr     *float32
	Fs       []float32
	FPtrs    []*float32
	B        bool
	BPtr     *bool
	Bs       []bool
	BPtrs    []*bool
	Bytes    []byte
	BytesPtr *[]byte
	S        string
	SPtr     *string
	Ss       []string

	return float64(r.Uint64()<<11>>11) / (1 << 53)
}

// Float32 returns, as a float32, a pseudo-random number in the half-open interval [0.0,1.0).
func (r *Rand) Float32() float32 {
	// There are exactly 1<<24 float32s in [0,1). Use Intn(1<<24) / (1<<24).
	return float32(r.Uint32()<<8>>8) / (1 << 24)
}

// Perm returns, as a slice of n ints, a pseudo-random permutation of the integers

		t.Errorf("float64(i8) != di8")
	}
	if float32(u64) != su64 {
		t.Errorf("float32(u64) != su64")
	}
	if float32(u32) != su32 {
		t.Errorf("float32(u32) != su32")
	}
	if float32(u16) != su16 {
		t.Errorf("float32(u16) != su16")
	}
	if float32(u8) != su8 {
		t.Errorf("float32(u8) != su8")
	}
	if float32(i64) != si64 {
		t.Errorf("float32(i64) != si64")
	}
	if float32(i32) != si32 {

	float32(0.16735445),                 // Float32()
	float32(0.28858566),                 // Float32()
	float32(0.9026048),                  // Float32()
	float32(0.84978026),                 // Float32()
	float32(0.2730468),                  // Float32()
	float32(0.6090802),                  // Float32()
	float32(0.253656),                   // Float32()
	float32(0.7746542),                  // Float32()

	t.UInt8 = types.Types[types.TUINT8]
	t.UInt16 = types.Types[types.TUINT16]
	t.UInt32 = types.Types[types.TUINT32]
	t.UInt64 = types.Types[types.TUINT64]
	t.Int = types.Types[types.TINT]
	t.Float32 = types.Types[types.TFLOAT32]
	t.Float64 = types.Types[types.TFLOAT64]
	t.UInt = types.Types[types.TUINT]
	t.Uintptr = types.Types[types.TUINTPTR]
	t.String = types.Types[types.TSTRING]

	{"max", `var x int    ; _ = max(0, x     )`, `func(int, int) int`},
	{"max", `var x string ; _ = max("a", x   )`, `func(string, string) string`},
	{"max", `var x float32; _ = max(0, 1.0, x)`, `func(float32, float32, float32) float32`},

	{"min", `               _ = min(0        )`, `invalid type`}, // constant
	{"min", `var x int    ; _ = min(x        )`, `func(int) int`},

}

//go:noinline
func add32_ssa(a, b float32) float32 {
	return a + b
}

//go:noinline
func mul32_ssa(a, b float32) float32 {
	return a * b
}

//go:noinline
func sub32_ssa(a, b float32) float32 {
	return a - b
}

//go:noinline
func div32_ssa(a, b float32) float32 {
	return a / b
}

//go:noinline
func neg32_ssa(a, b float32) float32 {
	return -a + -1*b
}

	_ = a[1.0<<s]

	_ = make([]int, 1.0)
	_ = make([]int, 1.0<<s)
	_ = make([]int, 1.1 /* ERROR "must be integer" */ <<s)

	_ = float32(1)
	_ = float32(1 /* ERROR "must be integer" */ <<s)
	_ = float32(1.0)
	_ = float32(1.0 /* ERROR "must be integer" */ <<s)
	_ = float32(1.1 /* ERROR "must be integer" */ <<s)

	// TODO(gri) Re-enable these tests once types2 has the go/types fixes.
	//           Issue #52080.