From ac75b9548e34e76777f1da7c9860c0f225a18087 Mon Sep 17 00:00:00 2001 From: LandryBe Date: Thu, 7 Jul 2022 15:56:19 +0200 Subject: [PATCH] fix: use package path instead of name Co-authored-by: Fernandez Ludovic --- mocktail.go | 2 +- testdata/src/b/b.go | 5 + testdata/src/b/c/foo.go | 38 + testdata/src/b/c/mock_gen_test.go | 2905 ++++++++++++++++++++++ testdata/src/b/c/mock_gen_test.go.golden | 2905 ++++++++++++++++++++++ testdata/src/b/c/mock_test.go | 36 + testdata/src/b/go.mod | 16 + testdata/src/b/go.sum | 20 + 8 files changed, 5926 insertions(+), 1 deletion(-) create mode 100644 testdata/src/b/b.go create mode 100644 testdata/src/b/c/foo.go create mode 100644 testdata/src/b/c/mock_gen_test.go create mode 100644 testdata/src/b/c/mock_gen_test.go.golden create mode 100644 testdata/src/b/c/mock_test.go create mode 100644 testdata/src/b/go.mod create mode 100644 testdata/src/b/go.sum diff --git a/mocktail.go b/mocktail.go index a3b5f39..06870db 100644 --- a/mocktail.go +++ b/mocktail.go @@ -148,7 +148,7 @@ func walk(root, moduleName string) (map[string]PackageDesc, error) { interfaceDesc.Methods = append(interfaceDesc.Methods, method) - for _, imp := range getMethodImports(method, packageDesc.Pkg.Name()) { + for _, imp := range getMethodImports(method, packageDesc.Pkg.Path()) { packageDesc.Imports[imp] = struct{}{} } } diff --git a/testdata/src/b/b.go b/testdata/src/b/b.go new file mode 100644 index 0000000..4736151 --- /dev/null +++ b/testdata/src/b/b.go @@ -0,0 +1,5 @@ +package b + +func Hello() string { + return "hello" +} diff --git a/testdata/src/b/c/foo.go b/testdata/src/b/c/foo.go new file mode 100644 index 0000000..adb8b9e --- /dev/null +++ b/testdata/src/b/c/foo.go @@ -0,0 +1,38 @@ +package c + +import ( + "bytes" + "context" + "time" + + "golang.org/x/mod/module" +) + +type Pineapple interface { + Hello(bar Water) string + World() string + Goo() (string, int, Water) + Coo(context.Context, string, Water) Water +} + +type Coconut interface { + Boo(src *bytes.Buffer) time.Duration + Doo(src time.Duration) time.Duration + Foo(st Strawberry) string + Goo(st string) Strawberry + Hoo(string, int, Water) + Joo(string, int, Water) (string, int) + Koo(src string) (dst string) + Loo(st string, values ...int) string + Too(src string) time.Duration + Voo(src *module.Version) time.Duration + Yoo(st string) interface{} + Zoo(st interface{}) string + Moo(fn func(st, stban Strawberry) Pineapple) string +} + +type Water struct{} + +type Strawberry interface { + Bar(string) int +} diff --git a/testdata/src/b/c/mock_gen_test.go b/testdata/src/b/c/mock_gen_test.go new file mode 100644 index 0000000..f0f0f65 --- /dev/null +++ b/testdata/src/b/c/mock_gen_test.go @@ -0,0 +1,2905 @@ +// Code generated by mocktail; DO NOT EDIT. + +package c + +import ( + "bytes" + "context" + "testing" + "time" + + "github.com/stretchr/testify/mock" + "golang.org/x/mod/module" +) + +// pineappleMock mock of Pineapple. +type pineappleMock struct{ mock.Mock } + +// newPineappleMock creates a new pineappleMock. +func newPineappleMock(tb testing.TB) *pineappleMock { + tb.Helper() + + m := &pineappleMock{} + m.Mock.Test(tb) + + tb.Cleanup(func() { m.AssertExpectations(tb) }) + + return m +} + +func (_m *pineappleMock) Coo(_ context.Context, bParam string, cParam Water) Water { + _ret := _m.Called(bParam, cParam) + + if _rf, ok := _ret.Get(0).(func(string, Water) Water); ok { + return _rf(bParam, cParam) + } + + _ra0, _ := _ret.Get(0).(Water) + + return _ra0 +} + +func (_m *pineappleMock) OnCoo(bParam string, cParam Water) *pineappleCooCall { + return &pineappleCooCall{Call: _m.Mock.On("Coo", bParam, cParam), Parent: _m} +} + +func (_m *pineappleMock) OnCooRaw(bParam interface{}, cParam interface{}) *pineappleCooCall { + return &pineappleCooCall{Call: _m.Mock.On("Coo", bParam, cParam), Parent: _m} +} + +type pineappleCooCall struct { + *mock.Call + Parent *pineappleMock +} + +func (_c *pineappleCooCall) Panic(msg string) *pineappleCooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *pineappleCooCall) Once() *pineappleCooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *pineappleCooCall) Twice() *pineappleCooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *pineappleCooCall) Times(i int) *pineappleCooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *pineappleCooCall) WaitUntil(w <-chan time.Time) *pineappleCooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *pineappleCooCall) After(d time.Duration) *pineappleCooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *pineappleCooCall) Run(fn func(args mock.Arguments)) *pineappleCooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *pineappleCooCall) Maybe() *pineappleCooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *pineappleCooCall) TypedReturns(a Water) *pineappleCooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *pineappleCooCall) ReturnsFn(fn func(string, Water) Water) *pineappleCooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *pineappleCooCall) TypedRun(fn func(string, Water)) *pineappleCooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _bParam := args.String(0) + _cParam, _ := args.Get(1).(Water) + fn(_bParam, _cParam) + }) + return _c +} + +func (_c *pineappleCooCall) OnCoo(bParam string, cParam Water) *pineappleCooCall { + return _c.Parent.OnCoo(bParam, cParam) +} + +func (_c *pineappleCooCall) OnGoo() *pineappleGooCall { + return _c.Parent.OnGoo() +} + +func (_c *pineappleCooCall) OnHello(bar Water) *pineappleHelloCall { + return _c.Parent.OnHello(bar) +} + +func (_c *pineappleCooCall) OnWorld() *pineappleWorldCall { + return _c.Parent.OnWorld() +} + +func (_c *pineappleCooCall) OnCooRaw(bParam interface{}, cParam interface{}) *pineappleCooCall { + return _c.Parent.OnCooRaw(bParam, cParam) +} + +func (_c *pineappleCooCall) OnGooRaw() *pineappleGooCall { + return _c.Parent.OnGooRaw() +} + +func (_c *pineappleCooCall) OnHelloRaw(bar interface{}) *pineappleHelloCall { + return _c.Parent.OnHelloRaw(bar) +} + +func (_c *pineappleCooCall) OnWorldRaw() *pineappleWorldCall { + return _c.Parent.OnWorldRaw() +} + +func (_m *pineappleMock) Goo() (string, int, Water) { + _ret := _m.Called() + + _ra0 := _ret.String(0) + _rb1 := _ret.Int(1) + _rc2, _ := _ret.Get(2).(Water) + + return _ra0, _rb1, _rc2 +} + +func (_m *pineappleMock) OnGoo() *pineappleGooCall { + return &pineappleGooCall{Call: _m.Mock.On("Goo"), Parent: _m} +} + +func (_m *pineappleMock) OnGooRaw() *pineappleGooCall { + return &pineappleGooCall{Call: _m.Mock.On("Goo"), Parent: _m} +} + +type pineappleGooCall struct { + *mock.Call + Parent *pineappleMock +} + +func (_c *pineappleGooCall) Panic(msg string) *pineappleGooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *pineappleGooCall) Once() *pineappleGooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *pineappleGooCall) Twice() *pineappleGooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *pineappleGooCall) Times(i int) *pineappleGooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *pineappleGooCall) WaitUntil(w <-chan time.Time) *pineappleGooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *pineappleGooCall) After(d time.Duration) *pineappleGooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *pineappleGooCall) Run(fn func(args mock.Arguments)) *pineappleGooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *pineappleGooCall) Maybe() *pineappleGooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *pineappleGooCall) TypedReturns(a string, b int, c Water) *pineappleGooCall { + _c.Call = _c.Return(a, b, c) + return _c +} + +func (_c *pineappleGooCall) TypedRun(fn func()) *pineappleGooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + fn() + }) + return _c +} + +func (_c *pineappleGooCall) OnCoo(bParam string, cParam Water) *pineappleCooCall { + return _c.Parent.OnCoo(bParam, cParam) +} + +func (_c *pineappleGooCall) OnGoo() *pineappleGooCall { + return _c.Parent.OnGoo() +} + +func (_c *pineappleGooCall) OnHello(bar Water) *pineappleHelloCall { + return _c.Parent.OnHello(bar) +} + +func (_c *pineappleGooCall) OnWorld() *pineappleWorldCall { + return _c.Parent.OnWorld() +} + +func (_c *pineappleGooCall) OnCooRaw(bParam interface{}, cParam interface{}) *pineappleCooCall { + return _c.Parent.OnCooRaw(bParam, cParam) +} + +func (_c *pineappleGooCall) OnGooRaw() *pineappleGooCall { + return _c.Parent.OnGooRaw() +} + +func (_c *pineappleGooCall) OnHelloRaw(bar interface{}) *pineappleHelloCall { + return _c.Parent.OnHelloRaw(bar) +} + +func (_c *pineappleGooCall) OnWorldRaw() *pineappleWorldCall { + return _c.Parent.OnWorldRaw() +} + +func (_m *pineappleMock) Hello(bar Water) string { + _ret := _m.Called(bar) + + if _rf, ok := _ret.Get(0).(func(Water) string); ok { + return _rf(bar) + } + + _ra0 := _ret.String(0) + + return _ra0 +} + +func (_m *pineappleMock) OnHello(bar Water) *pineappleHelloCall { + return &pineappleHelloCall{Call: _m.Mock.On("Hello", bar), Parent: _m} +} + +func (_m *pineappleMock) OnHelloRaw(bar interface{}) *pineappleHelloCall { + return &pineappleHelloCall{Call: _m.Mock.On("Hello", bar), Parent: _m} +} + +type pineappleHelloCall struct { + *mock.Call + Parent *pineappleMock +} + +func (_c *pineappleHelloCall) Panic(msg string) *pineappleHelloCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *pineappleHelloCall) Once() *pineappleHelloCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *pineappleHelloCall) Twice() *pineappleHelloCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *pineappleHelloCall) Times(i int) *pineappleHelloCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *pineappleHelloCall) WaitUntil(w <-chan time.Time) *pineappleHelloCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *pineappleHelloCall) After(d time.Duration) *pineappleHelloCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *pineappleHelloCall) Run(fn func(args mock.Arguments)) *pineappleHelloCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *pineappleHelloCall) Maybe() *pineappleHelloCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *pineappleHelloCall) TypedReturns(a string) *pineappleHelloCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *pineappleHelloCall) ReturnsFn(fn func(Water) string) *pineappleHelloCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *pineappleHelloCall) TypedRun(fn func(Water)) *pineappleHelloCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _bar, _ := args.Get(0).(Water) + fn(_bar) + }) + return _c +} + +func (_c *pineappleHelloCall) OnCoo(bParam string, cParam Water) *pineappleCooCall { + return _c.Parent.OnCoo(bParam, cParam) +} + +func (_c *pineappleHelloCall) OnGoo() *pineappleGooCall { + return _c.Parent.OnGoo() +} + +func (_c *pineappleHelloCall) OnHello(bar Water) *pineappleHelloCall { + return _c.Parent.OnHello(bar) +} + +func (_c *pineappleHelloCall) OnWorld() *pineappleWorldCall { + return _c.Parent.OnWorld() +} + +func (_c *pineappleHelloCall) OnCooRaw(bParam interface{}, cParam interface{}) *pineappleCooCall { + return _c.Parent.OnCooRaw(bParam, cParam) +} + +func (_c *pineappleHelloCall) OnGooRaw() *pineappleGooCall { + return _c.Parent.OnGooRaw() +} + +func (_c *pineappleHelloCall) OnHelloRaw(bar interface{}) *pineappleHelloCall { + return _c.Parent.OnHelloRaw(bar) +} + +func (_c *pineappleHelloCall) OnWorldRaw() *pineappleWorldCall { + return _c.Parent.OnWorldRaw() +} + +func (_m *pineappleMock) World() string { + _ret := _m.Called() + + _ra0 := _ret.String(0) + + return _ra0 +} + +func (_m *pineappleMock) OnWorld() *pineappleWorldCall { + return &pineappleWorldCall{Call: _m.Mock.On("World"), Parent: _m} +} + +func (_m *pineappleMock) OnWorldRaw() *pineappleWorldCall { + return &pineappleWorldCall{Call: _m.Mock.On("World"), Parent: _m} +} + +type pineappleWorldCall struct { + *mock.Call + Parent *pineappleMock +} + +func (_c *pineappleWorldCall) Panic(msg string) *pineappleWorldCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *pineappleWorldCall) Once() *pineappleWorldCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *pineappleWorldCall) Twice() *pineappleWorldCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *pineappleWorldCall) Times(i int) *pineappleWorldCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *pineappleWorldCall) WaitUntil(w <-chan time.Time) *pineappleWorldCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *pineappleWorldCall) After(d time.Duration) *pineappleWorldCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *pineappleWorldCall) Run(fn func(args mock.Arguments)) *pineappleWorldCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *pineappleWorldCall) Maybe() *pineappleWorldCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *pineappleWorldCall) TypedReturns(a string) *pineappleWorldCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *pineappleWorldCall) TypedRun(fn func()) *pineappleWorldCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + fn() + }) + return _c +} + +func (_c *pineappleWorldCall) OnCoo(bParam string, cParam Water) *pineappleCooCall { + return _c.Parent.OnCoo(bParam, cParam) +} + +func (_c *pineappleWorldCall) OnGoo() *pineappleGooCall { + return _c.Parent.OnGoo() +} + +func (_c *pineappleWorldCall) OnHello(bar Water) *pineappleHelloCall { + return _c.Parent.OnHello(bar) +} + +func (_c *pineappleWorldCall) OnWorld() *pineappleWorldCall { + return _c.Parent.OnWorld() +} + +func (_c *pineappleWorldCall) OnCooRaw(bParam interface{}, cParam interface{}) *pineappleCooCall { + return _c.Parent.OnCooRaw(bParam, cParam) +} + +func (_c *pineappleWorldCall) OnGooRaw() *pineappleGooCall { + return _c.Parent.OnGooRaw() +} + +func (_c *pineappleWorldCall) OnHelloRaw(bar interface{}) *pineappleHelloCall { + return _c.Parent.OnHelloRaw(bar) +} + +func (_c *pineappleWorldCall) OnWorldRaw() *pineappleWorldCall { + return _c.Parent.OnWorldRaw() +} + +// coconutMock mock of Coconut. +type coconutMock struct{ mock.Mock } + +// newCoconutMock creates a new coconutMock. +func newCoconutMock(tb testing.TB) *coconutMock { + tb.Helper() + + m := &coconutMock{} + m.Mock.Test(tb) + + tb.Cleanup(func() { m.AssertExpectations(tb) }) + + return m +} + +func (_m *coconutMock) Boo(src *bytes.Buffer) time.Duration { + _ret := _m.Called(src) + + if _rf, ok := _ret.Get(0).(func(*bytes.Buffer) time.Duration); ok { + return _rf(src) + } + + _ra0, _ := _ret.Get(0).(time.Duration) + + return _ra0 +} + +func (_m *coconutMock) OnBoo(src *bytes.Buffer) *coconutBooCall { + return &coconutBooCall{Call: _m.Mock.On("Boo", src), Parent: _m} +} + +func (_m *coconutMock) OnBooRaw(src interface{}) *coconutBooCall { + return &coconutBooCall{Call: _m.Mock.On("Boo", src), Parent: _m} +} + +type coconutBooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutBooCall) Panic(msg string) *coconutBooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutBooCall) Once() *coconutBooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutBooCall) Twice() *coconutBooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutBooCall) Times(i int) *coconutBooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutBooCall) WaitUntil(w <-chan time.Time) *coconutBooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutBooCall) After(d time.Duration) *coconutBooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutBooCall) Run(fn func(args mock.Arguments)) *coconutBooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutBooCall) Maybe() *coconutBooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutBooCall) TypedReturns(a time.Duration) *coconutBooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutBooCall) ReturnsFn(fn func(*bytes.Buffer) time.Duration) *coconutBooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutBooCall) TypedRun(fn func(*bytes.Buffer)) *coconutBooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _src, _ := args.Get(0).(*bytes.Buffer) + fn(_src) + }) + return _c +} + +func (_c *coconutBooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutBooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutBooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutBooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutBooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutBooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutBooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutBooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutBooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutBooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutBooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutBooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutBooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutBooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutBooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutBooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutBooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutBooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutBooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutBooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutBooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutBooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutBooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutBooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutBooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutBooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Doo(src time.Duration) time.Duration { + _ret := _m.Called(src) + + if _rf, ok := _ret.Get(0).(func(time.Duration) time.Duration); ok { + return _rf(src) + } + + _ra0, _ := _ret.Get(0).(time.Duration) + + return _ra0 +} + +func (_m *coconutMock) OnDoo(src time.Duration) *coconutDooCall { + return &coconutDooCall{Call: _m.Mock.On("Doo", src), Parent: _m} +} + +func (_m *coconutMock) OnDooRaw(src interface{}) *coconutDooCall { + return &coconutDooCall{Call: _m.Mock.On("Doo", src), Parent: _m} +} + +type coconutDooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutDooCall) Panic(msg string) *coconutDooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutDooCall) Once() *coconutDooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutDooCall) Twice() *coconutDooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutDooCall) Times(i int) *coconutDooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutDooCall) WaitUntil(w <-chan time.Time) *coconutDooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutDooCall) After(d time.Duration) *coconutDooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutDooCall) Run(fn func(args mock.Arguments)) *coconutDooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutDooCall) Maybe() *coconutDooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutDooCall) TypedReturns(a time.Duration) *coconutDooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutDooCall) ReturnsFn(fn func(time.Duration) time.Duration) *coconutDooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutDooCall) TypedRun(fn func(time.Duration)) *coconutDooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _src, _ := args.Get(0).(time.Duration) + fn(_src) + }) + return _c +} + +func (_c *coconutDooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutDooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutDooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutDooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutDooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutDooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutDooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutDooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutDooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutDooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutDooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutDooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutDooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutDooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutDooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutDooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutDooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutDooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutDooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutDooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutDooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutDooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutDooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutDooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutDooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutDooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Foo(st Strawberry) string { + _ret := _m.Called(st) + + if _rf, ok := _ret.Get(0).(func(Strawberry) string); ok { + return _rf(st) + } + + _ra0 := _ret.String(0) + + return _ra0 +} + +func (_m *coconutMock) OnFoo(st Strawberry) *coconutFooCall { + return &coconutFooCall{Call: _m.Mock.On("Foo", st), Parent: _m} +} + +func (_m *coconutMock) OnFooRaw(st interface{}) *coconutFooCall { + return &coconutFooCall{Call: _m.Mock.On("Foo", st), Parent: _m} +} + +type coconutFooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutFooCall) Panic(msg string) *coconutFooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutFooCall) Once() *coconutFooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutFooCall) Twice() *coconutFooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutFooCall) Times(i int) *coconutFooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutFooCall) WaitUntil(w <-chan time.Time) *coconutFooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutFooCall) After(d time.Duration) *coconutFooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutFooCall) Run(fn func(args mock.Arguments)) *coconutFooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutFooCall) Maybe() *coconutFooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutFooCall) TypedReturns(a string) *coconutFooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutFooCall) ReturnsFn(fn func(Strawberry) string) *coconutFooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutFooCall) TypedRun(fn func(Strawberry)) *coconutFooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _st, _ := args.Get(0).(Strawberry) + fn(_st) + }) + return _c +} + +func (_c *coconutFooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutFooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutFooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutFooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutFooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutFooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutFooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutFooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutFooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutFooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutFooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutFooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutFooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutFooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutFooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutFooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutFooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutFooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutFooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutFooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutFooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutFooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutFooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutFooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutFooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutFooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Goo(st string) Strawberry { + _ret := _m.Called(st) + + if _rf, ok := _ret.Get(0).(func(string) Strawberry); ok { + return _rf(st) + } + + _ra0, _ := _ret.Get(0).(Strawberry) + + return _ra0 +} + +func (_m *coconutMock) OnGoo(st string) *coconutGooCall { + return &coconutGooCall{Call: _m.Mock.On("Goo", st), Parent: _m} +} + +func (_m *coconutMock) OnGooRaw(st interface{}) *coconutGooCall { + return &coconutGooCall{Call: _m.Mock.On("Goo", st), Parent: _m} +} + +type coconutGooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutGooCall) Panic(msg string) *coconutGooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutGooCall) Once() *coconutGooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutGooCall) Twice() *coconutGooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutGooCall) Times(i int) *coconutGooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutGooCall) WaitUntil(w <-chan time.Time) *coconutGooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutGooCall) After(d time.Duration) *coconutGooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutGooCall) Run(fn func(args mock.Arguments)) *coconutGooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutGooCall) Maybe() *coconutGooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutGooCall) TypedReturns(a Strawberry) *coconutGooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutGooCall) ReturnsFn(fn func(string) Strawberry) *coconutGooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutGooCall) TypedRun(fn func(string)) *coconutGooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _st := args.String(0) + fn(_st) + }) + return _c +} + +func (_c *coconutGooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutGooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutGooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutGooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutGooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutGooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutGooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutGooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutGooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutGooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutGooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutGooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutGooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutGooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutGooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutGooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutGooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutGooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutGooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutGooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutGooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutGooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutGooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutGooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutGooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutGooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Hoo(aParam string, bParam int, cParam Water) { + _m.Called(aParam, bParam, cParam) +} + +func (_m *coconutMock) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return &coconutHooCall{Call: _m.Mock.On("Hoo", aParam, bParam, cParam), Parent: _m} +} + +func (_m *coconutMock) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return &coconutHooCall{Call: _m.Mock.On("Hoo", aParam, bParam, cParam), Parent: _m} +} + +type coconutHooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutHooCall) Panic(msg string) *coconutHooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutHooCall) Once() *coconutHooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutHooCall) Twice() *coconutHooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutHooCall) Times(i int) *coconutHooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutHooCall) WaitUntil(w <-chan time.Time) *coconutHooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutHooCall) After(d time.Duration) *coconutHooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutHooCall) Run(fn func(args mock.Arguments)) *coconutHooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutHooCall) Maybe() *coconutHooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutHooCall) TypedRun(fn func(string, int, Water)) *coconutHooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _aParam := args.String(0) + _bParam := args.Int(1) + _cParam, _ := args.Get(2).(Water) + fn(_aParam, _bParam, _cParam) + }) + return _c +} + +func (_c *coconutHooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutHooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutHooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutHooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutHooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutHooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutHooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutHooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutHooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutHooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutHooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutHooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutHooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutHooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutHooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutHooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutHooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutHooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutHooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutHooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutHooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutHooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutHooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutHooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutHooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutHooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Joo(aParam string, bParam int, cParam Water) (string, int) { + _ret := _m.Called(aParam, bParam, cParam) + + if _rf, ok := _ret.Get(0).(func(string, int, Water) (string, int)); ok { + return _rf(aParam, bParam, cParam) + } + + _ra0 := _ret.String(0) + _rb1 := _ret.Int(1) + + return _ra0, _rb1 +} + +func (_m *coconutMock) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return &coconutJooCall{Call: _m.Mock.On("Joo", aParam, bParam, cParam), Parent: _m} +} + +func (_m *coconutMock) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return &coconutJooCall{Call: _m.Mock.On("Joo", aParam, bParam, cParam), Parent: _m} +} + +type coconutJooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutJooCall) Panic(msg string) *coconutJooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutJooCall) Once() *coconutJooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutJooCall) Twice() *coconutJooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutJooCall) Times(i int) *coconutJooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutJooCall) WaitUntil(w <-chan time.Time) *coconutJooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutJooCall) After(d time.Duration) *coconutJooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutJooCall) Run(fn func(args mock.Arguments)) *coconutJooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutJooCall) Maybe() *coconutJooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutJooCall) TypedReturns(a string, b int) *coconutJooCall { + _c.Call = _c.Return(a, b) + return _c +} + +func (_c *coconutJooCall) ReturnsFn(fn func(string, int, Water) (string, int)) *coconutJooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutJooCall) TypedRun(fn func(string, int, Water)) *coconutJooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _aParam := args.String(0) + _bParam := args.Int(1) + _cParam, _ := args.Get(2).(Water) + fn(_aParam, _bParam, _cParam) + }) + return _c +} + +func (_c *coconutJooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutJooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutJooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutJooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutJooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutJooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutJooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutJooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutJooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutJooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutJooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutJooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutJooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutJooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutJooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutJooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutJooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutJooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutJooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutJooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutJooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutJooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutJooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutJooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutJooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutJooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Koo(src string) string { + _ret := _m.Called(src) + + if _rf, ok := _ret.Get(0).(func(string) string); ok { + return _rf(src) + } + + dst := _ret.String(0) + + return dst +} + +func (_m *coconutMock) OnKoo(src string) *coconutKooCall { + return &coconutKooCall{Call: _m.Mock.On("Koo", src), Parent: _m} +} + +func (_m *coconutMock) OnKooRaw(src interface{}) *coconutKooCall { + return &coconutKooCall{Call: _m.Mock.On("Koo", src), Parent: _m} +} + +type coconutKooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutKooCall) Panic(msg string) *coconutKooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutKooCall) Once() *coconutKooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutKooCall) Twice() *coconutKooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutKooCall) Times(i int) *coconutKooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutKooCall) WaitUntil(w <-chan time.Time) *coconutKooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutKooCall) After(d time.Duration) *coconutKooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutKooCall) Run(fn func(args mock.Arguments)) *coconutKooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutKooCall) Maybe() *coconutKooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutKooCall) TypedReturns(a string) *coconutKooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutKooCall) ReturnsFn(fn func(string) string) *coconutKooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutKooCall) TypedRun(fn func(string)) *coconutKooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _src := args.String(0) + fn(_src) + }) + return _c +} + +func (_c *coconutKooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutKooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutKooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutKooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutKooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutKooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutKooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutKooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutKooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutKooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutKooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutKooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutKooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutKooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutKooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutKooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutKooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutKooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutKooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutKooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutKooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutKooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutKooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutKooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutKooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutKooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Loo(st string, values ...int) string { + _ret := _m.Called(st, values) + + if _rf, ok := _ret.Get(0).(func(string, ...int) string); ok { + return _rf(st, values...) + } + + _ra0 := _ret.String(0) + + return _ra0 +} + +func (_m *coconutMock) OnLoo(st string, values ...int) *coconutLooCall { + return &coconutLooCall{Call: _m.Mock.On("Loo", st, values), Parent: _m} +} + +func (_m *coconutMock) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return &coconutLooCall{Call: _m.Mock.On("Loo", st, values), Parent: _m} +} + +type coconutLooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutLooCall) Panic(msg string) *coconutLooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutLooCall) Once() *coconutLooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutLooCall) Twice() *coconutLooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutLooCall) Times(i int) *coconutLooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutLooCall) WaitUntil(w <-chan time.Time) *coconutLooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutLooCall) After(d time.Duration) *coconutLooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutLooCall) Run(fn func(args mock.Arguments)) *coconutLooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutLooCall) Maybe() *coconutLooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutLooCall) TypedReturns(a string) *coconutLooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutLooCall) ReturnsFn(fn func(string, ...int) string) *coconutLooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutLooCall) TypedRun(fn func(string, ...int)) *coconutLooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _st := args.String(0) + _values, _ := args.Get(1).([]int) + fn(_st, _values...) + }) + return _c +} + +func (_c *coconutLooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutLooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutLooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutLooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutLooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutLooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutLooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutLooCall) OnLoo(st string, values ...int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutLooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutLooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutLooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutLooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutLooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutLooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutLooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutLooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutLooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutLooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutLooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutLooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutLooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutLooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutLooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutLooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutLooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutLooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Moo(fn func(Strawberry, Strawberry) Pineapple) string { + _ret := _m.Called(fn) + + if _rf, ok := _ret.Get(0).(func(func(Strawberry, Strawberry) Pineapple) string); ok { + return _rf(fn) + } + + _ra0 := _ret.String(0) + + return _ra0 +} + +func (_m *coconutMock) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return &coconutMooCall{Call: _m.Mock.On("Moo", mock.Anything), Parent: _m} +} + +func (_m *coconutMock) OnMooRaw(fn interface{}) *coconutMooCall { + return &coconutMooCall{Call: _m.Mock.On("Moo", mock.Anything), Parent: _m} +} + +type coconutMooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutMooCall) Panic(msg string) *coconutMooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutMooCall) Once() *coconutMooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutMooCall) Twice() *coconutMooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutMooCall) Times(i int) *coconutMooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutMooCall) WaitUntil(w <-chan time.Time) *coconutMooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutMooCall) After(d time.Duration) *coconutMooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutMooCall) Run(fn func(args mock.Arguments)) *coconutMooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutMooCall) Maybe() *coconutMooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutMooCall) TypedReturns(a string) *coconutMooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutMooCall) ReturnsFn(fn func(func(Strawberry, Strawberry) Pineapple) string) *coconutMooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutMooCall) TypedRun(fn func(func(Strawberry, Strawberry) Pineapple)) *coconutMooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _fn, _ := args.Get(0).(func(Strawberry, Strawberry) Pineapple) + fn(_fn) + }) + return _c +} + +func (_c *coconutMooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutMooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutMooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutMooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutMooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutMooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutMooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutMooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutMooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutMooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutMooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutMooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutMooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutMooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutMooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutMooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutMooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutMooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutMooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutMooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutMooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutMooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutMooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutMooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutMooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutMooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Too(src string) time.Duration { + _ret := _m.Called(src) + + if _rf, ok := _ret.Get(0).(func(string) time.Duration); ok { + return _rf(src) + } + + _ra0, _ := _ret.Get(0).(time.Duration) + + return _ra0 +} + +func (_m *coconutMock) OnToo(src string) *coconutTooCall { + return &coconutTooCall{Call: _m.Mock.On("Too", src), Parent: _m} +} + +func (_m *coconutMock) OnTooRaw(src interface{}) *coconutTooCall { + return &coconutTooCall{Call: _m.Mock.On("Too", src), Parent: _m} +} + +type coconutTooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutTooCall) Panic(msg string) *coconutTooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutTooCall) Once() *coconutTooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutTooCall) Twice() *coconutTooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutTooCall) Times(i int) *coconutTooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutTooCall) WaitUntil(w <-chan time.Time) *coconutTooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutTooCall) After(d time.Duration) *coconutTooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutTooCall) Run(fn func(args mock.Arguments)) *coconutTooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutTooCall) Maybe() *coconutTooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutTooCall) TypedReturns(a time.Duration) *coconutTooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutTooCall) ReturnsFn(fn func(string) time.Duration) *coconutTooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutTooCall) TypedRun(fn func(string)) *coconutTooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _src := args.String(0) + fn(_src) + }) + return _c +} + +func (_c *coconutTooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutTooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutTooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutTooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutTooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutTooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutTooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutTooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutTooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutTooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutTooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutTooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutTooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutTooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutTooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutTooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutTooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutTooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutTooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutTooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutTooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutTooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutTooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutTooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutTooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutTooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Voo(src *module.Version) time.Duration { + _ret := _m.Called(src) + + if _rf, ok := _ret.Get(0).(func(*module.Version) time.Duration); ok { + return _rf(src) + } + + _ra0, _ := _ret.Get(0).(time.Duration) + + return _ra0 +} + +func (_m *coconutMock) OnVoo(src *module.Version) *coconutVooCall { + return &coconutVooCall{Call: _m.Mock.On("Voo", src), Parent: _m} +} + +func (_m *coconutMock) OnVooRaw(src interface{}) *coconutVooCall { + return &coconutVooCall{Call: _m.Mock.On("Voo", src), Parent: _m} +} + +type coconutVooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutVooCall) Panic(msg string) *coconutVooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutVooCall) Once() *coconutVooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutVooCall) Twice() *coconutVooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutVooCall) Times(i int) *coconutVooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutVooCall) WaitUntil(w <-chan time.Time) *coconutVooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutVooCall) After(d time.Duration) *coconutVooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutVooCall) Run(fn func(args mock.Arguments)) *coconutVooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutVooCall) Maybe() *coconutVooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutVooCall) TypedReturns(a time.Duration) *coconutVooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutVooCall) ReturnsFn(fn func(*module.Version) time.Duration) *coconutVooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutVooCall) TypedRun(fn func(*module.Version)) *coconutVooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _src, _ := args.Get(0).(*module.Version) + fn(_src) + }) + return _c +} + +func (_c *coconutVooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutVooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutVooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutVooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutVooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutVooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutVooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutVooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutVooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutVooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutVooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutVooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutVooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutVooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutVooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutVooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutVooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutVooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutVooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutVooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutVooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutVooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutVooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutVooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutVooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutVooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Yoo(st string) interface{} { + _ret := _m.Called(st) + + if _rf, ok := _ret.Get(0).(func(string) interface{}); ok { + return _rf(st) + } + + _ra0, _ := _ret.Get(0).(interface{}) + + return _ra0 +} + +func (_m *coconutMock) OnYoo(st string) *coconutYooCall { + return &coconutYooCall{Call: _m.Mock.On("Yoo", st), Parent: _m} +} + +func (_m *coconutMock) OnYooRaw(st interface{}) *coconutYooCall { + return &coconutYooCall{Call: _m.Mock.On("Yoo", st), Parent: _m} +} + +type coconutYooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutYooCall) Panic(msg string) *coconutYooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutYooCall) Once() *coconutYooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutYooCall) Twice() *coconutYooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutYooCall) Times(i int) *coconutYooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutYooCall) WaitUntil(w <-chan time.Time) *coconutYooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutYooCall) After(d time.Duration) *coconutYooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutYooCall) Run(fn func(args mock.Arguments)) *coconutYooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutYooCall) Maybe() *coconutYooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutYooCall) TypedReturns(a interface{}) *coconutYooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutYooCall) ReturnsFn(fn func(string) interface{}) *coconutYooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutYooCall) TypedRun(fn func(string)) *coconutYooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _st := args.String(0) + fn(_st) + }) + return _c +} + +func (_c *coconutYooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutYooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutYooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutYooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutYooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutYooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutYooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutYooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutYooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutYooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutYooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutYooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutYooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutYooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutYooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutYooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutYooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutYooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutYooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutYooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutYooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutYooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutYooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutYooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutYooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutYooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Zoo(st interface{}) string { + _ret := _m.Called(st) + + if _rf, ok := _ret.Get(0).(func(interface{}) string); ok { + return _rf(st) + } + + _ra0 := _ret.String(0) + + return _ra0 +} + +func (_m *coconutMock) OnZoo(st interface{}) *coconutZooCall { + return &coconutZooCall{Call: _m.Mock.On("Zoo", st), Parent: _m} +} + +func (_m *coconutMock) OnZooRaw(st interface{}) *coconutZooCall { + return &coconutZooCall{Call: _m.Mock.On("Zoo", st), Parent: _m} +} + +type coconutZooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutZooCall) Panic(msg string) *coconutZooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutZooCall) Once() *coconutZooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutZooCall) Twice() *coconutZooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutZooCall) Times(i int) *coconutZooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutZooCall) WaitUntil(w <-chan time.Time) *coconutZooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutZooCall) After(d time.Duration) *coconutZooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutZooCall) Run(fn func(args mock.Arguments)) *coconutZooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutZooCall) Maybe() *coconutZooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutZooCall) TypedReturns(a string) *coconutZooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutZooCall) ReturnsFn(fn func(interface{}) string) *coconutZooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutZooCall) TypedRun(fn func(interface{})) *coconutZooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _st, _ := args.Get(0).(interface{}) + fn(_st) + }) + return _c +} + +func (_c *coconutZooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutZooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutZooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutZooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutZooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutZooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutZooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutZooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutZooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutZooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutZooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutZooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutZooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutZooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutZooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutZooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutZooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutZooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutZooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutZooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutZooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutZooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutZooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutZooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutZooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutZooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} diff --git a/testdata/src/b/c/mock_gen_test.go.golden b/testdata/src/b/c/mock_gen_test.go.golden new file mode 100644 index 0000000..f0f0f65 --- /dev/null +++ b/testdata/src/b/c/mock_gen_test.go.golden @@ -0,0 +1,2905 @@ +// Code generated by mocktail; DO NOT EDIT. + +package c + +import ( + "bytes" + "context" + "testing" + "time" + + "github.com/stretchr/testify/mock" + "golang.org/x/mod/module" +) + +// pineappleMock mock of Pineapple. +type pineappleMock struct{ mock.Mock } + +// newPineappleMock creates a new pineappleMock. +func newPineappleMock(tb testing.TB) *pineappleMock { + tb.Helper() + + m := &pineappleMock{} + m.Mock.Test(tb) + + tb.Cleanup(func() { m.AssertExpectations(tb) }) + + return m +} + +func (_m *pineappleMock) Coo(_ context.Context, bParam string, cParam Water) Water { + _ret := _m.Called(bParam, cParam) + + if _rf, ok := _ret.Get(0).(func(string, Water) Water); ok { + return _rf(bParam, cParam) + } + + _ra0, _ := _ret.Get(0).(Water) + + return _ra0 +} + +func (_m *pineappleMock) OnCoo(bParam string, cParam Water) *pineappleCooCall { + return &pineappleCooCall{Call: _m.Mock.On("Coo", bParam, cParam), Parent: _m} +} + +func (_m *pineappleMock) OnCooRaw(bParam interface{}, cParam interface{}) *pineappleCooCall { + return &pineappleCooCall{Call: _m.Mock.On("Coo", bParam, cParam), Parent: _m} +} + +type pineappleCooCall struct { + *mock.Call + Parent *pineappleMock +} + +func (_c *pineappleCooCall) Panic(msg string) *pineappleCooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *pineappleCooCall) Once() *pineappleCooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *pineappleCooCall) Twice() *pineappleCooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *pineappleCooCall) Times(i int) *pineappleCooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *pineappleCooCall) WaitUntil(w <-chan time.Time) *pineappleCooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *pineappleCooCall) After(d time.Duration) *pineappleCooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *pineappleCooCall) Run(fn func(args mock.Arguments)) *pineappleCooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *pineappleCooCall) Maybe() *pineappleCooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *pineappleCooCall) TypedReturns(a Water) *pineappleCooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *pineappleCooCall) ReturnsFn(fn func(string, Water) Water) *pineappleCooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *pineappleCooCall) TypedRun(fn func(string, Water)) *pineappleCooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _bParam := args.String(0) + _cParam, _ := args.Get(1).(Water) + fn(_bParam, _cParam) + }) + return _c +} + +func (_c *pineappleCooCall) OnCoo(bParam string, cParam Water) *pineappleCooCall { + return _c.Parent.OnCoo(bParam, cParam) +} + +func (_c *pineappleCooCall) OnGoo() *pineappleGooCall { + return _c.Parent.OnGoo() +} + +func (_c *pineappleCooCall) OnHello(bar Water) *pineappleHelloCall { + return _c.Parent.OnHello(bar) +} + +func (_c *pineappleCooCall) OnWorld() *pineappleWorldCall { + return _c.Parent.OnWorld() +} + +func (_c *pineappleCooCall) OnCooRaw(bParam interface{}, cParam interface{}) *pineappleCooCall { + return _c.Parent.OnCooRaw(bParam, cParam) +} + +func (_c *pineappleCooCall) OnGooRaw() *pineappleGooCall { + return _c.Parent.OnGooRaw() +} + +func (_c *pineappleCooCall) OnHelloRaw(bar interface{}) *pineappleHelloCall { + return _c.Parent.OnHelloRaw(bar) +} + +func (_c *pineappleCooCall) OnWorldRaw() *pineappleWorldCall { + return _c.Parent.OnWorldRaw() +} + +func (_m *pineappleMock) Goo() (string, int, Water) { + _ret := _m.Called() + + _ra0 := _ret.String(0) + _rb1 := _ret.Int(1) + _rc2, _ := _ret.Get(2).(Water) + + return _ra0, _rb1, _rc2 +} + +func (_m *pineappleMock) OnGoo() *pineappleGooCall { + return &pineappleGooCall{Call: _m.Mock.On("Goo"), Parent: _m} +} + +func (_m *pineappleMock) OnGooRaw() *pineappleGooCall { + return &pineappleGooCall{Call: _m.Mock.On("Goo"), Parent: _m} +} + +type pineappleGooCall struct { + *mock.Call + Parent *pineappleMock +} + +func (_c *pineappleGooCall) Panic(msg string) *pineappleGooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *pineappleGooCall) Once() *pineappleGooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *pineappleGooCall) Twice() *pineappleGooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *pineappleGooCall) Times(i int) *pineappleGooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *pineappleGooCall) WaitUntil(w <-chan time.Time) *pineappleGooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *pineappleGooCall) After(d time.Duration) *pineappleGooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *pineappleGooCall) Run(fn func(args mock.Arguments)) *pineappleGooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *pineappleGooCall) Maybe() *pineappleGooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *pineappleGooCall) TypedReturns(a string, b int, c Water) *pineappleGooCall { + _c.Call = _c.Return(a, b, c) + return _c +} + +func (_c *pineappleGooCall) TypedRun(fn func()) *pineappleGooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + fn() + }) + return _c +} + +func (_c *pineappleGooCall) OnCoo(bParam string, cParam Water) *pineappleCooCall { + return _c.Parent.OnCoo(bParam, cParam) +} + +func (_c *pineappleGooCall) OnGoo() *pineappleGooCall { + return _c.Parent.OnGoo() +} + +func (_c *pineappleGooCall) OnHello(bar Water) *pineappleHelloCall { + return _c.Parent.OnHello(bar) +} + +func (_c *pineappleGooCall) OnWorld() *pineappleWorldCall { + return _c.Parent.OnWorld() +} + +func (_c *pineappleGooCall) OnCooRaw(bParam interface{}, cParam interface{}) *pineappleCooCall { + return _c.Parent.OnCooRaw(bParam, cParam) +} + +func (_c *pineappleGooCall) OnGooRaw() *pineappleGooCall { + return _c.Parent.OnGooRaw() +} + +func (_c *pineappleGooCall) OnHelloRaw(bar interface{}) *pineappleHelloCall { + return _c.Parent.OnHelloRaw(bar) +} + +func (_c *pineappleGooCall) OnWorldRaw() *pineappleWorldCall { + return _c.Parent.OnWorldRaw() +} + +func (_m *pineappleMock) Hello(bar Water) string { + _ret := _m.Called(bar) + + if _rf, ok := _ret.Get(0).(func(Water) string); ok { + return _rf(bar) + } + + _ra0 := _ret.String(0) + + return _ra0 +} + +func (_m *pineappleMock) OnHello(bar Water) *pineappleHelloCall { + return &pineappleHelloCall{Call: _m.Mock.On("Hello", bar), Parent: _m} +} + +func (_m *pineappleMock) OnHelloRaw(bar interface{}) *pineappleHelloCall { + return &pineappleHelloCall{Call: _m.Mock.On("Hello", bar), Parent: _m} +} + +type pineappleHelloCall struct { + *mock.Call + Parent *pineappleMock +} + +func (_c *pineappleHelloCall) Panic(msg string) *pineappleHelloCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *pineappleHelloCall) Once() *pineappleHelloCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *pineappleHelloCall) Twice() *pineappleHelloCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *pineappleHelloCall) Times(i int) *pineappleHelloCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *pineappleHelloCall) WaitUntil(w <-chan time.Time) *pineappleHelloCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *pineappleHelloCall) After(d time.Duration) *pineappleHelloCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *pineappleHelloCall) Run(fn func(args mock.Arguments)) *pineappleHelloCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *pineappleHelloCall) Maybe() *pineappleHelloCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *pineappleHelloCall) TypedReturns(a string) *pineappleHelloCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *pineappleHelloCall) ReturnsFn(fn func(Water) string) *pineappleHelloCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *pineappleHelloCall) TypedRun(fn func(Water)) *pineappleHelloCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _bar, _ := args.Get(0).(Water) + fn(_bar) + }) + return _c +} + +func (_c *pineappleHelloCall) OnCoo(bParam string, cParam Water) *pineappleCooCall { + return _c.Parent.OnCoo(bParam, cParam) +} + +func (_c *pineappleHelloCall) OnGoo() *pineappleGooCall { + return _c.Parent.OnGoo() +} + +func (_c *pineappleHelloCall) OnHello(bar Water) *pineappleHelloCall { + return _c.Parent.OnHello(bar) +} + +func (_c *pineappleHelloCall) OnWorld() *pineappleWorldCall { + return _c.Parent.OnWorld() +} + +func (_c *pineappleHelloCall) OnCooRaw(bParam interface{}, cParam interface{}) *pineappleCooCall { + return _c.Parent.OnCooRaw(bParam, cParam) +} + +func (_c *pineappleHelloCall) OnGooRaw() *pineappleGooCall { + return _c.Parent.OnGooRaw() +} + +func (_c *pineappleHelloCall) OnHelloRaw(bar interface{}) *pineappleHelloCall { + return _c.Parent.OnHelloRaw(bar) +} + +func (_c *pineappleHelloCall) OnWorldRaw() *pineappleWorldCall { + return _c.Parent.OnWorldRaw() +} + +func (_m *pineappleMock) World() string { + _ret := _m.Called() + + _ra0 := _ret.String(0) + + return _ra0 +} + +func (_m *pineappleMock) OnWorld() *pineappleWorldCall { + return &pineappleWorldCall{Call: _m.Mock.On("World"), Parent: _m} +} + +func (_m *pineappleMock) OnWorldRaw() *pineappleWorldCall { + return &pineappleWorldCall{Call: _m.Mock.On("World"), Parent: _m} +} + +type pineappleWorldCall struct { + *mock.Call + Parent *pineappleMock +} + +func (_c *pineappleWorldCall) Panic(msg string) *pineappleWorldCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *pineappleWorldCall) Once() *pineappleWorldCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *pineappleWorldCall) Twice() *pineappleWorldCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *pineappleWorldCall) Times(i int) *pineappleWorldCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *pineappleWorldCall) WaitUntil(w <-chan time.Time) *pineappleWorldCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *pineappleWorldCall) After(d time.Duration) *pineappleWorldCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *pineappleWorldCall) Run(fn func(args mock.Arguments)) *pineappleWorldCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *pineappleWorldCall) Maybe() *pineappleWorldCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *pineappleWorldCall) TypedReturns(a string) *pineappleWorldCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *pineappleWorldCall) TypedRun(fn func()) *pineappleWorldCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + fn() + }) + return _c +} + +func (_c *pineappleWorldCall) OnCoo(bParam string, cParam Water) *pineappleCooCall { + return _c.Parent.OnCoo(bParam, cParam) +} + +func (_c *pineappleWorldCall) OnGoo() *pineappleGooCall { + return _c.Parent.OnGoo() +} + +func (_c *pineappleWorldCall) OnHello(bar Water) *pineappleHelloCall { + return _c.Parent.OnHello(bar) +} + +func (_c *pineappleWorldCall) OnWorld() *pineappleWorldCall { + return _c.Parent.OnWorld() +} + +func (_c *pineappleWorldCall) OnCooRaw(bParam interface{}, cParam interface{}) *pineappleCooCall { + return _c.Parent.OnCooRaw(bParam, cParam) +} + +func (_c *pineappleWorldCall) OnGooRaw() *pineappleGooCall { + return _c.Parent.OnGooRaw() +} + +func (_c *pineappleWorldCall) OnHelloRaw(bar interface{}) *pineappleHelloCall { + return _c.Parent.OnHelloRaw(bar) +} + +func (_c *pineappleWorldCall) OnWorldRaw() *pineappleWorldCall { + return _c.Parent.OnWorldRaw() +} + +// coconutMock mock of Coconut. +type coconutMock struct{ mock.Mock } + +// newCoconutMock creates a new coconutMock. +func newCoconutMock(tb testing.TB) *coconutMock { + tb.Helper() + + m := &coconutMock{} + m.Mock.Test(tb) + + tb.Cleanup(func() { m.AssertExpectations(tb) }) + + return m +} + +func (_m *coconutMock) Boo(src *bytes.Buffer) time.Duration { + _ret := _m.Called(src) + + if _rf, ok := _ret.Get(0).(func(*bytes.Buffer) time.Duration); ok { + return _rf(src) + } + + _ra0, _ := _ret.Get(0).(time.Duration) + + return _ra0 +} + +func (_m *coconutMock) OnBoo(src *bytes.Buffer) *coconutBooCall { + return &coconutBooCall{Call: _m.Mock.On("Boo", src), Parent: _m} +} + +func (_m *coconutMock) OnBooRaw(src interface{}) *coconutBooCall { + return &coconutBooCall{Call: _m.Mock.On("Boo", src), Parent: _m} +} + +type coconutBooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutBooCall) Panic(msg string) *coconutBooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutBooCall) Once() *coconutBooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutBooCall) Twice() *coconutBooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutBooCall) Times(i int) *coconutBooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutBooCall) WaitUntil(w <-chan time.Time) *coconutBooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutBooCall) After(d time.Duration) *coconutBooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutBooCall) Run(fn func(args mock.Arguments)) *coconutBooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutBooCall) Maybe() *coconutBooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutBooCall) TypedReturns(a time.Duration) *coconutBooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutBooCall) ReturnsFn(fn func(*bytes.Buffer) time.Duration) *coconutBooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutBooCall) TypedRun(fn func(*bytes.Buffer)) *coconutBooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _src, _ := args.Get(0).(*bytes.Buffer) + fn(_src) + }) + return _c +} + +func (_c *coconutBooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutBooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutBooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutBooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutBooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutBooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutBooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutBooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutBooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutBooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutBooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutBooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutBooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutBooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutBooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutBooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutBooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutBooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutBooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutBooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutBooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutBooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutBooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutBooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutBooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutBooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Doo(src time.Duration) time.Duration { + _ret := _m.Called(src) + + if _rf, ok := _ret.Get(0).(func(time.Duration) time.Duration); ok { + return _rf(src) + } + + _ra0, _ := _ret.Get(0).(time.Duration) + + return _ra0 +} + +func (_m *coconutMock) OnDoo(src time.Duration) *coconutDooCall { + return &coconutDooCall{Call: _m.Mock.On("Doo", src), Parent: _m} +} + +func (_m *coconutMock) OnDooRaw(src interface{}) *coconutDooCall { + return &coconutDooCall{Call: _m.Mock.On("Doo", src), Parent: _m} +} + +type coconutDooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutDooCall) Panic(msg string) *coconutDooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutDooCall) Once() *coconutDooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutDooCall) Twice() *coconutDooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutDooCall) Times(i int) *coconutDooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutDooCall) WaitUntil(w <-chan time.Time) *coconutDooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutDooCall) After(d time.Duration) *coconutDooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutDooCall) Run(fn func(args mock.Arguments)) *coconutDooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutDooCall) Maybe() *coconutDooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutDooCall) TypedReturns(a time.Duration) *coconutDooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutDooCall) ReturnsFn(fn func(time.Duration) time.Duration) *coconutDooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutDooCall) TypedRun(fn func(time.Duration)) *coconutDooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _src, _ := args.Get(0).(time.Duration) + fn(_src) + }) + return _c +} + +func (_c *coconutDooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutDooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutDooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutDooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutDooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutDooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutDooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutDooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutDooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutDooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutDooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutDooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutDooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutDooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutDooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutDooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutDooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutDooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutDooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutDooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutDooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutDooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutDooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutDooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutDooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutDooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Foo(st Strawberry) string { + _ret := _m.Called(st) + + if _rf, ok := _ret.Get(0).(func(Strawberry) string); ok { + return _rf(st) + } + + _ra0 := _ret.String(0) + + return _ra0 +} + +func (_m *coconutMock) OnFoo(st Strawberry) *coconutFooCall { + return &coconutFooCall{Call: _m.Mock.On("Foo", st), Parent: _m} +} + +func (_m *coconutMock) OnFooRaw(st interface{}) *coconutFooCall { + return &coconutFooCall{Call: _m.Mock.On("Foo", st), Parent: _m} +} + +type coconutFooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutFooCall) Panic(msg string) *coconutFooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutFooCall) Once() *coconutFooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutFooCall) Twice() *coconutFooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutFooCall) Times(i int) *coconutFooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutFooCall) WaitUntil(w <-chan time.Time) *coconutFooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutFooCall) After(d time.Duration) *coconutFooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutFooCall) Run(fn func(args mock.Arguments)) *coconutFooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutFooCall) Maybe() *coconutFooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutFooCall) TypedReturns(a string) *coconutFooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutFooCall) ReturnsFn(fn func(Strawberry) string) *coconutFooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutFooCall) TypedRun(fn func(Strawberry)) *coconutFooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _st, _ := args.Get(0).(Strawberry) + fn(_st) + }) + return _c +} + +func (_c *coconutFooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutFooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutFooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutFooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutFooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutFooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutFooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutFooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutFooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutFooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutFooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutFooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutFooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutFooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutFooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutFooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutFooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutFooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutFooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutFooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutFooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutFooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutFooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutFooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutFooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutFooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Goo(st string) Strawberry { + _ret := _m.Called(st) + + if _rf, ok := _ret.Get(0).(func(string) Strawberry); ok { + return _rf(st) + } + + _ra0, _ := _ret.Get(0).(Strawberry) + + return _ra0 +} + +func (_m *coconutMock) OnGoo(st string) *coconutGooCall { + return &coconutGooCall{Call: _m.Mock.On("Goo", st), Parent: _m} +} + +func (_m *coconutMock) OnGooRaw(st interface{}) *coconutGooCall { + return &coconutGooCall{Call: _m.Mock.On("Goo", st), Parent: _m} +} + +type coconutGooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutGooCall) Panic(msg string) *coconutGooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutGooCall) Once() *coconutGooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutGooCall) Twice() *coconutGooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutGooCall) Times(i int) *coconutGooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutGooCall) WaitUntil(w <-chan time.Time) *coconutGooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutGooCall) After(d time.Duration) *coconutGooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutGooCall) Run(fn func(args mock.Arguments)) *coconutGooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutGooCall) Maybe() *coconutGooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutGooCall) TypedReturns(a Strawberry) *coconutGooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutGooCall) ReturnsFn(fn func(string) Strawberry) *coconutGooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutGooCall) TypedRun(fn func(string)) *coconutGooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _st := args.String(0) + fn(_st) + }) + return _c +} + +func (_c *coconutGooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutGooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutGooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutGooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutGooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutGooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutGooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutGooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutGooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutGooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutGooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutGooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutGooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutGooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutGooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutGooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutGooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutGooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutGooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutGooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutGooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutGooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutGooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutGooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutGooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutGooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Hoo(aParam string, bParam int, cParam Water) { + _m.Called(aParam, bParam, cParam) +} + +func (_m *coconutMock) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return &coconutHooCall{Call: _m.Mock.On("Hoo", aParam, bParam, cParam), Parent: _m} +} + +func (_m *coconutMock) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return &coconutHooCall{Call: _m.Mock.On("Hoo", aParam, bParam, cParam), Parent: _m} +} + +type coconutHooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutHooCall) Panic(msg string) *coconutHooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutHooCall) Once() *coconutHooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutHooCall) Twice() *coconutHooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutHooCall) Times(i int) *coconutHooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutHooCall) WaitUntil(w <-chan time.Time) *coconutHooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutHooCall) After(d time.Duration) *coconutHooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutHooCall) Run(fn func(args mock.Arguments)) *coconutHooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutHooCall) Maybe() *coconutHooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutHooCall) TypedRun(fn func(string, int, Water)) *coconutHooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _aParam := args.String(0) + _bParam := args.Int(1) + _cParam, _ := args.Get(2).(Water) + fn(_aParam, _bParam, _cParam) + }) + return _c +} + +func (_c *coconutHooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutHooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutHooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutHooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutHooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutHooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutHooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutHooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutHooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutHooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutHooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutHooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutHooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutHooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutHooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutHooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutHooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutHooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutHooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutHooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutHooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutHooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutHooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutHooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutHooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutHooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Joo(aParam string, bParam int, cParam Water) (string, int) { + _ret := _m.Called(aParam, bParam, cParam) + + if _rf, ok := _ret.Get(0).(func(string, int, Water) (string, int)); ok { + return _rf(aParam, bParam, cParam) + } + + _ra0 := _ret.String(0) + _rb1 := _ret.Int(1) + + return _ra0, _rb1 +} + +func (_m *coconutMock) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return &coconutJooCall{Call: _m.Mock.On("Joo", aParam, bParam, cParam), Parent: _m} +} + +func (_m *coconutMock) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return &coconutJooCall{Call: _m.Mock.On("Joo", aParam, bParam, cParam), Parent: _m} +} + +type coconutJooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutJooCall) Panic(msg string) *coconutJooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutJooCall) Once() *coconutJooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutJooCall) Twice() *coconutJooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutJooCall) Times(i int) *coconutJooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutJooCall) WaitUntil(w <-chan time.Time) *coconutJooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutJooCall) After(d time.Duration) *coconutJooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutJooCall) Run(fn func(args mock.Arguments)) *coconutJooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutJooCall) Maybe() *coconutJooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutJooCall) TypedReturns(a string, b int) *coconutJooCall { + _c.Call = _c.Return(a, b) + return _c +} + +func (_c *coconutJooCall) ReturnsFn(fn func(string, int, Water) (string, int)) *coconutJooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutJooCall) TypedRun(fn func(string, int, Water)) *coconutJooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _aParam := args.String(0) + _bParam := args.Int(1) + _cParam, _ := args.Get(2).(Water) + fn(_aParam, _bParam, _cParam) + }) + return _c +} + +func (_c *coconutJooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutJooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutJooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutJooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutJooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutJooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutJooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutJooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutJooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutJooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutJooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutJooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutJooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutJooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutJooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutJooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutJooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutJooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutJooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutJooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutJooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutJooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutJooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutJooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutJooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutJooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Koo(src string) string { + _ret := _m.Called(src) + + if _rf, ok := _ret.Get(0).(func(string) string); ok { + return _rf(src) + } + + dst := _ret.String(0) + + return dst +} + +func (_m *coconutMock) OnKoo(src string) *coconutKooCall { + return &coconutKooCall{Call: _m.Mock.On("Koo", src), Parent: _m} +} + +func (_m *coconutMock) OnKooRaw(src interface{}) *coconutKooCall { + return &coconutKooCall{Call: _m.Mock.On("Koo", src), Parent: _m} +} + +type coconutKooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutKooCall) Panic(msg string) *coconutKooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutKooCall) Once() *coconutKooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutKooCall) Twice() *coconutKooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutKooCall) Times(i int) *coconutKooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutKooCall) WaitUntil(w <-chan time.Time) *coconutKooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutKooCall) After(d time.Duration) *coconutKooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutKooCall) Run(fn func(args mock.Arguments)) *coconutKooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutKooCall) Maybe() *coconutKooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutKooCall) TypedReturns(a string) *coconutKooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutKooCall) ReturnsFn(fn func(string) string) *coconutKooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutKooCall) TypedRun(fn func(string)) *coconutKooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _src := args.String(0) + fn(_src) + }) + return _c +} + +func (_c *coconutKooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutKooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutKooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutKooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutKooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutKooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutKooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutKooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutKooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutKooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutKooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutKooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutKooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutKooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutKooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutKooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutKooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutKooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutKooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutKooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutKooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutKooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutKooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutKooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutKooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutKooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Loo(st string, values ...int) string { + _ret := _m.Called(st, values) + + if _rf, ok := _ret.Get(0).(func(string, ...int) string); ok { + return _rf(st, values...) + } + + _ra0 := _ret.String(0) + + return _ra0 +} + +func (_m *coconutMock) OnLoo(st string, values ...int) *coconutLooCall { + return &coconutLooCall{Call: _m.Mock.On("Loo", st, values), Parent: _m} +} + +func (_m *coconutMock) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return &coconutLooCall{Call: _m.Mock.On("Loo", st, values), Parent: _m} +} + +type coconutLooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutLooCall) Panic(msg string) *coconutLooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutLooCall) Once() *coconutLooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutLooCall) Twice() *coconutLooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutLooCall) Times(i int) *coconutLooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutLooCall) WaitUntil(w <-chan time.Time) *coconutLooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutLooCall) After(d time.Duration) *coconutLooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutLooCall) Run(fn func(args mock.Arguments)) *coconutLooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutLooCall) Maybe() *coconutLooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutLooCall) TypedReturns(a string) *coconutLooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutLooCall) ReturnsFn(fn func(string, ...int) string) *coconutLooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutLooCall) TypedRun(fn func(string, ...int)) *coconutLooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _st := args.String(0) + _values, _ := args.Get(1).([]int) + fn(_st, _values...) + }) + return _c +} + +func (_c *coconutLooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutLooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutLooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutLooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutLooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutLooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutLooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutLooCall) OnLoo(st string, values ...int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutLooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutLooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutLooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutLooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutLooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutLooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutLooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutLooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutLooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutLooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutLooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutLooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutLooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutLooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutLooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutLooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutLooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutLooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Moo(fn func(Strawberry, Strawberry) Pineapple) string { + _ret := _m.Called(fn) + + if _rf, ok := _ret.Get(0).(func(func(Strawberry, Strawberry) Pineapple) string); ok { + return _rf(fn) + } + + _ra0 := _ret.String(0) + + return _ra0 +} + +func (_m *coconutMock) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return &coconutMooCall{Call: _m.Mock.On("Moo", mock.Anything), Parent: _m} +} + +func (_m *coconutMock) OnMooRaw(fn interface{}) *coconutMooCall { + return &coconutMooCall{Call: _m.Mock.On("Moo", mock.Anything), Parent: _m} +} + +type coconutMooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutMooCall) Panic(msg string) *coconutMooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutMooCall) Once() *coconutMooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutMooCall) Twice() *coconutMooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutMooCall) Times(i int) *coconutMooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutMooCall) WaitUntil(w <-chan time.Time) *coconutMooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutMooCall) After(d time.Duration) *coconutMooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutMooCall) Run(fn func(args mock.Arguments)) *coconutMooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutMooCall) Maybe() *coconutMooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutMooCall) TypedReturns(a string) *coconutMooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutMooCall) ReturnsFn(fn func(func(Strawberry, Strawberry) Pineapple) string) *coconutMooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutMooCall) TypedRun(fn func(func(Strawberry, Strawberry) Pineapple)) *coconutMooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _fn, _ := args.Get(0).(func(Strawberry, Strawberry) Pineapple) + fn(_fn) + }) + return _c +} + +func (_c *coconutMooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutMooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutMooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutMooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutMooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutMooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutMooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutMooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutMooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutMooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutMooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutMooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutMooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutMooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutMooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutMooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutMooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutMooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutMooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutMooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutMooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutMooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutMooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutMooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutMooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutMooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Too(src string) time.Duration { + _ret := _m.Called(src) + + if _rf, ok := _ret.Get(0).(func(string) time.Duration); ok { + return _rf(src) + } + + _ra0, _ := _ret.Get(0).(time.Duration) + + return _ra0 +} + +func (_m *coconutMock) OnToo(src string) *coconutTooCall { + return &coconutTooCall{Call: _m.Mock.On("Too", src), Parent: _m} +} + +func (_m *coconutMock) OnTooRaw(src interface{}) *coconutTooCall { + return &coconutTooCall{Call: _m.Mock.On("Too", src), Parent: _m} +} + +type coconutTooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutTooCall) Panic(msg string) *coconutTooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutTooCall) Once() *coconutTooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutTooCall) Twice() *coconutTooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutTooCall) Times(i int) *coconutTooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutTooCall) WaitUntil(w <-chan time.Time) *coconutTooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutTooCall) After(d time.Duration) *coconutTooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutTooCall) Run(fn func(args mock.Arguments)) *coconutTooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutTooCall) Maybe() *coconutTooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutTooCall) TypedReturns(a time.Duration) *coconutTooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutTooCall) ReturnsFn(fn func(string) time.Duration) *coconutTooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutTooCall) TypedRun(fn func(string)) *coconutTooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _src := args.String(0) + fn(_src) + }) + return _c +} + +func (_c *coconutTooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutTooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutTooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutTooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutTooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutTooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutTooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutTooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutTooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutTooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutTooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutTooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutTooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutTooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutTooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutTooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutTooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutTooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutTooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutTooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutTooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutTooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutTooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutTooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutTooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutTooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Voo(src *module.Version) time.Duration { + _ret := _m.Called(src) + + if _rf, ok := _ret.Get(0).(func(*module.Version) time.Duration); ok { + return _rf(src) + } + + _ra0, _ := _ret.Get(0).(time.Duration) + + return _ra0 +} + +func (_m *coconutMock) OnVoo(src *module.Version) *coconutVooCall { + return &coconutVooCall{Call: _m.Mock.On("Voo", src), Parent: _m} +} + +func (_m *coconutMock) OnVooRaw(src interface{}) *coconutVooCall { + return &coconutVooCall{Call: _m.Mock.On("Voo", src), Parent: _m} +} + +type coconutVooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutVooCall) Panic(msg string) *coconutVooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutVooCall) Once() *coconutVooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutVooCall) Twice() *coconutVooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutVooCall) Times(i int) *coconutVooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutVooCall) WaitUntil(w <-chan time.Time) *coconutVooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutVooCall) After(d time.Duration) *coconutVooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutVooCall) Run(fn func(args mock.Arguments)) *coconutVooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutVooCall) Maybe() *coconutVooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutVooCall) TypedReturns(a time.Duration) *coconutVooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutVooCall) ReturnsFn(fn func(*module.Version) time.Duration) *coconutVooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutVooCall) TypedRun(fn func(*module.Version)) *coconutVooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _src, _ := args.Get(0).(*module.Version) + fn(_src) + }) + return _c +} + +func (_c *coconutVooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutVooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutVooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutVooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutVooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutVooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutVooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutVooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutVooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutVooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutVooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutVooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutVooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutVooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutVooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutVooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutVooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutVooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutVooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutVooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutVooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutVooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutVooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutVooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutVooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutVooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Yoo(st string) interface{} { + _ret := _m.Called(st) + + if _rf, ok := _ret.Get(0).(func(string) interface{}); ok { + return _rf(st) + } + + _ra0, _ := _ret.Get(0).(interface{}) + + return _ra0 +} + +func (_m *coconutMock) OnYoo(st string) *coconutYooCall { + return &coconutYooCall{Call: _m.Mock.On("Yoo", st), Parent: _m} +} + +func (_m *coconutMock) OnYooRaw(st interface{}) *coconutYooCall { + return &coconutYooCall{Call: _m.Mock.On("Yoo", st), Parent: _m} +} + +type coconutYooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutYooCall) Panic(msg string) *coconutYooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutYooCall) Once() *coconutYooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutYooCall) Twice() *coconutYooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutYooCall) Times(i int) *coconutYooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutYooCall) WaitUntil(w <-chan time.Time) *coconutYooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutYooCall) After(d time.Duration) *coconutYooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutYooCall) Run(fn func(args mock.Arguments)) *coconutYooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutYooCall) Maybe() *coconutYooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutYooCall) TypedReturns(a interface{}) *coconutYooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutYooCall) ReturnsFn(fn func(string) interface{}) *coconutYooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutYooCall) TypedRun(fn func(string)) *coconutYooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _st := args.String(0) + fn(_st) + }) + return _c +} + +func (_c *coconutYooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutYooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutYooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutYooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutYooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutYooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutYooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutYooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutYooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutYooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutYooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutYooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutYooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutYooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutYooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutYooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutYooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutYooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutYooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutYooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutYooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutYooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutYooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutYooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutYooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutYooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} + +func (_m *coconutMock) Zoo(st interface{}) string { + _ret := _m.Called(st) + + if _rf, ok := _ret.Get(0).(func(interface{}) string); ok { + return _rf(st) + } + + _ra0 := _ret.String(0) + + return _ra0 +} + +func (_m *coconutMock) OnZoo(st interface{}) *coconutZooCall { + return &coconutZooCall{Call: _m.Mock.On("Zoo", st), Parent: _m} +} + +func (_m *coconutMock) OnZooRaw(st interface{}) *coconutZooCall { + return &coconutZooCall{Call: _m.Mock.On("Zoo", st), Parent: _m} +} + +type coconutZooCall struct { + *mock.Call + Parent *coconutMock +} + +func (_c *coconutZooCall) Panic(msg string) *coconutZooCall { + _c.Call = _c.Call.Panic(msg) + return _c +} + +func (_c *coconutZooCall) Once() *coconutZooCall { + _c.Call = _c.Call.Once() + return _c +} + +func (_c *coconutZooCall) Twice() *coconutZooCall { + _c.Call = _c.Call.Twice() + return _c +} + +func (_c *coconutZooCall) Times(i int) *coconutZooCall { + _c.Call = _c.Call.Times(i) + return _c +} + +func (_c *coconutZooCall) WaitUntil(w <-chan time.Time) *coconutZooCall { + _c.Call = _c.Call.WaitUntil(w) + return _c +} + +func (_c *coconutZooCall) After(d time.Duration) *coconutZooCall { + _c.Call = _c.Call.After(d) + return _c +} + +func (_c *coconutZooCall) Run(fn func(args mock.Arguments)) *coconutZooCall { + _c.Call = _c.Call.Run(fn) + return _c +} + +func (_c *coconutZooCall) Maybe() *coconutZooCall { + _c.Call = _c.Call.Maybe() + return _c +} + +func (_c *coconutZooCall) TypedReturns(a string) *coconutZooCall { + _c.Call = _c.Return(a) + return _c +} + +func (_c *coconutZooCall) ReturnsFn(fn func(interface{}) string) *coconutZooCall { + _c.Call = _c.Return(fn) + return _c +} + +func (_c *coconutZooCall) TypedRun(fn func(interface{})) *coconutZooCall { + _c.Call = _c.Call.Run(func(args mock.Arguments) { + _st, _ := args.Get(0).(interface{}) + fn(_st) + }) + return _c +} + +func (_c *coconutZooCall) OnBoo(src *bytes.Buffer) *coconutBooCall { + return _c.Parent.OnBoo(src) +} + +func (_c *coconutZooCall) OnDoo(src time.Duration) *coconutDooCall { + return _c.Parent.OnDoo(src) +} + +func (_c *coconutZooCall) OnFoo(st Strawberry) *coconutFooCall { + return _c.Parent.OnFoo(st) +} + +func (_c *coconutZooCall) OnGoo(st string) *coconutGooCall { + return _c.Parent.OnGoo(st) +} + +func (_c *coconutZooCall) OnHoo(aParam string, bParam int, cParam Water) *coconutHooCall { + return _c.Parent.OnHoo(aParam, bParam, cParam) +} + +func (_c *coconutZooCall) OnJoo(aParam string, bParam int, cParam Water) *coconutJooCall { + return _c.Parent.OnJoo(aParam, bParam, cParam) +} + +func (_c *coconutZooCall) OnKoo(src string) *coconutKooCall { + return _c.Parent.OnKoo(src) +} + +func (_c *coconutZooCall) OnLoo(st string, values []int) *coconutLooCall { + return _c.Parent.OnLoo(st, values...) +} + +func (_c *coconutZooCall) OnMoo(fn func(Strawberry, Strawberry) Pineapple) *coconutMooCall { + return _c.Parent.OnMoo(fn) +} + +func (_c *coconutZooCall) OnToo(src string) *coconutTooCall { + return _c.Parent.OnToo(src) +} + +func (_c *coconutZooCall) OnVoo(src *module.Version) *coconutVooCall { + return _c.Parent.OnVoo(src) +} + +func (_c *coconutZooCall) OnYoo(st string) *coconutYooCall { + return _c.Parent.OnYoo(st) +} + +func (_c *coconutZooCall) OnZoo(st interface{}) *coconutZooCall { + return _c.Parent.OnZoo(st) +} + +func (_c *coconutZooCall) OnBooRaw(src interface{}) *coconutBooCall { + return _c.Parent.OnBooRaw(src) +} + +func (_c *coconutZooCall) OnDooRaw(src interface{}) *coconutDooCall { + return _c.Parent.OnDooRaw(src) +} + +func (_c *coconutZooCall) OnFooRaw(st interface{}) *coconutFooCall { + return _c.Parent.OnFooRaw(st) +} + +func (_c *coconutZooCall) OnGooRaw(st interface{}) *coconutGooCall { + return _c.Parent.OnGooRaw(st) +} + +func (_c *coconutZooCall) OnHooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutHooCall { + return _c.Parent.OnHooRaw(aParam, bParam, cParam) +} + +func (_c *coconutZooCall) OnJooRaw(aParam interface{}, bParam interface{}, cParam interface{}) *coconutJooCall { + return _c.Parent.OnJooRaw(aParam, bParam, cParam) +} + +func (_c *coconutZooCall) OnKooRaw(src interface{}) *coconutKooCall { + return _c.Parent.OnKooRaw(src) +} + +func (_c *coconutZooCall) OnLooRaw(st interface{}, values interface{}) *coconutLooCall { + return _c.Parent.OnLooRaw(st, values) +} + +func (_c *coconutZooCall) OnMooRaw(fn interface{}) *coconutMooCall { + return _c.Parent.OnMooRaw(fn) +} + +func (_c *coconutZooCall) OnTooRaw(src interface{}) *coconutTooCall { + return _c.Parent.OnTooRaw(src) +} + +func (_c *coconutZooCall) OnVooRaw(src interface{}) *coconutVooCall { + return _c.Parent.OnVooRaw(src) +} + +func (_c *coconutZooCall) OnYooRaw(st interface{}) *coconutYooCall { + return _c.Parent.OnYooRaw(st) +} + +func (_c *coconutZooCall) OnZooRaw(st interface{}) *coconutZooCall { + return _c.Parent.OnZooRaw(st) +} diff --git a/testdata/src/b/c/mock_test.go b/testdata/src/b/c/mock_test.go new file mode 100644 index 0000000..de059cc --- /dev/null +++ b/testdata/src/b/c/mock_test.go @@ -0,0 +1,36 @@ +package c + +import ( + "context" + "testing" +) + +// mocktail:Pineapple +// mocktail:Coconut + +func TestName(t *testing.T) { + var s Pineapple = newPineappleMock(t). + OnHello(Water{}).TypedReturns("a").Once(). + OnWorld().TypedReturns("a").Once(). + OnGoo().TypedReturns("", 1, Water{}).Once(). + OnCoo("", Water{}).TypedReturns(Water{}). + TypedRun(func(s string, water Water) {}).Once(). + Parent + + s.Hello(Water{}) + s.World() + s.Goo() + s.Coo(context.Background(), "", Water{}) + + fn := func(st Strawberry, stban Strawberry) Pineapple { + return s + } + + var c Coconut = newCoconutMock(t). + OnLoo("a", 1, 2).TypedReturns("foo").Once(). + OnMoo(fn).TypedReturns("").Once(). + Parent + + c.Loo("a", 1, 2) + c.Moo(fn) +} diff --git a/testdata/src/b/go.mod b/testdata/src/b/go.mod new file mode 100644 index 0000000..68e91a6 --- /dev/null +++ b/testdata/src/b/go.mod @@ -0,0 +1,16 @@ +module b + +go 1.18 + +require ( + github.com/stretchr/testify v1.8.0 + golang.org/x/mod v0.5.1 +) + +require ( + github.com/davecgh/go-spew v1.1.1 // indirect + github.com/pmezard/go-difflib v1.0.0 // indirect + github.com/stretchr/objx v0.4.0 // indirect + golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect +) diff --git a/testdata/src/b/go.sum b/testdata/src/b/go.sum new file mode 100644 index 0000000..0c98ef7 --- /dev/null +++ b/testdata/src/b/go.sum @@ -0,0 +1,20 @@ +github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c= +github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38= +github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM= +github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4= +github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= +github.com/stretchr/objx v0.4.0 h1:M2gUjqZET1qApGOWNSnZ49BAIMX4F/1plDv3+l31EJ4= +github.com/stretchr/objx v0.4.0/go.mod h1:YvHI0jy2hoMjB+UWwv71VJQ9isScKT/TqJzVSSt89Yw= +github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/stretchr/testify v1.8.0 h1:pSgiaMZlXftHpm5L7V1+rVB+AZJydKsMxsQBIJw4PKk= +github.com/stretchr/testify v1.8.0/go.mod h1:yNjHg4UonilssWZ8iaSj1OCr/vHnekPRkoO+kdMU+MU= +golang.org/x/mod v0.5.1 h1:OJxoQ/rynoF0dcCdI7cLPktw/hR2cueqYfjm43oqK38= +golang.org/x/mod v0.5.1/go.mod h1:5OXOZSfqPIIbmVBIIKWRFfZjPR0E5r58TLhUjH0a2Ro= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898 h1:/atklqdjdhuosWIl6AIbOeHJjicWYPqR9bpxqxYG2pA= +golang.org/x/xerrors v0.0.0-20191011141410-1b5146add898/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM= +gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= +gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= +gopkg.in/yaml.v3 v3.0.1 h1:fxVm/GzAzEWqLHuvctI91KS9hhNmmWOoWu0XTYJS7CA= +gopkg.in/yaml.v3 v3.0.1/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM=