func (f *FakeChanneler) ChannelSendCalled() bool {
	return len(f.ChannelSendCalls) != 0
}
ChannelSendCalled returns true if FakeChanneler.ChannelSend was called
package main
import "reflect"
type ChannelerChannelInvocation struct {
	Parameters struct {
		Ident1 chan int
	}
	Results struct {
		Ident2 chan int
	}
}
func NewChannelerChannelInvocation(ident1 chan int, ident2 chan int) *ChannelerChannelInvocation {
	invocation := new(ChannelerChannelInvocation)
	invocation.Parameters.Ident1 = ident1
	invocation.Results.Ident2 = ident2
	return invocation
}
type ChannelerChannelReceiveInvocation struct {
	Parameters struct {
		Ident1 <-chan int
	}
	Results struct {
		Ident2 <-chan int
	}
}
func NewChannelerChannelReceiveInvocation(ident1 <-chan int, ident2 <-chan int) *ChannelerChannelReceiveInvocation {
	invocation := new(ChannelerChannelReceiveInvocation)
	invocation.Parameters.Ident1 = ident1
	invocation.Results.Ident2 = ident2
	return invocation
}
type ChannelerChannelSendInvocation struct {
	Parameters struct {
		Ident1 chan<- int
	}
	Results struct {
		Ident2 chan<- int
	}
}
func NewChannelerChannelSendInvocation(ident1 chan<- int, ident2 chan<- int) *ChannelerChannelSendInvocation {
	invocation := new(ChannelerChannelSendInvocation)
	invocation.Parameters.Ident1 = ident1
	invocation.Results.Ident2 = ident2
	return invocation
}
type ChannelerChannelPointerInvocation struct {
	Parameters struct {
		Ident1 *chan int
	}
	Results struct {
		Ident2 *chan int
	}
}
func NewChannelerChannelPointerInvocation(ident1 *chan int, ident2 *chan int) *ChannelerChannelPointerInvocation {
	invocation := new(ChannelerChannelPointerInvocation)
	invocation.Parameters.Ident1 = ident1
	invocation.Results.Ident2 = ident2
	return invocation
}
type ChannelerChannelInterfaceInvocation struct {
	Parameters struct {
		Ident1 chan interface{}
	}
	Results struct {
		Ident2 chan interface{}
	}
}
func NewChannelerChannelInterfaceInvocation(ident1 chan interface{}, ident2 chan interface{}) *ChannelerChannelInterfaceInvocation {
	invocation := new(ChannelerChannelInterfaceInvocation)
	invocation.Parameters.Ident1 = ident1
	invocation.Results.Ident2 = ident2
	return invocation
}
type ChannelerTestingT interface {
	Error(...interface{})
	Errorf(string, ...interface{})
	Fatal(...interface{})
	Helper()
}
type FakeChanneler struct {
	ChannelHook          func(chan int) chan int
	ChannelReceiveHook   func(<-chan int) <-chan int
	ChannelSendHook      func(chan<- int) chan<- int
	ChannelPointerHook   func(*chan int) *chan int
	ChannelInterfaceHook func(chan interface{}) chan interface{}
	ChannelCalls          []*ChannelerChannelInvocation
	ChannelReceiveCalls   []*ChannelerChannelReceiveInvocation
	ChannelSendCalls      []*ChannelerChannelSendInvocation
	ChannelPointerCalls   []*ChannelerChannelPointerInvocation
	ChannelInterfaceCalls []*ChannelerChannelInterfaceInvocation
}
func NewFakeChannelerDefaultPanic() *FakeChanneler {
	return &FakeChanneler{
		ChannelHook: func(chan int) (ident2 chan int) {
			panic("Unexpected call to Channeler.Channel")
		},
		ChannelReceiveHook: func(<-chan int) (ident2 <-chan int) {
			panic("Unexpected call to Channeler.ChannelReceive")
		},
		ChannelSendHook: func(chan<- int) (ident2 chan<- int) {
			panic("Unexpected call to Channeler.ChannelSend")
		},
		ChannelPointerHook: func(*chan int) (ident2 *chan int) {
			panic("Unexpected call to Channeler.ChannelPointer")
		},
		ChannelInterfaceHook: func(chan interface{}) (ident2 chan interface{}) {
			panic("Unexpected call to Channeler.ChannelInterface")
		},
	}
}
func NewFakeChannelerDefaultFatal(t_sym1 ChannelerTestingT) *FakeChanneler {
	return &FakeChanneler{
		ChannelHook: func(chan int) (ident2 chan int) {
			t_sym1.Fatal("Unexpected call to Channeler.Channel")
			return
		},
		ChannelReceiveHook: func(<-chan int) (ident2 <-chan int) {
			t_sym1.Fatal("Unexpected call to Channeler.ChannelReceive")
			return
		},
		ChannelSendHook: func(chan<- int) (ident2 chan<- int) {
			t_sym1.Fatal("Unexpected call to Channeler.ChannelSend")
			return
		},
		ChannelPointerHook: func(*chan int) (ident2 *chan int) {
			t_sym1.Fatal("Unexpected call to Channeler.ChannelPointer")
			return
		},
		ChannelInterfaceHook: func(chan interface{}) (ident2 chan interface{}) {
			t_sym1.Fatal("Unexpected call to Channeler.ChannelInterface")
			return
		},
	}
}
func NewFakeChannelerDefaultError(t_sym2 ChannelerTestingT) *FakeChanneler {
	return &FakeChanneler{
		ChannelHook: func(chan int) (ident2 chan int) {
			t_sym2.Error("Unexpected call to Channeler.Channel")
			return
		},
		ChannelReceiveHook: func(<-chan int) (ident2 <-chan int) {
			t_sym2.Error("Unexpected call to Channeler.ChannelReceive")
			return
		},
		ChannelSendHook: func(chan<- int) (ident2 chan<- int) {
			t_sym2.Error("Unexpected call to Channeler.ChannelSend")
			return
		},
		ChannelPointerHook: func(*chan int) (ident2 *chan int) {
			t_sym2.Error("Unexpected call to Channeler.ChannelPointer")
			return
		},
		ChannelInterfaceHook: func(chan interface{}) (ident2 chan interface{}) {
			t_sym2.Error("Unexpected call to Channeler.ChannelInterface")
			return
		},
	}
}
func (f *FakeChanneler) Reset() {
	f.ChannelCalls = []*ChannelerChannelInvocation{}
	f.ChannelReceiveCalls = []*ChannelerChannelReceiveInvocation{}
	f.ChannelSendCalls = []*ChannelerChannelSendInvocation{}
	f.ChannelPointerCalls = []*ChannelerChannelPointerInvocation{}
	f.ChannelInterfaceCalls = []*ChannelerChannelInterfaceInvocation{}
}
func (f_sym3 *FakeChanneler) Channel(ident1 chan int) (ident2 chan int) {
	if f_sym3.ChannelHook == nil {
		panic("Channeler.Channel() called but FakeChanneler.ChannelHook is nil")
	}
	invocation_sym3 := new(ChannelerChannelInvocation)
	f_sym3.ChannelCalls = append(f_sym3.ChannelCalls, invocation_sym3)
	invocation_sym3.Parameters.Ident1 = ident1
	ident2 = f_sym3.ChannelHook(ident1)
	invocation_sym3.Results.Ident2 = ident2
	return
}
func (f_sym4 *FakeChanneler) SetChannelStub(ident2 chan int) {
	f_sym4.ChannelHook = func(chan int) chan int {
		return ident2
	}
}
func (f_sym5 *FakeChanneler) SetChannelInvocation(calls_sym5 []*ChannelerChannelInvocation, fallback_sym5 func() chan int) {
	f_sym5.ChannelHook = func(ident1 chan int) (ident2 chan int) {
		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 *FakeChanneler) ChannelCalled() bool {
	return len(f.ChannelCalls) != 0
}
func (f *FakeChanneler) AssertChannelCalled(t ChannelerTestingT) {
	t.Helper()
	if len(f.ChannelCalls) == 0 {
		t.Error("FakeChanneler.Channel not called, expected at least one")
	}
}
func (f *FakeChanneler) ChannelNotCalled() bool {
	return len(f.ChannelCalls) == 0
}
func (f *FakeChanneler) AssertChannelNotCalled(t ChannelerTestingT) {
	t.Helper()
	if len(f.ChannelCalls) != 0 {
		t.Error("FakeChanneler.Channel called, expected none")
	}
}
func (f *FakeChanneler) ChannelCalledOnce() bool {
	return len(f.ChannelCalls) == 1
}
func (f *FakeChanneler) AssertChannelCalledOnce(t ChannelerTestingT) {
	t.Helper()
	if len(f.ChannelCalls) != 1 {
		t.Errorf("FakeChanneler.Channel called %d times, expected 1", len(f.ChannelCalls))
	}
}
func (f *FakeChanneler) ChannelCalledN(n int) bool {
	return len(f.ChannelCalls) >= n
}
func (f *FakeChanneler) AssertChannelCalledN(t ChannelerTestingT, n int) {
	t.Helper()
	if len(f.ChannelCalls) < n {
		t.Errorf("FakeChanneler.Channel called %d times, expected >= %d", len(f.ChannelCalls), n)
	}
}
func (f_sym6 *FakeChanneler) ChannelCalledWith(ident1 chan int) bool {
	for _, call_sym6 := range f_sym6.ChannelCalls {
		if reflect.DeepEqual(call_sym6.Parameters.Ident1, ident1) {
			return true
		}
	}
	return false
}
func (f_sym7 *FakeChanneler) AssertChannelCalledWith(t ChannelerTestingT, ident1 chan int) {
	t.Helper()
	var found_sym7 bool
	for _, call_sym7 := range f_sym7.ChannelCalls {
		if reflect.DeepEqual(call_sym7.Parameters.Ident1, ident1) {
			found_sym7 = true
			break
		}
	}
	if !found_sym7 {
		t.Error("FakeChanneler.Channel not called with expected parameters")
	}
}
func (f_sym8 *FakeChanneler) ChannelCalledOnceWith(ident1 chan int) bool {
	var count_sym8 int
	for _, call_sym8 := range f_sym8.ChannelCalls {
		if reflect.DeepEqual(call_sym8.Parameters.Ident1, ident1) {
			count_sym8++
		}
	}
	return count_sym8 == 1
}
func (f_sym9 *FakeChanneler) AssertChannelCalledOnceWith(t ChannelerTestingT, ident1 chan int) {
	t.Helper()
	var count_sym9 int
	for _, call_sym9 := range f_sym9.ChannelCalls {
		if reflect.DeepEqual(call_sym9.Parameters.Ident1, ident1) {
			count_sym9++
		}
	}
	if count_sym9 != 1 {
		t.Errorf("FakeChanneler.Channel called %d times with expected parameters, expected one", count_sym9)
	}
}
func (f_sym10 *FakeChanneler) ChannelResultsForCall(ident1 chan int) (ident2 chan int, found_sym10 bool) {
	for _, call_sym10 := range f_sym10.ChannelCalls {
		if reflect.DeepEqual(call_sym10.Parameters.Ident1, ident1) {
			ident2 = call_sym10.Results.Ident2
			found_sym10 = true
			break
		}
	}
	return
}
func (f_sym11 *FakeChanneler) ChannelReceive(ident1 <-chan int) (ident2 <-chan int) {
	if f_sym11.ChannelReceiveHook == nil {
		panic("Channeler.ChannelReceive() called but FakeChanneler.ChannelReceiveHook is nil")
	}
	invocation_sym11 := new(ChannelerChannelReceiveInvocation)
	f_sym11.ChannelReceiveCalls = append(f_sym11.ChannelReceiveCalls, invocation_sym11)
	invocation_sym11.Parameters.Ident1 = ident1
	ident2 = f_sym11.ChannelReceiveHook(ident1)
	invocation_sym11.Results.Ident2 = ident2
	return
}
func (f_sym12 *FakeChanneler) SetChannelReceiveStub(ident2 <-chan int) {
	f_sym12.ChannelReceiveHook = func(<-chan int) <-chan int {
		return ident2
	}
}
func (f_sym13 *FakeChanneler) SetChannelReceiveInvocation(calls_sym13 []*ChannelerChannelReceiveInvocation, fallback_sym13 func() <-chan int) {
	f_sym13.ChannelReceiveHook = func(ident1 <-chan int) (ident2 <-chan int) {
		for _, call_sym13 := range calls_sym13 {
			if reflect.DeepEqual(call_sym13.Parameters.Ident1, ident1) {
				ident2 = call_sym13.Results.Ident2
				return
			}
		}
		return fallback_sym13()
	}
}
func (f *FakeChanneler) ChannelReceiveCalled() bool {
	return len(f.ChannelReceiveCalls) != 0
}
func (f *FakeChanneler) AssertChannelReceiveCalled(t ChannelerTestingT) {
	t.Helper()
	if len(f.ChannelReceiveCalls) == 0 {
		t.Error("FakeChanneler.ChannelReceive not called, expected at least one")
	}
}
func (f *FakeChanneler) ChannelReceiveNotCalled() bool {
	return len(f.ChannelReceiveCalls) == 0
}
func (f *FakeChanneler) AssertChannelReceiveNotCalled(t ChannelerTestingT) {
	t.Helper()
	if len(f.ChannelReceiveCalls) != 0 {
		t.Error("FakeChanneler.ChannelReceive called, expected none")
	}
}
func (f *FakeChanneler) ChannelReceiveCalledOnce() bool {
	return len(f.ChannelReceiveCalls) == 1
}
func (f *FakeChanneler) AssertChannelReceiveCalledOnce(t ChannelerTestingT) {
	t.Helper()
	if len(f.ChannelReceiveCalls) != 1 {
		t.Errorf("FakeChanneler.ChannelReceive called %d times, expected 1", len(f.ChannelReceiveCalls))
	}
}
func (f *FakeChanneler) ChannelReceiveCalledN(n int) bool {
	return len(f.ChannelReceiveCalls) >= n
}
func (f *FakeChanneler) AssertChannelReceiveCalledN(t ChannelerTestingT, n int) {
	t.Helper()
	if len(f.ChannelReceiveCalls) < n {
		t.Errorf("FakeChanneler.ChannelReceive called %d times, expected >= %d", len(f.ChannelReceiveCalls), n)
	}
}
func (f_sym14 *FakeChanneler) ChannelReceiveCalledWith(ident1 <-chan int) bool {
	for _, call_sym14 := range f_sym14.ChannelReceiveCalls {
		if reflect.DeepEqual(call_sym14.Parameters.Ident1, ident1) {
			return true
		}
	}
	return false
}
func (f_sym15 *FakeChanneler) AssertChannelReceiveCalledWith(t ChannelerTestingT, ident1 <-chan int) {
	t.Helper()
	var found_sym15 bool
	for _, call_sym15 := range f_sym15.ChannelReceiveCalls {
		if reflect.DeepEqual(call_sym15.Parameters.Ident1, ident1) {
			found_sym15 = true
			break
		}
	}
	if !found_sym15 {
		t.Error("FakeChanneler.ChannelReceive not called with expected parameters")
	}
}
func (f_sym16 *FakeChanneler) ChannelReceiveCalledOnceWith(ident1 <-chan int) bool {
	var count_sym16 int
	for _, call_sym16 := range f_sym16.ChannelReceiveCalls {
		if reflect.DeepEqual(call_sym16.Parameters.Ident1, ident1) {
			count_sym16++
		}
	}
	return count_sym16 == 1
}
func (f_sym17 *FakeChanneler) AssertChannelReceiveCalledOnceWith(t ChannelerTestingT, ident1 <-chan int) {
	t.Helper()
	var count_sym17 int
	for _, call_sym17 := range f_sym17.ChannelReceiveCalls {
		if reflect.DeepEqual(call_sym17.Parameters.Ident1, ident1) {
			count_sym17++
		}
	}
	if count_sym17 != 1 {
		t.Errorf("FakeChanneler.ChannelReceive called %d times with expected parameters, expected one", count_sym17)
	}
}
func (f_sym18 *FakeChanneler) ChannelReceiveResultsForCall(ident1 <-chan int) (ident2 <-chan int, found_sym18 bool) {
	for _, call_sym18 := range f_sym18.ChannelReceiveCalls {
		if reflect.DeepEqual(call_sym18.Parameters.Ident1, ident1) {
			ident2 = call_sym18.Results.Ident2
			found_sym18 = true
			break
		}
	}
	return
}
func (f_sym19 *FakeChanneler) ChannelSend(ident1 chan<- int) (ident2 chan<- int) {
	if f_sym19.ChannelSendHook == nil {
		panic("Channeler.ChannelSend() called but FakeChanneler.ChannelSendHook is nil")
	}
	invocation_sym19 := new(ChannelerChannelSendInvocation)
	f_sym19.ChannelSendCalls = append(f_sym19.ChannelSendCalls, invocation_sym19)
	invocation_sym19.Parameters.Ident1 = ident1
	ident2 = f_sym19.ChannelSendHook(ident1)
	invocation_sym19.Results.Ident2 = ident2
	return
}
func (f_sym20 *FakeChanneler) SetChannelSendStub(ident2 chan<- int) {
	f_sym20.ChannelSendHook = func(chan<- int) chan<- int {
		return ident2
	}
}
func (f_sym21 *FakeChanneler) SetChannelSendInvocation(calls_sym21 []*ChannelerChannelSendInvocation, fallback_sym21 func() chan<- int) {
	f_sym21.ChannelSendHook = func(ident1 chan<- int) (ident2 chan<- int) {
		for _, call_sym21 := range calls_sym21 {
			if reflect.DeepEqual(call_sym21.Parameters.Ident1, ident1) {
				ident2 = call_sym21.Results.Ident2
				return
			}
		}
		return fallback_sym21()
	}
}