}
}

func testAssertE2TPanic(t *testing.T) {
	var got *U
	defer func() {
		if got != nil {
			t.Errorf("e2t_ssa(s)=%v want nil", got)
		}
		e := recover()
		err, ok := e.(*runtime.TypeAssertionError)
		if !ok {
			t.Errorf("e2t_ssa(s) panic type %T", e)
		}
		want := "interface conversion: interface {} is *main.S, not *main.U"
		if err.Error() != want {

	RuntimeError()
}

// A TypeAssertionError explains a failed type assertion.
type TypeAssertionError struct {
	_interface    *_type
	concrete      *_type
	asserted      *_type
	missingMethod string // one method needed by Interface, missing from Concrete
}

func (*TypeAssertionError) RuntimeError() {}

func (e *TypeAssertionError) Error() string {
	inter := "interface"
	if e._interface != nil {

		throw("internal error - misuse of itab")
	}

	// easy case
	if typ.TFlag&abi.TFlagUncommon == 0 {
		if canfail {
			return nil
		}
		name := toRType(&inter.Type).nameOff(inter.Methods[0].Name)
		panic(&TypeAssertionError{nil, typ, &inter.Type, name.Name()})
	}

	var m *itab

	// First, look in the existing table to see if we can find the itab we need.
	// This is by far the most common case, so do it without locks.

		{"(*PanicNilError).RuntimeError", Method, 21},
		{"(*Pinner).Pin", Method, 21},
		{"(*Pinner).Unpin", Method, 21},
		{"(*StackRecord).Stack", Method, 0},
		{"(*TypeAssertionError).Error", Method, 0},
		{"(*TypeAssertionError).RuntimeError", Method, 0},
		{"BlockProfile", Func, 1},
		{"BlockProfileRecord", Type, 1},
		{"BlockProfileRecord.Count", Field, 1},
		{"BlockProfileRecord.Cycles", Field, 1},

pkg runtime, method (*MemProfileRecord) InUseObjects() int64
pkg runtime, method (*MemProfileRecord) Stack() []uintptr
pkg runtime, method (*StackRecord) Stack() []uintptr
pkg runtime, method (*TypeAssertionError) Error() string
pkg runtime, method (*TypeAssertionError) RuntimeError()
pkg runtime, type Error interface { Error, RuntimeError }
pkg runtime, type Error interface, Error() string
pkg runtime, type Error interface, RuntimeError()