"testing"
)

func TestTypeFor(t *testing.T) {
	type (
		mystring string
		myiface  interface{}
	)

	testcases := []struct {
		wantFrom any
		got      reflect.Type
	}{
		{new(int), reflect.TypeFor[int]()},
		{new(int64), reflect.TypeFor[int64]()},
		{new(string), reflect.TypeFor[string]()},
		{new(mystring), reflect.TypeFor[mystring]()},
		{new(any), reflect.TypeFor[any]()},

type MyInt32 int32
type MyInt64 int64
type MyString string
type MyUint uint
type MyUint8 uint8
type MyUint16 uint16
type MyUint32 uint32
type MyUint64 uint64
type MyUintptr uintptr

func panicCustomComplex64() {
	panic(MyComplex64(0.11 + 3i))
}

func panicCustomComplex128() {
	panic(MyComplex128(32.1 + 10i))
}

func panicCustomString() {
	panic(MyString("Panic\nline two"))
}

	z = z /* ERRORx `operand z .* must be integer` */ >> y
}

type mystring string

func _(x, y string, z mystring) {
	x = x + "foo"
	x = x /* ERROR "not defined" */ - "foo"
	x = x /* ERROR "mismatched types string and untyped int" */ + 1
	x = x + y
	x = x /* ERROR "not defined" */ - y
	x = x /* ERROR "mismatched types string and untyped int" */* 10
}

func f() (a, b int) { return }

// license that can be found in the LICENSE file.

// Test interfaces on basic types.

package main

type myint int
type mystring string
type I0 interface{}

func f() {
	var ia, ib I0
	var i myint
	var s mystring

	if ia != ib {
		panic("1")
	}

	i = 1
	ia = i
	ib = i
	if ia != ib {
		panic("2")
	}
	if ia == nil {
		panic("3")
	}

	i = 2

}

// "x is an integer or a slice of bytes or runes and T is a string type"

type myInt int
type myString string

func _[T ~string](x int) T      { return T(x) }
func _[T ~string](x myInt) T    { return T(x) }
func _[X Integer](x X) string   { return string(x) }
func _[X Integer](x X) myString { return myString(x) }
func _[X Integer](x X) *string {

// when the underlying kind is directly printable.
// Issue: https://golang.org/issues/37531
func TestPanicWithDirectlyPrintableCustomTypes(t *testing.T) {
	tests := []struct {
		name            string
		wantPanicPrefix string
	}{
		{"panicCustomBool", `panic: main.MyBool(true)`},
		{"panicCustomComplex128", `panic: main.MyComplex128(+3.210000e+001+1.000000e+001i)`},

	return x + 1
}

type MyString string
func double[T interface{MyInt|MyString}](x T) T {
	return x + x
}

// Embedding of interfaces with term lists leads to interfaces
// with term lists that are the intersection of the embedded
// term lists.

type E0 interface {
	~int | ~bool | ~string
}

type E1 interface {
	~int | ~float64 | ~string
}

type E2 interface {
	~float64

	time.Sleep(10*time.Millisecond)
	runtime.GC()
	runtime.GC()
	time.Sleep(10*time.Millisecond)
}

func setup() {
	var Ts []interface{}
	buf := make([]byte, 128)
	
	for i := 0; i < 10000; i++ {
		s := string(buf)
		t := &T{ptr: new(*int)}
		runtime.SetFinalizer(t.ptr, func(**int) { panic("*int freed too early") })
		Ts = append(Ts, t)
		things = append(things, s[len(s):])
	}
	
	things = append(things, Ts...)

Ian Lance Taylor <******@****.***> 1326931944 -0800

	print("\n")

	/* create string with integer constant */
	c = string('x')
	if c != "x" {
		panic("create int " + c)
	}

	/* create string with integer variable */
	v := 'x'
	c = string(v)
	if c != "x" {
		panic("create int " + c)
	}

	/* create string with byte array */
	var z1 [3]byte
	z1[0] = 'a'
	z1[1] = 'b'
	z1[2] = 'c'
	c = string(z1[0:])
	if c != "abc" {