var (
	gobEncoderInterfaceType        = reflect.TypeFor[GobEncoder]()
	gobDecoderInterfaceType        = reflect.TypeFor[GobDecoder]()
	binaryMarshalerInterfaceType   = reflect.TypeFor[encoding.BinaryMarshaler]()
	binaryUnmarshalerInterfaceType = reflect.TypeFor[encoding.BinaryUnmarshaler]()
	textMarshalerInterfaceType     = reflect.TypeFor[encoding.TextMarshaler]()
	textUnmarshalerInterfaceType   = reflect.TypeFor[encoding.TextUnmarshaler]()

                return asMutable().toString();
            }

            private StringBuilder asMutable() {
                String typeStr = type.toString();
                StringBuilder result = new StringBuilder(typeStr.length() + name.length() + 3);
                result.append(typeStr);
                result.append(" '");
                result.append(name);
                result.append('\'');
                return result;

	testCloneSeq[testStruct](t, cSeq(8))
}

func cSeq(stringOffsets ...uintptr) cloneSeq {
	return cloneSeq{stringOffsets: stringOffsets}
}

func testCloneSeq[T any](t *testing.T, want cloneSeq) {
	typName := reflect.TypeFor[T]().Name()
	typ := abi.TypeOf(*new(T))
	t.Run(typName, func(t *testing.T) {
		got := makeCloneSeq(typ)
		if !reflect.DeepEqual(got, want) {

	{CaseName: Name(""), in: `{"X": [1,2,3], "Y": 4}`, ptr: new(T), out: T{Y: 4}, err: &UnmarshalTypeError{"array", reflect.TypeFor[string](), 7, "T", "X"}},
	{CaseName: Name(""), in: `{"X": 23}`, ptr: new(T), out: T{}, err: &UnmarshalTypeError{"number", reflect.TypeFor[string](), 8, "T", "X"}},
	{CaseName: Name(""), in: `{"x": 1}`, ptr: new(tx), out: tx{}},
	{CaseName: Name(""), in: `{"x": 1}`, ptr: new(tx), out: tx{}},

}

func Set[T any](t TypeMap, v T) {
	interfaceType := reflect.TypeOf((*T)(nil)).Elem()
	t.inner[interfaceType] = v
}

func Get[T any](t TypeMap) *T {
	v, f := t.inner[reflect.TypeFor[T]()]
	if f {
		return ptr.Of(v.(T))
	}
	return nil

        overridden:
          public open fun setContentView (p0: kotlin.Int): kotlin.Unit declared in p2.Parent
        $this: VALUE_PARAMETER name:<this> type:p2.Parent
        VALUE_PARAMETER name:p0 index:0 type:kotlin.Int
          annotations:
            Anno(value = ["UnknownNullness", "MissingNullability"])

	return
}

var (
	bitStringType        = reflect.TypeFor[BitString]()
	objectIdentifierType = reflect.TypeFor[ObjectIdentifier]()
	enumeratedType       = reflect.TypeFor[Enumerated]()
	flagType             = reflect.TypeFor[Flag]()
	timeType             = reflect.TypeFor[time.Time]()
	rawValueType         = reflect.TypeFor[RawValue]()
	rawContentsType      = reflect.TypeFor[RawContent]()
	bigIntType           = reflect.TypeFor[*big.Int]()

	case *OrExpr:
		op := orVersion
		if sign < 0 {
			op = andVersion
		}
		return op(minVersion(z.X, sign), minVersion(z.Y, sign))
	case *NotExpr:
		return minVersion(z.X, -sign)
	case *TagExpr:
		if sign < 0 {
			// !foo implies nothing
			return -1
		}
		if z.Tag == "go1" {
			return 0
		}
		_, v, _ := strings.Cut(z.Tag, "go1.")
		n, err := strconv.Atoi(v)
		if err != nil {

func (w *mockTransferWriter) Write(p []byte) (int, error) {
	w.WriteCalled = true
	return io.Discard.Write(p)
}

func TestTransferWriterWriteBodyReaderTypes(t *testing.T) {
	fileType := reflect.TypeFor[*os.File]()
	bufferType := reflect.TypeFor[*bytes.Buffer]()

	nBytes := int64(1 << 10)
	newFileFunc := func() (r io.Reader, done func(), err error) {
		f, err := os.CreateTemp("", "net-http-newfilefunc")
		if err != nil {

		s: [2]testStringStruct{testStringStruct{"y"}, testStringStruct{"z"}},
	})
	testHandle[testStruct](t, testStruct{0.5, "184"})
}

func testHandle[T comparable](t *testing.T, value T) {
	name := reflect.TypeFor[T]().Name()
	t.Run(fmt.Sprintf("%s/%#v", name, value), func(t *testing.T) {
		t.Parallel()

		v0 := Make(value)
		v1 := Make(value)

		if v0.Value() != v1.Value() {
			t.Error("v0.Value != v1.Value")
		}