func (f *FakeInterfacer) AssertNamedInterfaceCalledOnce(t InterfacerTestingT) {
	t.Helper()
	if len(f.NamedInterfaceCalls) != 1 {
		t.Errorf("FakeInterfacer.NamedInterface called %d times, expected 1", len(f.NamedInterfaceCalls))
	}
}
AssertNamedInterfaceCalledOnce calls t.Error if FakeInterfacer.NamedInterface was not called exactly once
package main
import "reflect"
type InterfacerInterfaceInvocation struct {
	Parameters struct {
		Ident1 interface{}
	}
	Results struct {
		Ident2 interface{}
	}
}
func NewInterfacerInterfaceInvocation(ident1 interface{}, ident2 interface{}) *InterfacerInterfaceInvocation {
	invocation := new(InterfacerInterfaceInvocation)
	invocation.Parameters.Ident1 = ident1
	invocation.Results.Ident2 = ident2
	return invocation
}
type InterfacerNamedInterfaceInvocation struct {
	Parameters struct {
		A interface{}
	}
	Results struct {
		Z interface{}
	}
}
func NewInterfacerNamedInterfaceInvocation(a interface{}, z interface{}) *InterfacerNamedInterfaceInvocation {
	invocation := new(InterfacerNamedInterfaceInvocation)
	invocation.Parameters.A = a
	invocation.Results.Z = z
	return invocation
}
type InterfacerTestingT interface {
	Error(...interface{})
	Errorf(string, ...interface{})
	Fatal(...interface{})
	Helper()
}
type FakeInterfacer struct {
	InterfaceHook      func(interface{}) interface{}
	NamedInterfaceHook func(interface{}) interface{}
	InterfaceCalls      []*InterfacerInterfaceInvocation
	NamedInterfaceCalls []*InterfacerNamedInterfaceInvocation
}
func NewFakeInterfacerDefaultPanic() *FakeInterfacer {
	return &FakeInterfacer{
		InterfaceHook: func(interface{}) (ident2 interface{}) {
			panic("Unexpected call to Interfacer.Interface")
		},
		NamedInterfaceHook: func(interface{}) (z interface{}) {
			panic("Unexpected call to Interfacer.NamedInterface")
		},
	}
}
func NewFakeInterfacerDefaultFatal(t_sym1 InterfacerTestingT) *FakeInterfacer {
	return &FakeInterfacer{
		InterfaceHook: func(interface{}) (ident2 interface{}) {
			t_sym1.Fatal("Unexpected call to Interfacer.Interface")
			return
		},
		NamedInterfaceHook: func(interface{}) (z interface{}) {
			t_sym1.Fatal("Unexpected call to Interfacer.NamedInterface")
			return
		},
	}
}
func NewFakeInterfacerDefaultError(t_sym2 InterfacerTestingT) *FakeInterfacer {
	return &FakeInterfacer{
		InterfaceHook: func(interface{}) (ident2 interface{}) {
			t_sym2.Error("Unexpected call to Interfacer.Interface")
			return
		},
		NamedInterfaceHook: func(interface{}) (z interface{}) {
			t_sym2.Error("Unexpected call to Interfacer.NamedInterface")
			return
		},
	}
}
func (f *FakeInterfacer) Reset() {
	f.InterfaceCalls = []*InterfacerInterfaceInvocation{}
	f.NamedInterfaceCalls = []*InterfacerNamedInterfaceInvocation{}
}
func (f_sym3 *FakeInterfacer) Interface(ident1 interface{}) (ident2 interface{}) {
	if f_sym3.InterfaceHook == nil {
		panic("Interfacer.Interface() called but FakeInterfacer.InterfaceHook is nil")
	}
	invocation_sym3 := new(InterfacerInterfaceInvocation)
	f_sym3.InterfaceCalls = append(f_sym3.InterfaceCalls, invocation_sym3)
	invocation_sym3.Parameters.Ident1 = ident1
	ident2 = f_sym3.InterfaceHook(ident1)
	invocation_sym3.Results.Ident2 = ident2
	return
}
func (f_sym4 *FakeInterfacer) SetInterfaceStub(ident2 interface{}) {
	f_sym4.InterfaceHook = func(interface{}) interface{} {
		return ident2
	}
}
func (f_sym5 *FakeInterfacer) SetInterfaceInvocation(calls_sym5 []*InterfacerInterfaceInvocation, fallback_sym5 func() interface{}) {
	f_sym5.InterfaceHook = func(ident1 interface{}) (ident2 interface{}) {
		for _, call_sym5 := range calls_sym5 {
			if reflect.DeepEqual(call_sym5.Parameters.Ident1, ident1) {
				ident2 = call_sym5.Results.Ident2
				return
			}
		}
		return fallback_sym5()
	}
}
func (f *FakeInterfacer) InterfaceCalled() bool {
	return len(f.InterfaceCalls) != 0
}
func (f *FakeInterfacer) AssertInterfaceCalled(t InterfacerTestingT) {
	t.Helper()
	if len(f.InterfaceCalls) == 0 {
		t.Error("FakeInterfacer.Interface not called, expected at least one")
	}
}
func (f *FakeInterfacer) InterfaceNotCalled() bool {
	return len(f.InterfaceCalls) == 0
}
func (f *FakeInterfacer) AssertInterfaceNotCalled(t InterfacerTestingT) {
	t.Helper()
	if len(f.InterfaceCalls) != 0 {
		t.Error("FakeInterfacer.Interface called, expected none")
	}
}
func (f *FakeInterfacer) InterfaceCalledOnce() bool {
	return len(f.InterfaceCalls) == 1
}
func (f *FakeInterfacer) AssertInterfaceCalledOnce(t InterfacerTestingT) {
	t.Helper()
	if len(f.InterfaceCalls) != 1 {
		t.Errorf("FakeInterfacer.Interface called %d times, expected 1", len(f.InterfaceCalls))
	}
}
func (f *FakeInterfacer) InterfaceCalledN(n int) bool {
	return len(f.InterfaceCalls) >= n
}
func (f *FakeInterfacer) AssertInterfaceCalledN(t InterfacerTestingT, n int) {
	t.Helper()
	if len(f.InterfaceCalls) < n {
		t.Errorf("FakeInterfacer.Interface called %d times, expected >= %d", len(f.InterfaceCalls), n)
	}
}
func (f_sym6 *FakeInterfacer) InterfaceCalledWith(ident1 interface{}) bool {
	for _, call_sym6 := range f_sym6.InterfaceCalls {
		if reflect.DeepEqual(call_sym6.Parameters.Ident1, ident1) {
			return true
		}
	}
	return false
}
func (f_sym7 *FakeInterfacer) AssertInterfaceCalledWith(t InterfacerTestingT, ident1 interface{}) {
	t.Helper()
	var found_sym7 bool
	for _, call_sym7 := range f_sym7.InterfaceCalls {
		if reflect.DeepEqual(call_sym7.Parameters.Ident1, ident1) {
			found_sym7 = true
			break
		}
	}
	if !found_sym7 {
		t.Error("FakeInterfacer.Interface not called with expected parameters")
	}
}
func (f_sym8 *FakeInterfacer) InterfaceCalledOnceWith(ident1 interface{}) bool {
	var count_sym8 int
	for _, call_sym8 := range f_sym8.InterfaceCalls {
		if reflect.DeepEqual(call_sym8.Parameters.Ident1, ident1) {
			count_sym8++
		}
	}
	return count_sym8 == 1
}
func (f_sym9 *FakeInterfacer) AssertInterfaceCalledOnceWith(t InterfacerTestingT, ident1 interface{}) {
	t.Helper()
	var count_sym9 int
	for _, call_sym9 := range f_sym9.InterfaceCalls {
		if reflect.DeepEqual(call_sym9.Parameters.Ident1, ident1) {
			count_sym9++
		}
	}
	if count_sym9 != 1 {
		t.Errorf("FakeInterfacer.Interface called %d times with expected parameters, expected one", count_sym9)
	}
}
func (f_sym10 *FakeInterfacer) InterfaceResultsForCall(ident1 interface{}) (ident2 interface{}, found_sym10 bool) {
	for _, call_sym10 := range f_sym10.InterfaceCalls {
		if reflect.DeepEqual(call_sym10.Parameters.Ident1, ident1) {
			ident2 = call_sym10.Results.Ident2
			found_sym10 = true
			break
		}
	}
	return
}
func (f_sym11 *FakeInterfacer) NamedInterface(a interface{}) (z interface{}) {
	if f_sym11.NamedInterfaceHook == nil {
		panic("Interfacer.NamedInterface() called but FakeInterfacer.NamedInterfaceHook is nil")
	}
	invocation_sym11 := new(InterfacerNamedInterfaceInvocation)
	f_sym11.NamedInterfaceCalls = append(f_sym11.NamedInterfaceCalls, invocation_sym11)
	invocation_sym11.Parameters.A = a
	z = f_sym11.NamedInterfaceHook(a)
	invocation_sym11.Results.Z = z
	return
}
func (f_sym12 *FakeInterfacer) SetNamedInterfaceStub(z interface{}) {
	f_sym12.NamedInterfaceHook = func(interface{}) interface{} {
		return z
	}
}
func (f_sym13 *FakeInterfacer) SetNamedInterfaceInvocation(calls_sym13 []*InterfacerNamedInterfaceInvocation, fallback_sym13 func() interface{}) {
	f_sym13.NamedInterfaceHook = func(a interface{}) (z interface{}) {
		for _, call_sym13 := range calls_sym13 {
			if reflect.DeepEqual(call_sym13.Parameters.A, a) {
				z = call_sym13.Results.Z
				return
			}
		}
		return fallback_sym13()
	}
}
func (f *FakeInterfacer) NamedInterfaceCalled() bool {
	return len(f.NamedInterfaceCalls) != 0
}
func (f *FakeInterfacer) AssertNamedInterfaceCalled(t InterfacerTestingT) {
	t.Helper()
	if len(f.NamedInterfaceCalls) == 0 {
		t.Error("FakeInterfacer.NamedInterface not called, expected at least one")
	}
}
func (f *FakeInterfacer) NamedInterfaceNotCalled() bool {
	return len(f.NamedInterfaceCalls) == 0
}
func (f *FakeInterfacer) AssertNamedInterfaceNotCalled(t InterfacerTestingT) {
	t.Helper()
	if len(f.NamedInterfaceCalls) != 0 {
		t.Error("FakeInterfacer.NamedInterface called, expected none")
	}
}
func (f *FakeInterfacer) NamedInterfaceCalledOnce() bool {
	return len(f.NamedInterfaceCalls) == 1
}