diff --git a/Makefile b/Makefile index 8a92eac..f895037 100644 --- a/Makefile +++ b/Makefile @@ -17,6 +17,7 @@ generate: go run ./cmd/minimock/minimock.go -i ./tests.genericInlineUnion -o ./tests/generic_inline_union.go go run ./cmd/minimock/minimock.go -i ./tests.contextAccepter -o ./tests/context_accepter_mock.go go run ./cmd/minimock/minimock.go -i github.com/gojuno/minimock/v3.Tester -o ./tests/package_name_specified_test.go -p tests_test + go run ./cmd/minimock/minimock.go -i ./tests.actor -o ./tests/actor_mock.go ./bin: mkdir ./bin diff --git a/cmd/minimock/minimock.go b/cmd/minimock/minimock.go index 8ea17a0..aa24a9c 100644 --- a/cmd/minimock/minimock.go +++ b/cmd/minimock/minimock.go @@ -41,6 +41,9 @@ var helpers = template.FuncMap{ } return false }, + "inc": func(a int) int { + return a + 1 + }, } type ( diff --git a/go.mod b/go.mod index bb54703..5025cb8 100644 --- a/go.mod +++ b/go.mod @@ -2,10 +2,10 @@ module github.com/gojuno/minimock/v3 require ( github.com/davecgh/go-spew v1.1.1 - github.com/hexdigest/gowrap v1.3.2 + github.com/hexdigest/gowrap v1.3.6 github.com/pkg/errors v0.9.1 github.com/pmezard/go-difflib v1.0.0 - github.com/stretchr/testify v1.7.1 + github.com/stretchr/testify v1.8.4 golang.org/x/tools v0.1.11-0.20220316014157-77aa08bb151a google.golang.org/protobuf v1.30.0 ) @@ -13,10 +13,12 @@ require ( require ( github.com/kr/text v0.2.0 // indirect golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3 // indirect - golang.org/x/sys v0.1.0 // indirect + golang.org/x/sys v0.5.0 // indirect golang.org/x/xerrors v0.0.0-20220411194840-2f41105eb62f // indirect gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c // indirect - gopkg.in/yaml.v3 v3.0.0 // indirect + gopkg.in/yaml.v3 v3.0.1 // indirect ) -go 1.19 +go 1.22 + +toolchain go1.22.0 diff --git a/go.sum b/go.sum index aad4cab..f5e977d 100644 --- a/go.sum +++ b/go.sum @@ -1,14 +1,15 @@ github.com/creack/pty v1.1.9/go.mod h1:oKZEueFk5CKHvIhNR5MUki03XCEU+Q6VDXinZuGJ33E= -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/golang/protobuf v1.5.0/go.mod h1:FsONVRAS9T7sI+LIUmWTfcYkHO4aIWwzhcaSAoJOfIk= github.com/google/go-cmp v0.5.5/go.mod h1:v8dTdLbMG2kIc/vJvl+f65V22dbkXbowE6jgT/gNBxE= -github.com/google/go-cmp v0.5.7 h1:81/ik6ipDQS2aGcBfIN5dHDB36BwrStyeAQquSYCV4o= -github.com/hexdigest/gowrap v1.3.2 h1:ZDhDFhrbAHYRdt9ZnULKZyggC/3+W9EpfX6R8DjlggY= -github.com/hexdigest/gowrap v1.3.2/go.mod h1:g8N2jI4n9AKrf843erksNTrt4sdkG+TGVfhWe8dWrJQ= +github.com/google/go-cmp v0.6.0 h1:ofyhxvXcZhMsU5ulbFiLKl/XBFqE1GSq7atu8tAmTRI= +github.com/google/go-cmp v0.6.0/go.mod h1:17dUlkBOakJ0+DkrSSNjCkIjxS6bF9zb3elmeNGIjoY= +github.com/hexdigest/gowrap v1.3.6 h1:nW91fC0tjW9X6MjittAK1EmI/9lAXibjqL4ebA6y8F8= +github.com/hexdigest/gowrap v1.3.6/go.mod h1:5KTYxPjK1RRfD+9L4Oo9gjP3XNAs4rkoVK2E7eAEFyM= github.com/kr/pretty v0.2.1/go.mod h1:ipq/a2n7PKx3OHsz4KJII5eveXtPO4qwEXGdVfWzfnI= github.com/kr/pretty v0.3.0 h1:WgNl7dwNpEZ6jJ9k1snq4pZsg7DOEN8hP9Xw0Tsjwk0= +github.com/kr/pretty v0.3.0/go.mod h1:640gp4NfQd8pI5XOwp5fnNeVWj67G7CFk/SaSQn7NBk= github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ= github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI= github.com/kr/text v0.2.0 h1:5Nx0Ya0ZqY2ygV366QzturHI13Jq95ApcVaJBhpS+AY= @@ -18,13 +19,13 @@ github.com/pkg/errors v0.9.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINE 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/rogpeppe/go-internal v1.8.1 h1:geMPLpDpQOgVyCg5z5GoRwLHepNdb71NXb67XFkP+Eg= -github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME= -github.com/stretchr/testify v1.7.1 h1:5TQK59W5E3v0r2duFAb7P95B6hEeOyEnHRa8MjYSMTY= -github.com/stretchr/testify v1.7.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg= +github.com/rogpeppe/go-internal v1.8.1/go.mod h1:JeRgkft04UBgHMgCIwADu4Pn6Mtm5d4nPKWu0nJ5d+o= +github.com/stretchr/testify v1.8.4 h1:CcVxjf3Q8PM0mHUKJCdn+eZZtm5yQwehR5yeSVQQcUk= +github.com/stretchr/testify v1.8.4/go.mod h1:sz/lmYIOXD/1dqDmKjjqLyZ2RngseejIcXlSw2iwfAo= golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3 h1:kQgndtyPBW/JIYERgdxfwMYh3AVStj88WQTlNDi2a+o= golang.org/x/mod v0.6.0-dev.0.20220106191415-9b9b3d81d5e3/go.mod h1:3p9vT2HGsQu2K1YbXdKPJLVgG5VJdoTa1poYQBtP1AY= -golang.org/x/sys v0.1.0 h1:kunALQeHf1/185U1i0GOB/fy1IPRDDpuoOOqRReG57U= -golang.org/x/sys v0.1.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= +golang.org/x/sys v0.5.0 h1:MUK/U/4lj1t1oPg0HfuXDN/Z1wv31ZJ/YcPiGccS4DU= +golang.org/x/sys v0.5.0/go.mod h1:oPkhp1MJrh7nUepCBck5+mAzfO9JrbApNNgaTdGDITg= golang.org/x/tools v0.1.11-0.20220316014157-77aa08bb151a h1:ofrrl6c6NG5/IOSx/R1cyiQxxjqlur0h/TvbUhkH0II= golang.org/x/tools v0.1.11-0.20220316014157-77aa08bb151a/go.mod h1:Uh6Zz+xoGYZom868N8YTex3t7RhtHDBrE8Gzo9bV56E= golang.org/x/xerrors v0.0.0-20191204190536-9bdfabe68543/go.mod h1:I/5z698sn9Ka8TeJc9MKroUUfqBBauWjQqLJ2OPfmY0= @@ -36,6 +37,5 @@ google.golang.org/protobuf v1.30.0/go.mod h1:HV8QOd/L58Z+nl8r43ehVNZIU/HEI6OcFqw gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c h1:Hei/4ADfdWqJk1ZMxUNpqntNwaWcugrBjAiHlqqRiVk= gopkg.in/check.v1 v1.0.0-20201130134442-10cb98267c6c/go.mod h1:JHkPIbrfpd72SG/EVd6muEfDQjcINNoR0C8j2r3qZ4Q= -gopkg.in/yaml.v3 v3.0.0-20200313102051-9f266ea9e77c/go.mod h1:K4uyk7z7BCEPqu6E+C64Yfv1cQ7kz7rIZviUmN+EgEM= -gopkg.in/yaml.v3 v3.0.0 h1:hjy8E9ON/egN1tAYqKb61G10WtihqetD4sz2H+8nIeA= -gopkg.in/yaml.v3 v3.0.0/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= diff --git a/template.go b/template.go index e992c4d..7fc8173 100644 --- a/template.go +++ b/template.go @@ -78,6 +78,7 @@ const ( type {{$mock}}{{$method.Name}}Expectation{{(params)}} struct { mock *{{$mock}}{{(paramsRef)}} {{ if $method.HasParams }} params *{{$mock}}{{$method.Name}}Params{{(paramsRef)}} {{end}} + {{ if $method.HasParams }} paramPtrs *{{$mock}}{{$method.Name}}ParamPtrs{{(paramsRef)}} {{end}} {{ if $method.HasResults }} results *{{$mock}}{{$method.Name}}Results{{(paramsRef)}} {{end}} Counter uint64 } @@ -87,6 +88,11 @@ const ( type {{$mock}}{{$method.Name}}Params{{(params)}} {{$method.ParamsStruct}} {{end}} + {{if $method.HasParams }} + // {{$mock}}{{$method.Name}}ParamPtrs contains pointers to parameters of the {{$.Interface.Name}}.{{$method.Name}} + type {{$mock}}{{$method.Name}}ParamPtrs{{(params)}} {{$method.ParamPtrsStruct}} + {{end}} + {{if $method.HasResults }} // {{$mock}}{{$method.Name}}Results contains results of the {{$.Interface.Name}}.{{$method.Name}} type {{$mock}}{{$method.Name}}Results{{(params)}} {{$method.ResultsStruct}} @@ -103,6 +109,10 @@ const ( } {{if $method.HasParams }} + if {{$m}}.defaultExpectation.paramPtrs != nil { + {{$m}}.mock.t.Fatalf("{{$mock}}.{{$method.Name}} mock is already set by ExpectParams functions") + } + {{$m}}.defaultExpectation.params = &{{$mock}}{{$method.Name}}Params{{(paramsRef)}}{ {{ $method.ParamsNames }} } for _, e := range {{$m}}.expectations { if minimock.Equal(e.params, {{$m}}.defaultExpectation.params) { @@ -113,6 +123,29 @@ const ( return {{$m}} } + {{ range $idx, $param := $method.Params }} + // Expect{{ $param.Name | title }}Param{{$idx | inc}} sets up expected param {{ $param.Name }} for {{$.Interface.Name}}.{{$method.Name}} + func ({{$m}} *m{{$mock}}{{$method.Name}}{{(paramsRef)}}) Expect{{ $param.Name | title }}Param{{$idx | inc}}({{$param.Name}} {{$param.Type}}) *m{{$mock}}{{$method.Name}}{{(paramsRef)}} { + if {{$m}}.mock.func{{$method.Name}} != nil { + {{$m}}.mock.t.Fatalf("{{$mock}}.{{$method.Name}} mock is already set by Set") + } + + if {{$m}}.defaultExpectation == nil { + {{$m}}.defaultExpectation = &{{$mock}}{{$method.Name}}Expectation{{(paramsRef)}}{} + } + + if {{$m}}.defaultExpectation.params != nil { + {{$m}}.mock.t.Fatalf("{{$mock}}.{{$method.Name}} mock is already set by Expect") + } + + if {{$m}}.defaultExpectation.paramPtrs == nil { + {{$m}}.defaultExpectation.paramPtrs = &{{$mock}}{{$method.Name}}ParamPtrs{{(paramsRef)}}{} + } + {{$m}}.defaultExpectation.paramPtrs.{{$param.Name}} = &{{$param.Name}} + + return {{$m}} + } + {{ end }} // Inspect accepts an inspector function that has same arguments as the {{$.Interface.Name}}.{{$method.Name}} func ({{$m}} *m{{$mock}}{{$method.Name}}{{(paramsRef)}}) Inspect(f func({{$method.Params}})) *m{{$mock}}{{$method.Name}}{{(paramsRef)}} { if {{$m}}.mock.inspectFunc{{$method.Name}} != nil { @@ -203,8 +236,17 @@ const ( mm_atomic.AddUint64(&{{$m}}.{{$method.Name}}Mock.defaultExpectation.Counter, 1) {{- if $method.HasParams }} mm_want := {{$m}}.{{$method.Name}}Mock.defaultExpectation.params + mm_want_ptrs := {{$m}}.{{$method.Name}}Mock.defaultExpectation.paramPtrs + mm_got := {{$mock}}{{$method.Name}}Params{{(paramsRef)}}{ {{$method.ParamsNames}} } - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + {{ range $idx, $param := $method.Params }} + if mm_want_ptrs.{{$param.Name}} != nil && !minimock.Equal(*mm_want_ptrs.{{$param.Name}}, mm_got.{{$param.Name}}) { + {{$m}}.t.Errorf("{{$mock}}.{{$method.Name}} got unexpected parameter {{$param.Name}}, want: %#v, got: %#v%s\n", *mm_want_ptrs.{{$param.Name}}, mm_got.{{$param.Name}}, minimock.Diff(*mm_want_ptrs.{{$param.Name}}, mm_got.{{$param.Name}})) + } + {{ end }} + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { {{$m}}.t.Errorf("{{$mock}}.{{$method.Name}} got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } {{ end }} diff --git a/tests/actor_mock.go b/tests/actor_mock.go new file mode 100644 index 0000000..d0e4cad --- /dev/null +++ b/tests/actor_mock.go @@ -0,0 +1,358 @@ +package tests + +// Code generated by http://github.com/gojuno/minimock (dev). DO NOT EDIT. + +//go:generate minimock -i github.com/gojuno/minimock/v3/tests.actor -o actor_mock.go -n ActorMock -p tests + +import ( + "sync" + mm_atomic "sync/atomic" + mm_time "time" + + "github.com/gojuno/minimock/v3" +) + +// ActorMock implements actor +type ActorMock struct { + t minimock.Tester + finishOnce sync.Once + + funcAction func(firstParam string, secondParam int) (i1 int, err error) + inspectFuncAction func(firstParam string, secondParam int) + afterActionCounter uint64 + beforeActionCounter uint64 + ActionMock mActorMockAction +} + +// NewActorMock returns a mock for actor +func NewActorMock(t minimock.Tester) *ActorMock { + m := &ActorMock{t: t} + + if controller, ok := t.(minimock.MockController); ok { + controller.RegisterMocker(m) + } + + m.ActionMock = mActorMockAction{mock: m} + m.ActionMock.callArgs = []*ActorMockActionParams{} + + t.Cleanup(m.MinimockFinish) + + return m +} + +type mActorMockAction struct { + mock *ActorMock + defaultExpectation *ActorMockActionExpectation + expectations []*ActorMockActionExpectation + + callArgs []*ActorMockActionParams + mutex sync.RWMutex +} + +// ActorMockActionExpectation specifies expectation struct of the actor.Action +type ActorMockActionExpectation struct { + mock *ActorMock + params *ActorMockActionParams + paramPtrs *ActorMockActionParamPtrs + results *ActorMockActionResults + Counter uint64 +} + +// ActorMockActionParams contains parameters of the actor.Action +type ActorMockActionParams struct { + firstParam string + secondParam int +} + +// ActorMockActionParamPtrs contains pointers to parameters of the actor.Action +type ActorMockActionParamPtrs struct { + firstParam *string + secondParam *int +} + +// ActorMockActionResults contains results of the actor.Action +type ActorMockActionResults struct { + i1 int + err error +} + +// Expect sets up expected params for actor.Action +func (mmAction *mActorMockAction) Expect(firstParam string, secondParam int) *mActorMockAction { + if mmAction.mock.funcAction != nil { + mmAction.mock.t.Fatalf("ActorMock.Action mock is already set by Set") + } + + if mmAction.defaultExpectation == nil { + mmAction.defaultExpectation = &ActorMockActionExpectation{} + } + + if mmAction.defaultExpectation.paramPtrs != nil { + mmAction.mock.t.Fatalf("ActorMock.Action mock is already set by ExpectParams functions") + } + + mmAction.defaultExpectation.params = &ActorMockActionParams{firstParam, secondParam} + for _, e := range mmAction.expectations { + if minimock.Equal(e.params, mmAction.defaultExpectation.params) { + mmAction.mock.t.Fatalf("Expectation set by When has same params: %#v", *mmAction.defaultExpectation.params) + } + } + + return mmAction +} + +// ExpectFirstParamParam1 sets up expected param firstParam for actor.Action +func (mmAction *mActorMockAction) ExpectFirstParamParam1(firstParam string) *mActorMockAction { + if mmAction.mock.funcAction != nil { + mmAction.mock.t.Fatalf("ActorMock.Action mock is already set by Set") + } + + if mmAction.defaultExpectation == nil { + mmAction.defaultExpectation = &ActorMockActionExpectation{} + } + + if mmAction.defaultExpectation.params != nil { + mmAction.mock.t.Fatalf("ActorMock.Action mock is already set by Expect") + } + + if mmAction.defaultExpectation.paramPtrs == nil { + mmAction.defaultExpectation.paramPtrs = &ActorMockActionParamPtrs{} + } + mmAction.defaultExpectation.paramPtrs.firstParam = &firstParam + + return mmAction +} + +// ExpectSecondParamParam2 sets up expected param secondParam for actor.Action +func (mmAction *mActorMockAction) ExpectSecondParamParam2(secondParam int) *mActorMockAction { + if mmAction.mock.funcAction != nil { + mmAction.mock.t.Fatalf("ActorMock.Action mock is already set by Set") + } + + if mmAction.defaultExpectation == nil { + mmAction.defaultExpectation = &ActorMockActionExpectation{} + } + + if mmAction.defaultExpectation.params != nil { + mmAction.mock.t.Fatalf("ActorMock.Action mock is already set by Expect") + } + + if mmAction.defaultExpectation.paramPtrs == nil { + mmAction.defaultExpectation.paramPtrs = &ActorMockActionParamPtrs{} + } + mmAction.defaultExpectation.paramPtrs.secondParam = &secondParam + + return mmAction +} + +// Inspect accepts an inspector function that has same arguments as the actor.Action +func (mmAction *mActorMockAction) Inspect(f func(firstParam string, secondParam int)) *mActorMockAction { + if mmAction.mock.inspectFuncAction != nil { + mmAction.mock.t.Fatalf("Inspect function is already set for ActorMock.Action") + } + + mmAction.mock.inspectFuncAction = f + + return mmAction +} + +// Return sets up results that will be returned by actor.Action +func (mmAction *mActorMockAction) Return(i1 int, err error) *ActorMock { + if mmAction.mock.funcAction != nil { + mmAction.mock.t.Fatalf("ActorMock.Action mock is already set by Set") + } + + if mmAction.defaultExpectation == nil { + mmAction.defaultExpectation = &ActorMockActionExpectation{mock: mmAction.mock} + } + mmAction.defaultExpectation.results = &ActorMockActionResults{i1, err} + return mmAction.mock +} + +// Set uses given function f to mock the actor.Action method +func (mmAction *mActorMockAction) Set(f func(firstParam string, secondParam int) (i1 int, err error)) *ActorMock { + if mmAction.defaultExpectation != nil { + mmAction.mock.t.Fatalf("Default expectation is already set for the actor.Action method") + } + + if len(mmAction.expectations) > 0 { + mmAction.mock.t.Fatalf("Some expectations are already set for the actor.Action method") + } + + mmAction.mock.funcAction = f + return mmAction.mock +} + +// When sets expectation for the actor.Action which will trigger the result defined by the following +// Then helper +func (mmAction *mActorMockAction) When(firstParam string, secondParam int) *ActorMockActionExpectation { + if mmAction.mock.funcAction != nil { + mmAction.mock.t.Fatalf("ActorMock.Action mock is already set by Set") + } + + expectation := &ActorMockActionExpectation{ + mock: mmAction.mock, + params: &ActorMockActionParams{firstParam, secondParam}, + } + mmAction.expectations = append(mmAction.expectations, expectation) + return expectation +} + +// Then sets up actor.Action return parameters for the expectation previously defined by the When method +func (e *ActorMockActionExpectation) Then(i1 int, err error) *ActorMock { + e.results = &ActorMockActionResults{i1, err} + return e.mock +} + +// Action implements actor +func (mmAction *ActorMock) Action(firstParam string, secondParam int) (i1 int, err error) { + mm_atomic.AddUint64(&mmAction.beforeActionCounter, 1) + defer mm_atomic.AddUint64(&mmAction.afterActionCounter, 1) + + if mmAction.inspectFuncAction != nil { + mmAction.inspectFuncAction(firstParam, secondParam) + } + + mm_params := ActorMockActionParams{firstParam, secondParam} + + // Record call args + mmAction.ActionMock.mutex.Lock() + mmAction.ActionMock.callArgs = append(mmAction.ActionMock.callArgs, &mm_params) + mmAction.ActionMock.mutex.Unlock() + + for _, e := range mmAction.ActionMock.expectations { + if minimock.Equal(*e.params, mm_params) { + mm_atomic.AddUint64(&e.Counter, 1) + return e.results.i1, e.results.err + } + } + + if mmAction.ActionMock.defaultExpectation != nil { + mm_atomic.AddUint64(&mmAction.ActionMock.defaultExpectation.Counter, 1) + mm_want := mmAction.ActionMock.defaultExpectation.params + mm_want_ptrs := mmAction.ActionMock.defaultExpectation.paramPtrs + + mm_got := ActorMockActionParams{firstParam, secondParam} + + if mm_want_ptrs != nil { + + if mm_want_ptrs.firstParam != nil && !minimock.Equal(*mm_want_ptrs.firstParam, mm_got.firstParam) { + mmAction.t.Errorf("ActorMock.Action got unexpected parameter firstParam, want: %#v, got: %#v%s\n", *mm_want_ptrs.firstParam, mm_got.firstParam, minimock.Diff(*mm_want_ptrs.firstParam, mm_got.firstParam)) + } + + if mm_want_ptrs.secondParam != nil && !minimock.Equal(*mm_want_ptrs.secondParam, mm_got.secondParam) { + mmAction.t.Errorf("ActorMock.Action got unexpected parameter secondParam, want: %#v, got: %#v%s\n", *mm_want_ptrs.secondParam, mm_got.secondParam, minimock.Diff(*mm_want_ptrs.secondParam, mm_got.secondParam)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + mmAction.t.Errorf("ActorMock.Action got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) + } + + mm_results := mmAction.ActionMock.defaultExpectation.results + if mm_results == nil { + mmAction.t.Fatal("No results are set for the ActorMock.Action") + } + return (*mm_results).i1, (*mm_results).err + } + if mmAction.funcAction != nil { + return mmAction.funcAction(firstParam, secondParam) + } + mmAction.t.Fatalf("Unexpected call to ActorMock.Action. %v %v", firstParam, secondParam) + return +} + +// ActionAfterCounter returns a count of finished ActorMock.Action invocations +func (mmAction *ActorMock) ActionAfterCounter() uint64 { + return mm_atomic.LoadUint64(&mmAction.afterActionCounter) +} + +// ActionBeforeCounter returns a count of ActorMock.Action invocations +func (mmAction *ActorMock) ActionBeforeCounter() uint64 { + return mm_atomic.LoadUint64(&mmAction.beforeActionCounter) +} + +// Calls returns a list of arguments used in each call to ActorMock.Action. +// The list is in the same order as the calls were made (i.e. recent calls have a higher index) +func (mmAction *mActorMockAction) Calls() []*ActorMockActionParams { + mmAction.mutex.RLock() + + argCopy := make([]*ActorMockActionParams, len(mmAction.callArgs)) + copy(argCopy, mmAction.callArgs) + + mmAction.mutex.RUnlock() + + return argCopy +} + +// MinimockActionDone returns true if the count of the Action invocations corresponds +// the number of defined expectations +func (m *ActorMock) MinimockActionDone() bool { + for _, e := range m.ActionMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + return false + } + } + + // if default expectation was set then invocations count should be greater than zero + if m.ActionMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterActionCounter) < 1 { + return false + } + // if func was set then invocations count should be greater than zero + if m.funcAction != nil && mm_atomic.LoadUint64(&m.afterActionCounter) < 1 { + return false + } + return true +} + +// MinimockActionInspect logs each unmet expectation +func (m *ActorMock) MinimockActionInspect() { + for _, e := range m.ActionMock.expectations { + if mm_atomic.LoadUint64(&e.Counter) < 1 { + m.t.Errorf("Expected call to ActorMock.Action with params: %#v", *e.params) + } + } + + // if default expectation was set then invocations count should be greater than zero + if m.ActionMock.defaultExpectation != nil && mm_atomic.LoadUint64(&m.afterActionCounter) < 1 { + if m.ActionMock.defaultExpectation.params == nil { + m.t.Error("Expected call to ActorMock.Action") + } else { + m.t.Errorf("Expected call to ActorMock.Action with params: %#v", *m.ActionMock.defaultExpectation.params) + } + } + // if func was set then invocations count should be greater than zero + if m.funcAction != nil && mm_atomic.LoadUint64(&m.afterActionCounter) < 1 { + m.t.Error("Expected call to ActorMock.Action") + } +} + +// MinimockFinish checks that all mocked methods have been called the expected number of times +func (m *ActorMock) MinimockFinish() { + m.finishOnce.Do(func() { + if !m.minimockDone() { + m.MinimockActionInspect() + m.t.FailNow() + } + }) +} + +// MinimockWait waits for all mocked methods to be called the expected number of times +func (m *ActorMock) MinimockWait(timeout mm_time.Duration) { + timeoutCh := mm_time.After(timeout) + for { + if m.minimockDone() { + return + } + select { + case <-timeoutCh: + m.MinimockFinish() + return + case <-mm_time.After(10 * mm_time.Millisecond): + } + } +} + +func (m *ActorMock) minimockDone() bool { + done := true + return done && + m.MinimockActionDone() +} diff --git a/tests/actor_mock_test.go b/tests/actor_mock_test.go new file mode 100644 index 0000000..3311817 --- /dev/null +++ b/tests/actor_mock_test.go @@ -0,0 +1,85 @@ +package tests + +import ( + "testing" + + "github.com/stretchr/testify/assert" +) + +func TestActorMock_TestPassedWithBothExpectedParams(t *testing.T) { + tester := NewTesterMock(t) + tester.CleanupMock.Return() + + mock := NewActorMock(tester). + ActionMock.ExpectFirstParamParam1("abc"). + ExpectSecondParamParam2(24).Return(1, nil) + + a, err := mock.Action("abc", 24) + assert.NoError(t, err) + assert.Equal(t, 1, a) +} + +func TestActorMock_TestPassedWithOneExpectedParams(t *testing.T) { + tester := NewTesterMock(t) + tester.CleanupMock.Return() + + mock := NewActorMock(tester). + ActionMock.ExpectFirstParamParam1("abc").Return(1, nil) + + a, err := mock.Action("abc", 24) + assert.NoError(t, err) + assert.Equal(t, 1, a) +} + +func TestActorMock_TestFailedWithExpectedParams(t *testing.T) { + tester := NewTesterMock(t) + tester.CleanupMock.Return() + tester.ErrorfMock. + Expect("ActorMock.Action got unexpected parameter secondParam, want: %#v, got: %#v%s\n", 24, 25, ""). + Return() + + mock := NewActorMock(tester). + ActionMock.ExpectFirstParamParam1("abc"). + ExpectSecondParamParam2(24).Return(1, nil) + + a, err := mock.Action("abc", 25) + assert.NoError(t, err) + assert.Equal(t, 1, a) +} + +func TestActorMock_FailedToUseExpectAfterExpectParams(t *testing.T) { + tester := NewTesterMock(t) + tester.CleanupMock.Return() + tester.FatalfMock. + Expect("ActorMock.Action mock is already set by ExpectParams functions"). + Return() + + _ = NewActorMock(tester). + ActionMock.ExpectFirstParamParam1("abc"). + Expect("aaa", 123).Return(1, nil) +} + +func TestActorMock_FailedToUseExpectParamsAfterExpect(t *testing.T) { + tester := NewTesterMock(t) + tester.CleanupMock.Return() + tester.FatalfMock. + Expect("ActorMock.Action mock is already set by Expect"). + Return() + + _ = NewActorMock(tester). + ActionMock.Expect("aaa", 123). + ExpectFirstParamParam1("abc").Return(1, nil) +} + +func TestActorMock_FailedToUseExpectParamsAfterSet(t *testing.T) { + tester := NewTesterMock(t) + tester.CleanupMock.Return() + tester.FatalfMock. + Expect("ActorMock.Action mock is already set by Set"). + Return() + + _ = NewActorMock(tester). + ActionMock.Set(func(firstParam string, secondParam int) (i1 int, err error) { + return + }).ActionMock.ExpectFirstParamParam1("abc").Return(1, nil) +} diff --git a/tests/context_accepter_mock.go b/tests/context_accepter_mock.go index 9f89838..6c16e68 100644 --- a/tests/context_accepter_mock.go +++ b/tests/context_accepter_mock.go @@ -61,8 +61,9 @@ type mContextAccepterMockAcceptContext struct { // ContextAccepterMockAcceptContextExpectation specifies expectation struct of the contextAccepter.AcceptContext type ContextAccepterMockAcceptContextExpectation struct { - mock *ContextAccepterMock - params *ContextAccepterMockAcceptContextParams + mock *ContextAccepterMock + params *ContextAccepterMockAcceptContextParams + paramPtrs *ContextAccepterMockAcceptContextParamPtrs Counter uint64 } @@ -72,6 +73,11 @@ type ContextAccepterMockAcceptContextParams struct { ctx context.Context } +// ContextAccepterMockAcceptContextParamPtrs contains pointers to parameters of the contextAccepter.AcceptContext +type ContextAccepterMockAcceptContextParamPtrs struct { + ctx *context.Context +} + // Expect sets up expected params for contextAccepter.AcceptContext func (mmAcceptContext *mContextAccepterMockAcceptContext) Expect(ctx context.Context) *mContextAccepterMockAcceptContext { if mmAcceptContext.mock.funcAcceptContext != nil { @@ -82,6 +88,10 @@ func (mmAcceptContext *mContextAccepterMockAcceptContext) Expect(ctx context.Con mmAcceptContext.defaultExpectation = &ContextAccepterMockAcceptContextExpectation{} } + if mmAcceptContext.defaultExpectation.paramPtrs != nil { + mmAcceptContext.mock.t.Fatalf("ContextAccepterMock.AcceptContext mock is already set by ExpectParams functions") + } + mmAcceptContext.defaultExpectation.params = &ContextAccepterMockAcceptContextParams{ctx} for _, e := range mmAcceptContext.expectations { if minimock.Equal(e.params, mmAcceptContext.defaultExpectation.params) { @@ -92,6 +102,28 @@ func (mmAcceptContext *mContextAccepterMockAcceptContext) Expect(ctx context.Con return mmAcceptContext } +// ExpectCtxParam1 sets up expected param ctx for contextAccepter.AcceptContext +func (mmAcceptContext *mContextAccepterMockAcceptContext) ExpectCtxParam1(ctx context.Context) *mContextAccepterMockAcceptContext { + if mmAcceptContext.mock.funcAcceptContext != nil { + mmAcceptContext.mock.t.Fatalf("ContextAccepterMock.AcceptContext mock is already set by Set") + } + + if mmAcceptContext.defaultExpectation == nil { + mmAcceptContext.defaultExpectation = &ContextAccepterMockAcceptContextExpectation{} + } + + if mmAcceptContext.defaultExpectation.params != nil { + mmAcceptContext.mock.t.Fatalf("ContextAccepterMock.AcceptContext mock is already set by Expect") + } + + if mmAcceptContext.defaultExpectation.paramPtrs == nil { + mmAcceptContext.defaultExpectation.paramPtrs = &ContextAccepterMockAcceptContextParamPtrs{} + } + mmAcceptContext.defaultExpectation.paramPtrs.ctx = &ctx + + return mmAcceptContext +} + // Inspect accepts an inspector function that has same arguments as the contextAccepter.AcceptContext func (mmAcceptContext *mContextAccepterMockAcceptContext) Inspect(f func(ctx context.Context)) *mContextAccepterMockAcceptContext { if mmAcceptContext.mock.inspectFuncAcceptContext != nil { @@ -156,8 +188,17 @@ func (mmAcceptContext *ContextAccepterMock) AcceptContext(ctx context.Context) { if mmAcceptContext.AcceptContextMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmAcceptContext.AcceptContextMock.defaultExpectation.Counter, 1) mm_want := mmAcceptContext.AcceptContextMock.defaultExpectation.params + mm_want_ptrs := mmAcceptContext.AcceptContextMock.defaultExpectation.paramPtrs + mm_got := ContextAccepterMockAcceptContextParams{ctx} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmAcceptContext.t.Errorf("ContextAccepterMock.AcceptContext got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmAcceptContext.t.Errorf("ContextAccepterMock.AcceptContext got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } @@ -248,10 +289,11 @@ type mContextAccepterMockAcceptContextWithOtherArgs struct { // ContextAccepterMockAcceptContextWithOtherArgsExpectation specifies expectation struct of the contextAccepter.AcceptContextWithOtherArgs type ContextAccepterMockAcceptContextWithOtherArgsExpectation struct { - mock *ContextAccepterMock - params *ContextAccepterMockAcceptContextWithOtherArgsParams - results *ContextAccepterMockAcceptContextWithOtherArgsResults - Counter uint64 + mock *ContextAccepterMock + params *ContextAccepterMockAcceptContextWithOtherArgsParams + paramPtrs *ContextAccepterMockAcceptContextWithOtherArgsParamPtrs + results *ContextAccepterMockAcceptContextWithOtherArgsResults + Counter uint64 } // ContextAccepterMockAcceptContextWithOtherArgsParams contains parameters of the contextAccepter.AcceptContextWithOtherArgs @@ -260,6 +302,12 @@ type ContextAccepterMockAcceptContextWithOtherArgsParams struct { i1 int } +// ContextAccepterMockAcceptContextWithOtherArgsParamPtrs contains pointers to parameters of the contextAccepter.AcceptContextWithOtherArgs +type ContextAccepterMockAcceptContextWithOtherArgsParamPtrs struct { + ctx *context.Context + i1 *int +} + // ContextAccepterMockAcceptContextWithOtherArgsResults contains results of the contextAccepter.AcceptContextWithOtherArgs type ContextAccepterMockAcceptContextWithOtherArgsResults struct { i2 int @@ -276,6 +324,10 @@ func (mmAcceptContextWithOtherArgs *mContextAccepterMockAcceptContextWithOtherAr mmAcceptContextWithOtherArgs.defaultExpectation = &ContextAccepterMockAcceptContextWithOtherArgsExpectation{} } + if mmAcceptContextWithOtherArgs.defaultExpectation.paramPtrs != nil { + mmAcceptContextWithOtherArgs.mock.t.Fatalf("ContextAccepterMock.AcceptContextWithOtherArgs mock is already set by ExpectParams functions") + } + mmAcceptContextWithOtherArgs.defaultExpectation.params = &ContextAccepterMockAcceptContextWithOtherArgsParams{ctx, i1} for _, e := range mmAcceptContextWithOtherArgs.expectations { if minimock.Equal(e.params, mmAcceptContextWithOtherArgs.defaultExpectation.params) { @@ -286,6 +338,50 @@ func (mmAcceptContextWithOtherArgs *mContextAccepterMockAcceptContextWithOtherAr return mmAcceptContextWithOtherArgs } +// ExpectCtxParam1 sets up expected param ctx for contextAccepter.AcceptContextWithOtherArgs +func (mmAcceptContextWithOtherArgs *mContextAccepterMockAcceptContextWithOtherArgs) ExpectCtxParam1(ctx context.Context) *mContextAccepterMockAcceptContextWithOtherArgs { + if mmAcceptContextWithOtherArgs.mock.funcAcceptContextWithOtherArgs != nil { + mmAcceptContextWithOtherArgs.mock.t.Fatalf("ContextAccepterMock.AcceptContextWithOtherArgs mock is already set by Set") + } + + if mmAcceptContextWithOtherArgs.defaultExpectation == nil { + mmAcceptContextWithOtherArgs.defaultExpectation = &ContextAccepterMockAcceptContextWithOtherArgsExpectation{} + } + + if mmAcceptContextWithOtherArgs.defaultExpectation.params != nil { + mmAcceptContextWithOtherArgs.mock.t.Fatalf("ContextAccepterMock.AcceptContextWithOtherArgs mock is already set by Expect") + } + + if mmAcceptContextWithOtherArgs.defaultExpectation.paramPtrs == nil { + mmAcceptContextWithOtherArgs.defaultExpectation.paramPtrs = &ContextAccepterMockAcceptContextWithOtherArgsParamPtrs{} + } + mmAcceptContextWithOtherArgs.defaultExpectation.paramPtrs.ctx = &ctx + + return mmAcceptContextWithOtherArgs +} + +// ExpectI1Param2 sets up expected param i1 for contextAccepter.AcceptContextWithOtherArgs +func (mmAcceptContextWithOtherArgs *mContextAccepterMockAcceptContextWithOtherArgs) ExpectI1Param2(i1 int) *mContextAccepterMockAcceptContextWithOtherArgs { + if mmAcceptContextWithOtherArgs.mock.funcAcceptContextWithOtherArgs != nil { + mmAcceptContextWithOtherArgs.mock.t.Fatalf("ContextAccepterMock.AcceptContextWithOtherArgs mock is already set by Set") + } + + if mmAcceptContextWithOtherArgs.defaultExpectation == nil { + mmAcceptContextWithOtherArgs.defaultExpectation = &ContextAccepterMockAcceptContextWithOtherArgsExpectation{} + } + + if mmAcceptContextWithOtherArgs.defaultExpectation.params != nil { + mmAcceptContextWithOtherArgs.mock.t.Fatalf("ContextAccepterMock.AcceptContextWithOtherArgs mock is already set by Expect") + } + + if mmAcceptContextWithOtherArgs.defaultExpectation.paramPtrs == nil { + mmAcceptContextWithOtherArgs.defaultExpectation.paramPtrs = &ContextAccepterMockAcceptContextWithOtherArgsParamPtrs{} + } + mmAcceptContextWithOtherArgs.defaultExpectation.paramPtrs.i1 = &i1 + + return mmAcceptContextWithOtherArgs +} + // Inspect accepts an inspector function that has same arguments as the contextAccepter.AcceptContextWithOtherArgs func (mmAcceptContextWithOtherArgs *mContextAccepterMockAcceptContextWithOtherArgs) Inspect(f func(ctx context.Context, i1 int)) *mContextAccepterMockAcceptContextWithOtherArgs { if mmAcceptContextWithOtherArgs.mock.inspectFuncAcceptContextWithOtherArgs != nil { @@ -371,8 +467,21 @@ func (mmAcceptContextWithOtherArgs *ContextAccepterMock) AcceptContextWithOtherA if mmAcceptContextWithOtherArgs.AcceptContextWithOtherArgsMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmAcceptContextWithOtherArgs.AcceptContextWithOtherArgsMock.defaultExpectation.Counter, 1) mm_want := mmAcceptContextWithOtherArgs.AcceptContextWithOtherArgsMock.defaultExpectation.params + mm_want_ptrs := mmAcceptContextWithOtherArgs.AcceptContextWithOtherArgsMock.defaultExpectation.paramPtrs + mm_got := ContextAccepterMockAcceptContextWithOtherArgsParams{ctx, i1} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.ctx != nil && !minimock.Equal(*mm_want_ptrs.ctx, mm_got.ctx) { + mmAcceptContextWithOtherArgs.t.Errorf("ContextAccepterMock.AcceptContextWithOtherArgs got unexpected parameter ctx, want: %#v, got: %#v%s\n", *mm_want_ptrs.ctx, mm_got.ctx, minimock.Diff(*mm_want_ptrs.ctx, mm_got.ctx)) + } + + if mm_want_ptrs.i1 != nil && !minimock.Equal(*mm_want_ptrs.i1, mm_got.i1) { + mmAcceptContextWithOtherArgs.t.Errorf("ContextAccepterMock.AcceptContextWithOtherArgs got unexpected parameter i1, want: %#v, got: %#v%s\n", *mm_want_ptrs.i1, mm_got.i1, minimock.Diff(*mm_want_ptrs.i1, mm_got.i1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmAcceptContextWithOtherArgs.t.Errorf("ContextAccepterMock.AcceptContextWithOtherArgs got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } diff --git a/tests/formatter_mock.go b/tests/formatter_mock.go index a6abfed..319146f 100644 --- a/tests/formatter_mock.go +++ b/tests/formatter_mock.go @@ -51,10 +51,11 @@ type mFormatterMockFormat struct { // FormatterMockFormatExpectation specifies expectation struct of the Formatter.Format type FormatterMockFormatExpectation struct { - mock *FormatterMock - params *FormatterMockFormatParams - results *FormatterMockFormatResults - Counter uint64 + mock *FormatterMock + params *FormatterMockFormatParams + paramPtrs *FormatterMockFormatParamPtrs + results *FormatterMockFormatResults + Counter uint64 } // FormatterMockFormatParams contains parameters of the Formatter.Format @@ -63,6 +64,12 @@ type FormatterMockFormatParams struct { p1 []interface{} } +// FormatterMockFormatParamPtrs contains pointers to parameters of the Formatter.Format +type FormatterMockFormatParamPtrs struct { + s1 *string + p1 *[]interface{} +} + // FormatterMockFormatResults contains results of the Formatter.Format type FormatterMockFormatResults struct { s2 string @@ -78,6 +85,10 @@ func (mmFormat *mFormatterMockFormat) Expect(s1 string, p1 ...interface{}) *mFor mmFormat.defaultExpectation = &FormatterMockFormatExpectation{} } + if mmFormat.defaultExpectation.paramPtrs != nil { + mmFormat.mock.t.Fatalf("FormatterMock.Format mock is already set by ExpectParams functions") + } + mmFormat.defaultExpectation.params = &FormatterMockFormatParams{s1, p1} for _, e := range mmFormat.expectations { if minimock.Equal(e.params, mmFormat.defaultExpectation.params) { @@ -88,6 +99,50 @@ func (mmFormat *mFormatterMockFormat) Expect(s1 string, p1 ...interface{}) *mFor return mmFormat } +// ExpectS1Param1 sets up expected param s1 for Formatter.Format +func (mmFormat *mFormatterMockFormat) ExpectS1Param1(s1 string) *mFormatterMockFormat { + if mmFormat.mock.funcFormat != nil { + mmFormat.mock.t.Fatalf("FormatterMock.Format mock is already set by Set") + } + + if mmFormat.defaultExpectation == nil { + mmFormat.defaultExpectation = &FormatterMockFormatExpectation{} + } + + if mmFormat.defaultExpectation.params != nil { + mmFormat.mock.t.Fatalf("FormatterMock.Format mock is already set by Expect") + } + + if mmFormat.defaultExpectation.paramPtrs == nil { + mmFormat.defaultExpectation.paramPtrs = &FormatterMockFormatParamPtrs{} + } + mmFormat.defaultExpectation.paramPtrs.s1 = &s1 + + return mmFormat +} + +// ExpectP1Param2 sets up expected param p1 for Formatter.Format +func (mmFormat *mFormatterMockFormat) ExpectP1Param2(p1 ...interface{}) *mFormatterMockFormat { + if mmFormat.mock.funcFormat != nil { + mmFormat.mock.t.Fatalf("FormatterMock.Format mock is already set by Set") + } + + if mmFormat.defaultExpectation == nil { + mmFormat.defaultExpectation = &FormatterMockFormatExpectation{} + } + + if mmFormat.defaultExpectation.params != nil { + mmFormat.mock.t.Fatalf("FormatterMock.Format mock is already set by Expect") + } + + if mmFormat.defaultExpectation.paramPtrs == nil { + mmFormat.defaultExpectation.paramPtrs = &FormatterMockFormatParamPtrs{} + } + mmFormat.defaultExpectation.paramPtrs.p1 = &p1 + + return mmFormat +} + // Inspect accepts an inspector function that has same arguments as the Formatter.Format func (mmFormat *mFormatterMockFormat) Inspect(f func(s1 string, p1 ...interface{})) *mFormatterMockFormat { if mmFormat.mock.inspectFuncFormat != nil { @@ -173,8 +228,21 @@ func (mmFormat *FormatterMock) Format(s1 string, p1 ...interface{}) (s2 string) if mmFormat.FormatMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmFormat.FormatMock.defaultExpectation.Counter, 1) mm_want := mmFormat.FormatMock.defaultExpectation.params + mm_want_ptrs := mmFormat.FormatMock.defaultExpectation.paramPtrs + mm_got := FormatterMockFormatParams{s1, p1} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.s1 != nil && !minimock.Equal(*mm_want_ptrs.s1, mm_got.s1) { + mmFormat.t.Errorf("FormatterMock.Format got unexpected parameter s1, want: %#v, got: %#v%s\n", *mm_want_ptrs.s1, mm_got.s1, minimock.Diff(*mm_want_ptrs.s1, mm_got.s1)) + } + + if mm_want_ptrs.p1 != nil && !minimock.Equal(*mm_want_ptrs.p1, mm_got.p1) { + mmFormat.t.Errorf("FormatterMock.Format got unexpected parameter p1, want: %#v, got: %#v%s\n", *mm_want_ptrs.p1, mm_got.p1, minimock.Diff(*mm_want_ptrs.p1, mm_got.p1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmFormat.t.Errorf("FormatterMock.Format got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } diff --git a/tests/generic_complex_union.go b/tests/generic_complex_union.go index 6ca0923..4229e31 100644 --- a/tests/generic_complex_union.go +++ b/tests/generic_complex_union.go @@ -51,8 +51,9 @@ type mGenericComplexUnionMockName[T complexUnion] struct { // GenericComplexUnionMockNameExpectation specifies expectation struct of the genericComplexUnion.Name type GenericComplexUnionMockNameExpectation[T complexUnion] struct { - mock *GenericComplexUnionMock[T] - params *GenericComplexUnionMockNameParams[T] + mock *GenericComplexUnionMock[T] + params *GenericComplexUnionMockNameParams[T] + paramPtrs *GenericComplexUnionMockNameParamPtrs[T] Counter uint64 } @@ -62,6 +63,11 @@ type GenericComplexUnionMockNameParams[T complexUnion] struct { t1 T } +// GenericComplexUnionMockNameParamPtrs contains pointers to parameters of the genericComplexUnion.Name +type GenericComplexUnionMockNameParamPtrs[T complexUnion] struct { + t1 *T +} + // Expect sets up expected params for genericComplexUnion.Name func (mmName *mGenericComplexUnionMockName[T]) Expect(t1 T) *mGenericComplexUnionMockName[T] { if mmName.mock.funcName != nil { @@ -72,6 +78,10 @@ func (mmName *mGenericComplexUnionMockName[T]) Expect(t1 T) *mGenericComplexUnio mmName.defaultExpectation = &GenericComplexUnionMockNameExpectation[T]{} } + if mmName.defaultExpectation.paramPtrs != nil { + mmName.mock.t.Fatalf("GenericComplexUnionMock.Name mock is already set by ExpectParams functions") + } + mmName.defaultExpectation.params = &GenericComplexUnionMockNameParams[T]{t1} for _, e := range mmName.expectations { if minimock.Equal(e.params, mmName.defaultExpectation.params) { @@ -82,6 +92,28 @@ func (mmName *mGenericComplexUnionMockName[T]) Expect(t1 T) *mGenericComplexUnio return mmName } +// ExpectT1Param1 sets up expected param t1 for genericComplexUnion.Name +func (mmName *mGenericComplexUnionMockName[T]) ExpectT1Param1(t1 T) *mGenericComplexUnionMockName[T] { + if mmName.mock.funcName != nil { + mmName.mock.t.Fatalf("GenericComplexUnionMock.Name mock is already set by Set") + } + + if mmName.defaultExpectation == nil { + mmName.defaultExpectation = &GenericComplexUnionMockNameExpectation[T]{} + } + + if mmName.defaultExpectation.params != nil { + mmName.mock.t.Fatalf("GenericComplexUnionMock.Name mock is already set by Expect") + } + + if mmName.defaultExpectation.paramPtrs == nil { + mmName.defaultExpectation.paramPtrs = &GenericComplexUnionMockNameParamPtrs[T]{} + } + mmName.defaultExpectation.paramPtrs.t1 = &t1 + + return mmName +} + // Inspect accepts an inspector function that has same arguments as the genericComplexUnion.Name func (mmName *mGenericComplexUnionMockName[T]) Inspect(f func(t1 T)) *mGenericComplexUnionMockName[T] { if mmName.mock.inspectFuncName != nil { @@ -146,8 +178,17 @@ func (mmName *GenericComplexUnionMock[T]) Name(t1 T) { if mmName.NameMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmName.NameMock.defaultExpectation.Counter, 1) mm_want := mmName.NameMock.defaultExpectation.params + mm_want_ptrs := mmName.NameMock.defaultExpectation.paramPtrs + mm_got := GenericComplexUnionMockNameParams[T]{t1} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.t1 != nil && !minimock.Equal(*mm_want_ptrs.t1, mm_got.t1) { + mmName.t.Errorf("GenericComplexUnionMock.Name got unexpected parameter t1, want: %#v, got: %#v%s\n", *mm_want_ptrs.t1, mm_got.t1, minimock.Diff(*mm_want_ptrs.t1, mm_got.t1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmName.t.Errorf("GenericComplexUnionMock.Name got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } diff --git a/tests/generic_in.go b/tests/generic_in.go index b8daf95..3fa42d5 100644 --- a/tests/generic_in.go +++ b/tests/generic_in.go @@ -51,8 +51,9 @@ type mGenericInMockName[T any] struct { // GenericInMockNameExpectation specifies expectation struct of the genericIn.Name type GenericInMockNameExpectation[T any] struct { - mock *GenericInMock[T] - params *GenericInMockNameParams[T] + mock *GenericInMock[T] + params *GenericInMockNameParams[T] + paramPtrs *GenericInMockNameParamPtrs[T] Counter uint64 } @@ -62,6 +63,11 @@ type GenericInMockNameParams[T any] struct { t1 T } +// GenericInMockNameParamPtrs contains pointers to parameters of the genericIn.Name +type GenericInMockNameParamPtrs[T any] struct { + t1 *T +} + // Expect sets up expected params for genericIn.Name func (mmName *mGenericInMockName[T]) Expect(t1 T) *mGenericInMockName[T] { if mmName.mock.funcName != nil { @@ -72,6 +78,10 @@ func (mmName *mGenericInMockName[T]) Expect(t1 T) *mGenericInMockName[T] { mmName.defaultExpectation = &GenericInMockNameExpectation[T]{} } + if mmName.defaultExpectation.paramPtrs != nil { + mmName.mock.t.Fatalf("GenericInMock.Name mock is already set by ExpectParams functions") + } + mmName.defaultExpectation.params = &GenericInMockNameParams[T]{t1} for _, e := range mmName.expectations { if minimock.Equal(e.params, mmName.defaultExpectation.params) { @@ -82,6 +92,28 @@ func (mmName *mGenericInMockName[T]) Expect(t1 T) *mGenericInMockName[T] { return mmName } +// ExpectT1Param1 sets up expected param t1 for genericIn.Name +func (mmName *mGenericInMockName[T]) ExpectT1Param1(t1 T) *mGenericInMockName[T] { + if mmName.mock.funcName != nil { + mmName.mock.t.Fatalf("GenericInMock.Name mock is already set by Set") + } + + if mmName.defaultExpectation == nil { + mmName.defaultExpectation = &GenericInMockNameExpectation[T]{} + } + + if mmName.defaultExpectation.params != nil { + mmName.mock.t.Fatalf("GenericInMock.Name mock is already set by Expect") + } + + if mmName.defaultExpectation.paramPtrs == nil { + mmName.defaultExpectation.paramPtrs = &GenericInMockNameParamPtrs[T]{} + } + mmName.defaultExpectation.paramPtrs.t1 = &t1 + + return mmName +} + // Inspect accepts an inspector function that has same arguments as the genericIn.Name func (mmName *mGenericInMockName[T]) Inspect(f func(t1 T)) *mGenericInMockName[T] { if mmName.mock.inspectFuncName != nil { @@ -146,8 +178,17 @@ func (mmName *GenericInMock[T]) Name(t1 T) { if mmName.NameMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmName.NameMock.defaultExpectation.Counter, 1) mm_want := mmName.NameMock.defaultExpectation.params + mm_want_ptrs := mmName.NameMock.defaultExpectation.paramPtrs + mm_got := GenericInMockNameParams[T]{t1} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.t1 != nil && !minimock.Equal(*mm_want_ptrs.t1, mm_got.t1) { + mmName.t.Errorf("GenericInMock.Name got unexpected parameter t1, want: %#v, got: %#v%s\n", *mm_want_ptrs.t1, mm_got.t1, minimock.Diff(*mm_want_ptrs.t1, mm_got.t1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmName.t.Errorf("GenericInMock.Name got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } diff --git a/tests/generic_inline_union.go b/tests/generic_inline_union.go index 5fb918f..e7d89e7 100644 --- a/tests/generic_inline_union.go +++ b/tests/generic_inline_union.go @@ -51,8 +51,9 @@ type mGenericInlineUnionMockName[T int | float64] struct { // GenericInlineUnionMockNameExpectation specifies expectation struct of the genericInlineUnion.Name type GenericInlineUnionMockNameExpectation[T int | float64] struct { - mock *GenericInlineUnionMock[T] - params *GenericInlineUnionMockNameParams[T] + mock *GenericInlineUnionMock[T] + params *GenericInlineUnionMockNameParams[T] + paramPtrs *GenericInlineUnionMockNameParamPtrs[T] Counter uint64 } @@ -62,6 +63,11 @@ type GenericInlineUnionMockNameParams[T int | float64] struct { t1 T } +// GenericInlineUnionMockNameParamPtrs contains pointers to parameters of the genericInlineUnion.Name +type GenericInlineUnionMockNameParamPtrs[T int | float64] struct { + t1 *T +} + // Expect sets up expected params for genericInlineUnion.Name func (mmName *mGenericInlineUnionMockName[T]) Expect(t1 T) *mGenericInlineUnionMockName[T] { if mmName.mock.funcName != nil { @@ -72,6 +78,10 @@ func (mmName *mGenericInlineUnionMockName[T]) Expect(t1 T) *mGenericInlineUnionM mmName.defaultExpectation = &GenericInlineUnionMockNameExpectation[T]{} } + if mmName.defaultExpectation.paramPtrs != nil { + mmName.mock.t.Fatalf("GenericInlineUnionMock.Name mock is already set by ExpectParams functions") + } + mmName.defaultExpectation.params = &GenericInlineUnionMockNameParams[T]{t1} for _, e := range mmName.expectations { if minimock.Equal(e.params, mmName.defaultExpectation.params) { @@ -82,6 +92,28 @@ func (mmName *mGenericInlineUnionMockName[T]) Expect(t1 T) *mGenericInlineUnionM return mmName } +// ExpectT1Param1 sets up expected param t1 for genericInlineUnion.Name +func (mmName *mGenericInlineUnionMockName[T]) ExpectT1Param1(t1 T) *mGenericInlineUnionMockName[T] { + if mmName.mock.funcName != nil { + mmName.mock.t.Fatalf("GenericInlineUnionMock.Name mock is already set by Set") + } + + if mmName.defaultExpectation == nil { + mmName.defaultExpectation = &GenericInlineUnionMockNameExpectation[T]{} + } + + if mmName.defaultExpectation.params != nil { + mmName.mock.t.Fatalf("GenericInlineUnionMock.Name mock is already set by Expect") + } + + if mmName.defaultExpectation.paramPtrs == nil { + mmName.defaultExpectation.paramPtrs = &GenericInlineUnionMockNameParamPtrs[T]{} + } + mmName.defaultExpectation.paramPtrs.t1 = &t1 + + return mmName +} + // Inspect accepts an inspector function that has same arguments as the genericInlineUnion.Name func (mmName *mGenericInlineUnionMockName[T]) Inspect(f func(t1 T)) *mGenericInlineUnionMockName[T] { if mmName.mock.inspectFuncName != nil { @@ -146,8 +178,17 @@ func (mmName *GenericInlineUnionMock[T]) Name(t1 T) { if mmName.NameMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmName.NameMock.defaultExpectation.Counter, 1) mm_want := mmName.NameMock.defaultExpectation.params + mm_want_ptrs := mmName.NameMock.defaultExpectation.paramPtrs + mm_got := GenericInlineUnionMockNameParams[T]{t1} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.t1 != nil && !minimock.Equal(*mm_want_ptrs.t1, mm_got.t1) { + mmName.t.Errorf("GenericInlineUnionMock.Name got unexpected parameter t1, want: %#v, got: %#v%s\n", *mm_want_ptrs.t1, mm_got.t1, minimock.Diff(*mm_want_ptrs.t1, mm_got.t1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmName.t.Errorf("GenericInlineUnionMock.Name got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } diff --git a/tests/generic_inout.go b/tests/generic_inout.go index 4b58742..82373c4 100644 --- a/tests/generic_inout.go +++ b/tests/generic_inout.go @@ -51,10 +51,11 @@ type mGenericInoutMockName[T any] struct { // GenericInoutMockNameExpectation specifies expectation struct of the genericInout.Name type GenericInoutMockNameExpectation[T any] struct { - mock *GenericInoutMock[T] - params *GenericInoutMockNameParams[T] - results *GenericInoutMockNameResults[T] - Counter uint64 + mock *GenericInoutMock[T] + params *GenericInoutMockNameParams[T] + paramPtrs *GenericInoutMockNameParamPtrs[T] + results *GenericInoutMockNameResults[T] + Counter uint64 } // GenericInoutMockNameParams contains parameters of the genericInout.Name @@ -62,6 +63,11 @@ type GenericInoutMockNameParams[T any] struct { t1 T } +// GenericInoutMockNameParamPtrs contains pointers to parameters of the genericInout.Name +type GenericInoutMockNameParamPtrs[T any] struct { + t1 *T +} + // GenericInoutMockNameResults contains results of the genericInout.Name type GenericInoutMockNameResults[T any] struct { t2 T @@ -77,6 +83,10 @@ func (mmName *mGenericInoutMockName[T]) Expect(t1 T) *mGenericInoutMockName[T] { mmName.defaultExpectation = &GenericInoutMockNameExpectation[T]{} } + if mmName.defaultExpectation.paramPtrs != nil { + mmName.mock.t.Fatalf("GenericInoutMock.Name mock is already set by ExpectParams functions") + } + mmName.defaultExpectation.params = &GenericInoutMockNameParams[T]{t1} for _, e := range mmName.expectations { if minimock.Equal(e.params, mmName.defaultExpectation.params) { @@ -87,6 +97,28 @@ func (mmName *mGenericInoutMockName[T]) Expect(t1 T) *mGenericInoutMockName[T] { return mmName } +// ExpectT1Param1 sets up expected param t1 for genericInout.Name +func (mmName *mGenericInoutMockName[T]) ExpectT1Param1(t1 T) *mGenericInoutMockName[T] { + if mmName.mock.funcName != nil { + mmName.mock.t.Fatalf("GenericInoutMock.Name mock is already set by Set") + } + + if mmName.defaultExpectation == nil { + mmName.defaultExpectation = &GenericInoutMockNameExpectation[T]{} + } + + if mmName.defaultExpectation.params != nil { + mmName.mock.t.Fatalf("GenericInoutMock.Name mock is already set by Expect") + } + + if mmName.defaultExpectation.paramPtrs == nil { + mmName.defaultExpectation.paramPtrs = &GenericInoutMockNameParamPtrs[T]{} + } + mmName.defaultExpectation.paramPtrs.t1 = &t1 + + return mmName +} + // Inspect accepts an inspector function that has same arguments as the genericInout.Name func (mmName *mGenericInoutMockName[T]) Inspect(f func(t1 T)) *mGenericInoutMockName[T] { if mmName.mock.inspectFuncName != nil { @@ -172,8 +204,17 @@ func (mmName *GenericInoutMock[T]) Name(t1 T) (t2 T) { if mmName.NameMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmName.NameMock.defaultExpectation.Counter, 1) mm_want := mmName.NameMock.defaultExpectation.params + mm_want_ptrs := mmName.NameMock.defaultExpectation.paramPtrs + mm_got := GenericInoutMockNameParams[T]{t1} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.t1 != nil && !minimock.Equal(*mm_want_ptrs.t1, mm_got.t1) { + mmName.t.Errorf("GenericInoutMock.Name got unexpected parameter t1, want: %#v, got: %#v%s\n", *mm_want_ptrs.t1, mm_got.t1, minimock.Diff(*mm_want_ptrs.t1, mm_got.t1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmName.t.Errorf("GenericInoutMock.Name got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } diff --git a/tests/generic_simple_union.go b/tests/generic_simple_union.go index 5aeddc3..c4542e4 100644 --- a/tests/generic_simple_union.go +++ b/tests/generic_simple_union.go @@ -51,8 +51,9 @@ type mGenericSimpleUnionMockName[T simpleUnion] struct { // GenericSimpleUnionMockNameExpectation specifies expectation struct of the genericSimpleUnion.Name type GenericSimpleUnionMockNameExpectation[T simpleUnion] struct { - mock *GenericSimpleUnionMock[T] - params *GenericSimpleUnionMockNameParams[T] + mock *GenericSimpleUnionMock[T] + params *GenericSimpleUnionMockNameParams[T] + paramPtrs *GenericSimpleUnionMockNameParamPtrs[T] Counter uint64 } @@ -62,6 +63,11 @@ type GenericSimpleUnionMockNameParams[T simpleUnion] struct { t1 T } +// GenericSimpleUnionMockNameParamPtrs contains pointers to parameters of the genericSimpleUnion.Name +type GenericSimpleUnionMockNameParamPtrs[T simpleUnion] struct { + t1 *T +} + // Expect sets up expected params for genericSimpleUnion.Name func (mmName *mGenericSimpleUnionMockName[T]) Expect(t1 T) *mGenericSimpleUnionMockName[T] { if mmName.mock.funcName != nil { @@ -72,6 +78,10 @@ func (mmName *mGenericSimpleUnionMockName[T]) Expect(t1 T) *mGenericSimpleUnionM mmName.defaultExpectation = &GenericSimpleUnionMockNameExpectation[T]{} } + if mmName.defaultExpectation.paramPtrs != nil { + mmName.mock.t.Fatalf("GenericSimpleUnionMock.Name mock is already set by ExpectParams functions") + } + mmName.defaultExpectation.params = &GenericSimpleUnionMockNameParams[T]{t1} for _, e := range mmName.expectations { if minimock.Equal(e.params, mmName.defaultExpectation.params) { @@ -82,6 +92,28 @@ func (mmName *mGenericSimpleUnionMockName[T]) Expect(t1 T) *mGenericSimpleUnionM return mmName } +// ExpectT1Param1 sets up expected param t1 for genericSimpleUnion.Name +func (mmName *mGenericSimpleUnionMockName[T]) ExpectT1Param1(t1 T) *mGenericSimpleUnionMockName[T] { + if mmName.mock.funcName != nil { + mmName.mock.t.Fatalf("GenericSimpleUnionMock.Name mock is already set by Set") + } + + if mmName.defaultExpectation == nil { + mmName.defaultExpectation = &GenericSimpleUnionMockNameExpectation[T]{} + } + + if mmName.defaultExpectation.params != nil { + mmName.mock.t.Fatalf("GenericSimpleUnionMock.Name mock is already set by Expect") + } + + if mmName.defaultExpectation.paramPtrs == nil { + mmName.defaultExpectation.paramPtrs = &GenericSimpleUnionMockNameParamPtrs[T]{} + } + mmName.defaultExpectation.paramPtrs.t1 = &t1 + + return mmName +} + // Inspect accepts an inspector function that has same arguments as the genericSimpleUnion.Name func (mmName *mGenericSimpleUnionMockName[T]) Inspect(f func(t1 T)) *mGenericSimpleUnionMockName[T] { if mmName.mock.inspectFuncName != nil { @@ -146,8 +178,17 @@ func (mmName *GenericSimpleUnionMock[T]) Name(t1 T) { if mmName.NameMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmName.NameMock.defaultExpectation.Counter, 1) mm_want := mmName.NameMock.defaultExpectation.params + mm_want_ptrs := mmName.NameMock.defaultExpectation.paramPtrs + mm_got := GenericSimpleUnionMockNameParams[T]{t1} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.t1 != nil && !minimock.Equal(*mm_want_ptrs.t1, mm_got.t1) { + mmName.t.Errorf("GenericSimpleUnionMock.Name got unexpected parameter t1, want: %#v, got: %#v%s\n", *mm_want_ptrs.t1, mm_got.t1, minimock.Diff(*mm_want_ptrs.t1, mm_got.t1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmName.t.Errorf("GenericSimpleUnionMock.Name got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } diff --git a/tests/generic_specific.go b/tests/generic_specific.go index bc8c40c..0521205 100644 --- a/tests/generic_specific.go +++ b/tests/generic_specific.go @@ -52,8 +52,9 @@ type mGenericSpecificMockName[T proto.Message] struct { // GenericSpecificMockNameExpectation specifies expectation struct of the genericSpecific.Name type GenericSpecificMockNameExpectation[T proto.Message] struct { - mock *GenericSpecificMock[T] - params *GenericSpecificMockNameParams[T] + mock *GenericSpecificMock[T] + params *GenericSpecificMockNameParams[T] + paramPtrs *GenericSpecificMockNameParamPtrs[T] Counter uint64 } @@ -63,6 +64,11 @@ type GenericSpecificMockNameParams[T proto.Message] struct { t1 T } +// GenericSpecificMockNameParamPtrs contains pointers to parameters of the genericSpecific.Name +type GenericSpecificMockNameParamPtrs[T proto.Message] struct { + t1 *T +} + // Expect sets up expected params for genericSpecific.Name func (mmName *mGenericSpecificMockName[T]) Expect(t1 T) *mGenericSpecificMockName[T] { if mmName.mock.funcName != nil { @@ -73,6 +79,10 @@ func (mmName *mGenericSpecificMockName[T]) Expect(t1 T) *mGenericSpecificMockNam mmName.defaultExpectation = &GenericSpecificMockNameExpectation[T]{} } + if mmName.defaultExpectation.paramPtrs != nil { + mmName.mock.t.Fatalf("GenericSpecificMock.Name mock is already set by ExpectParams functions") + } + mmName.defaultExpectation.params = &GenericSpecificMockNameParams[T]{t1} for _, e := range mmName.expectations { if minimock.Equal(e.params, mmName.defaultExpectation.params) { @@ -83,6 +93,28 @@ func (mmName *mGenericSpecificMockName[T]) Expect(t1 T) *mGenericSpecificMockNam return mmName } +// ExpectT1Param1 sets up expected param t1 for genericSpecific.Name +func (mmName *mGenericSpecificMockName[T]) ExpectT1Param1(t1 T) *mGenericSpecificMockName[T] { + if mmName.mock.funcName != nil { + mmName.mock.t.Fatalf("GenericSpecificMock.Name mock is already set by Set") + } + + if mmName.defaultExpectation == nil { + mmName.defaultExpectation = &GenericSpecificMockNameExpectation[T]{} + } + + if mmName.defaultExpectation.params != nil { + mmName.mock.t.Fatalf("GenericSpecificMock.Name mock is already set by Expect") + } + + if mmName.defaultExpectation.paramPtrs == nil { + mmName.defaultExpectation.paramPtrs = &GenericSpecificMockNameParamPtrs[T]{} + } + mmName.defaultExpectation.paramPtrs.t1 = &t1 + + return mmName +} + // Inspect accepts an inspector function that has same arguments as the genericSpecific.Name func (mmName *mGenericSpecificMockName[T]) Inspect(f func(t1 T)) *mGenericSpecificMockName[T] { if mmName.mock.inspectFuncName != nil { @@ -147,8 +179,17 @@ func (mmName *GenericSpecificMock[T]) Name(t1 T) { if mmName.NameMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmName.NameMock.defaultExpectation.Counter, 1) mm_want := mmName.NameMock.defaultExpectation.params + mm_want_ptrs := mmName.NameMock.defaultExpectation.paramPtrs + mm_got := GenericSpecificMockNameParams[T]{t1} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.t1 != nil && !minimock.Equal(*mm_want_ptrs.t1, mm_got.t1) { + mmName.t.Errorf("GenericSpecificMock.Name got unexpected parameter t1, want: %#v, got: %#v%s\n", *mm_want_ptrs.t1, mm_got.t1, minimock.Diff(*mm_want_ptrs.t1, mm_got.t1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmName.t.Errorf("GenericSpecificMock.Name got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } diff --git a/tests/package_name_specified_test.go b/tests/package_name_specified_test.go index 1aec510..4e7cc78 100644 --- a/tests/package_name_specified_test.go +++ b/tests/package_name_specified_test.go @@ -95,8 +95,9 @@ type mTesterMockCleanup struct { // TesterMockCleanupExpectation specifies expectation struct of the Tester.Cleanup type TesterMockCleanupExpectation struct { - mock *TesterMock - params *TesterMockCleanupParams + mock *TesterMock + params *TesterMockCleanupParams + paramPtrs *TesterMockCleanupParamPtrs Counter uint64 } @@ -106,6 +107,11 @@ type TesterMockCleanupParams struct { f func() } +// TesterMockCleanupParamPtrs contains pointers to parameters of the Tester.Cleanup +type TesterMockCleanupParamPtrs struct { + f *func() +} + // Expect sets up expected params for Tester.Cleanup func (mmCleanup *mTesterMockCleanup) Expect(f func()) *mTesterMockCleanup { if mmCleanup.mock.funcCleanup != nil { @@ -116,6 +122,10 @@ func (mmCleanup *mTesterMockCleanup) Expect(f func()) *mTesterMockCleanup { mmCleanup.defaultExpectation = &TesterMockCleanupExpectation{} } + if mmCleanup.defaultExpectation.paramPtrs != nil { + mmCleanup.mock.t.Fatalf("TesterMock.Cleanup mock is already set by ExpectParams functions") + } + mmCleanup.defaultExpectation.params = &TesterMockCleanupParams{f} for _, e := range mmCleanup.expectations { if minimock.Equal(e.params, mmCleanup.defaultExpectation.params) { @@ -126,6 +136,28 @@ func (mmCleanup *mTesterMockCleanup) Expect(f func()) *mTesterMockCleanup { return mmCleanup } +// ExpectFParam1 sets up expected param f for Tester.Cleanup +func (mmCleanup *mTesterMockCleanup) ExpectFParam1(f func()) *mTesterMockCleanup { + if mmCleanup.mock.funcCleanup != nil { + mmCleanup.mock.t.Fatalf("TesterMock.Cleanup mock is already set by Set") + } + + if mmCleanup.defaultExpectation == nil { + mmCleanup.defaultExpectation = &TesterMockCleanupExpectation{} + } + + if mmCleanup.defaultExpectation.params != nil { + mmCleanup.mock.t.Fatalf("TesterMock.Cleanup mock is already set by Expect") + } + + if mmCleanup.defaultExpectation.paramPtrs == nil { + mmCleanup.defaultExpectation.paramPtrs = &TesterMockCleanupParamPtrs{} + } + mmCleanup.defaultExpectation.paramPtrs.f = &f + + return mmCleanup +} + // Inspect accepts an inspector function that has same arguments as the Tester.Cleanup func (mmCleanup *mTesterMockCleanup) Inspect(f func(f func())) *mTesterMockCleanup { if mmCleanup.mock.inspectFuncCleanup != nil { @@ -190,8 +222,17 @@ func (mmCleanup *TesterMock) Cleanup(f func()) { if mmCleanup.CleanupMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmCleanup.CleanupMock.defaultExpectation.Counter, 1) mm_want := mmCleanup.CleanupMock.defaultExpectation.params + mm_want_ptrs := mmCleanup.CleanupMock.defaultExpectation.paramPtrs + mm_got := TesterMockCleanupParams{f} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.f != nil && !minimock.Equal(*mm_want_ptrs.f, mm_got.f) { + mmCleanup.t.Errorf("TesterMock.Cleanup got unexpected parameter f, want: %#v, got: %#v%s\n", *mm_want_ptrs.f, mm_got.f, minimock.Diff(*mm_want_ptrs.f, mm_got.f)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmCleanup.t.Errorf("TesterMock.Cleanup got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } @@ -282,8 +323,9 @@ type mTesterMockError struct { // TesterMockErrorExpectation specifies expectation struct of the Tester.Error type TesterMockErrorExpectation struct { - mock *TesterMock - params *TesterMockErrorParams + mock *TesterMock + params *TesterMockErrorParams + paramPtrs *TesterMockErrorParamPtrs Counter uint64 } @@ -293,6 +335,11 @@ type TesterMockErrorParams struct { p1 []interface{} } +// TesterMockErrorParamPtrs contains pointers to parameters of the Tester.Error +type TesterMockErrorParamPtrs struct { + p1 *[]interface{} +} + // Expect sets up expected params for Tester.Error func (mmError *mTesterMockError) Expect(p1 ...interface{}) *mTesterMockError { if mmError.mock.funcError != nil { @@ -303,6 +350,10 @@ func (mmError *mTesterMockError) Expect(p1 ...interface{}) *mTesterMockError { mmError.defaultExpectation = &TesterMockErrorExpectation{} } + if mmError.defaultExpectation.paramPtrs != nil { + mmError.mock.t.Fatalf("TesterMock.Error mock is already set by ExpectParams functions") + } + mmError.defaultExpectation.params = &TesterMockErrorParams{p1} for _, e := range mmError.expectations { if minimock.Equal(e.params, mmError.defaultExpectation.params) { @@ -313,6 +364,28 @@ func (mmError *mTesterMockError) Expect(p1 ...interface{}) *mTesterMockError { return mmError } +// ExpectP1Param1 sets up expected param p1 for Tester.Error +func (mmError *mTesterMockError) ExpectP1Param1(p1 ...interface{}) *mTesterMockError { + if mmError.mock.funcError != nil { + mmError.mock.t.Fatalf("TesterMock.Error mock is already set by Set") + } + + if mmError.defaultExpectation == nil { + mmError.defaultExpectation = &TesterMockErrorExpectation{} + } + + if mmError.defaultExpectation.params != nil { + mmError.mock.t.Fatalf("TesterMock.Error mock is already set by Expect") + } + + if mmError.defaultExpectation.paramPtrs == nil { + mmError.defaultExpectation.paramPtrs = &TesterMockErrorParamPtrs{} + } + mmError.defaultExpectation.paramPtrs.p1 = &p1 + + return mmError +} + // Inspect accepts an inspector function that has same arguments as the Tester.Error func (mmError *mTesterMockError) Inspect(f func(p1 ...interface{})) *mTesterMockError { if mmError.mock.inspectFuncError != nil { @@ -377,8 +450,17 @@ func (mmError *TesterMock) Error(p1 ...interface{}) { if mmError.ErrorMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmError.ErrorMock.defaultExpectation.Counter, 1) mm_want := mmError.ErrorMock.defaultExpectation.params + mm_want_ptrs := mmError.ErrorMock.defaultExpectation.paramPtrs + mm_got := TesterMockErrorParams{p1} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.p1 != nil && !minimock.Equal(*mm_want_ptrs.p1, mm_got.p1) { + mmError.t.Errorf("TesterMock.Error got unexpected parameter p1, want: %#v, got: %#v%s\n", *mm_want_ptrs.p1, mm_got.p1, minimock.Diff(*mm_want_ptrs.p1, mm_got.p1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmError.t.Errorf("TesterMock.Error got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } @@ -469,8 +551,9 @@ type mTesterMockErrorf struct { // TesterMockErrorfExpectation specifies expectation struct of the Tester.Errorf type TesterMockErrorfExpectation struct { - mock *TesterMock - params *TesterMockErrorfParams + mock *TesterMock + params *TesterMockErrorfParams + paramPtrs *TesterMockErrorfParamPtrs Counter uint64 } @@ -481,6 +564,12 @@ type TesterMockErrorfParams struct { args []interface{} } +// TesterMockErrorfParamPtrs contains pointers to parameters of the Tester.Errorf +type TesterMockErrorfParamPtrs struct { + format *string + args *[]interface{} +} + // Expect sets up expected params for Tester.Errorf func (mmErrorf *mTesterMockErrorf) Expect(format string, args ...interface{}) *mTesterMockErrorf { if mmErrorf.mock.funcErrorf != nil { @@ -491,6 +580,10 @@ func (mmErrorf *mTesterMockErrorf) Expect(format string, args ...interface{}) *m mmErrorf.defaultExpectation = &TesterMockErrorfExpectation{} } + if mmErrorf.defaultExpectation.paramPtrs != nil { + mmErrorf.mock.t.Fatalf("TesterMock.Errorf mock is already set by ExpectParams functions") + } + mmErrorf.defaultExpectation.params = &TesterMockErrorfParams{format, args} for _, e := range mmErrorf.expectations { if minimock.Equal(e.params, mmErrorf.defaultExpectation.params) { @@ -501,6 +594,50 @@ func (mmErrorf *mTesterMockErrorf) Expect(format string, args ...interface{}) *m return mmErrorf } +// ExpectFormatParam1 sets up expected param format for Tester.Errorf +func (mmErrorf *mTesterMockErrorf) ExpectFormatParam1(format string) *mTesterMockErrorf { + if mmErrorf.mock.funcErrorf != nil { + mmErrorf.mock.t.Fatalf("TesterMock.Errorf mock is already set by Set") + } + + if mmErrorf.defaultExpectation == nil { + mmErrorf.defaultExpectation = &TesterMockErrorfExpectation{} + } + + if mmErrorf.defaultExpectation.params != nil { + mmErrorf.mock.t.Fatalf("TesterMock.Errorf mock is already set by Expect") + } + + if mmErrorf.defaultExpectation.paramPtrs == nil { + mmErrorf.defaultExpectation.paramPtrs = &TesterMockErrorfParamPtrs{} + } + mmErrorf.defaultExpectation.paramPtrs.format = &format + + return mmErrorf +} + +// ExpectArgsParam2 sets up expected param args for Tester.Errorf +func (mmErrorf *mTesterMockErrorf) ExpectArgsParam2(args ...interface{}) *mTesterMockErrorf { + if mmErrorf.mock.funcErrorf != nil { + mmErrorf.mock.t.Fatalf("TesterMock.Errorf mock is already set by Set") + } + + if mmErrorf.defaultExpectation == nil { + mmErrorf.defaultExpectation = &TesterMockErrorfExpectation{} + } + + if mmErrorf.defaultExpectation.params != nil { + mmErrorf.mock.t.Fatalf("TesterMock.Errorf mock is already set by Expect") + } + + if mmErrorf.defaultExpectation.paramPtrs == nil { + mmErrorf.defaultExpectation.paramPtrs = &TesterMockErrorfParamPtrs{} + } + mmErrorf.defaultExpectation.paramPtrs.args = &args + + return mmErrorf +} + // Inspect accepts an inspector function that has same arguments as the Tester.Errorf func (mmErrorf *mTesterMockErrorf) Inspect(f func(format string, args ...interface{})) *mTesterMockErrorf { if mmErrorf.mock.inspectFuncErrorf != nil { @@ -565,8 +702,21 @@ func (mmErrorf *TesterMock) Errorf(format string, args ...interface{}) { if mmErrorf.ErrorfMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmErrorf.ErrorfMock.defaultExpectation.Counter, 1) mm_want := mmErrorf.ErrorfMock.defaultExpectation.params + mm_want_ptrs := mmErrorf.ErrorfMock.defaultExpectation.paramPtrs + mm_got := TesterMockErrorfParams{format, args} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.format != nil && !minimock.Equal(*mm_want_ptrs.format, mm_got.format) { + mmErrorf.t.Errorf("TesterMock.Errorf got unexpected parameter format, want: %#v, got: %#v%s\n", *mm_want_ptrs.format, mm_got.format, minimock.Diff(*mm_want_ptrs.format, mm_got.format)) + } + + if mm_want_ptrs.args != nil && !minimock.Equal(*mm_want_ptrs.args, mm_got.args) { + mmErrorf.t.Errorf("TesterMock.Errorf got unexpected parameter args, want: %#v, got: %#v%s\n", *mm_want_ptrs.args, mm_got.args, minimock.Diff(*mm_want_ptrs.args, mm_got.args)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmErrorf.t.Errorf("TesterMock.Errorf got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } @@ -792,8 +942,9 @@ type mTesterMockFatal struct { // TesterMockFatalExpectation specifies expectation struct of the Tester.Fatal type TesterMockFatalExpectation struct { - mock *TesterMock - params *TesterMockFatalParams + mock *TesterMock + params *TesterMockFatalParams + paramPtrs *TesterMockFatalParamPtrs Counter uint64 } @@ -803,6 +954,11 @@ type TesterMockFatalParams struct { args []interface{} } +// TesterMockFatalParamPtrs contains pointers to parameters of the Tester.Fatal +type TesterMockFatalParamPtrs struct { + args *[]interface{} +} + // Expect sets up expected params for Tester.Fatal func (mmFatal *mTesterMockFatal) Expect(args ...interface{}) *mTesterMockFatal { if mmFatal.mock.funcFatal != nil { @@ -813,6 +969,10 @@ func (mmFatal *mTesterMockFatal) Expect(args ...interface{}) *mTesterMockFatal { mmFatal.defaultExpectation = &TesterMockFatalExpectation{} } + if mmFatal.defaultExpectation.paramPtrs != nil { + mmFatal.mock.t.Fatalf("TesterMock.Fatal mock is already set by ExpectParams functions") + } + mmFatal.defaultExpectation.params = &TesterMockFatalParams{args} for _, e := range mmFatal.expectations { if minimock.Equal(e.params, mmFatal.defaultExpectation.params) { @@ -823,6 +983,28 @@ func (mmFatal *mTesterMockFatal) Expect(args ...interface{}) *mTesterMockFatal { return mmFatal } +// ExpectArgsParam1 sets up expected param args for Tester.Fatal +func (mmFatal *mTesterMockFatal) ExpectArgsParam1(args ...interface{}) *mTesterMockFatal { + if mmFatal.mock.funcFatal != nil { + mmFatal.mock.t.Fatalf("TesterMock.Fatal mock is already set by Set") + } + + if mmFatal.defaultExpectation == nil { + mmFatal.defaultExpectation = &TesterMockFatalExpectation{} + } + + if mmFatal.defaultExpectation.params != nil { + mmFatal.mock.t.Fatalf("TesterMock.Fatal mock is already set by Expect") + } + + if mmFatal.defaultExpectation.paramPtrs == nil { + mmFatal.defaultExpectation.paramPtrs = &TesterMockFatalParamPtrs{} + } + mmFatal.defaultExpectation.paramPtrs.args = &args + + return mmFatal +} + // Inspect accepts an inspector function that has same arguments as the Tester.Fatal func (mmFatal *mTesterMockFatal) Inspect(f func(args ...interface{})) *mTesterMockFatal { if mmFatal.mock.inspectFuncFatal != nil { @@ -887,8 +1069,17 @@ func (mmFatal *TesterMock) Fatal(args ...interface{}) { if mmFatal.FatalMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmFatal.FatalMock.defaultExpectation.Counter, 1) mm_want := mmFatal.FatalMock.defaultExpectation.params + mm_want_ptrs := mmFatal.FatalMock.defaultExpectation.paramPtrs + mm_got := TesterMockFatalParams{args} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.args != nil && !minimock.Equal(*mm_want_ptrs.args, mm_got.args) { + mmFatal.t.Errorf("TesterMock.Fatal got unexpected parameter args, want: %#v, got: %#v%s\n", *mm_want_ptrs.args, mm_got.args, minimock.Diff(*mm_want_ptrs.args, mm_got.args)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmFatal.t.Errorf("TesterMock.Fatal got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } @@ -979,8 +1170,9 @@ type mTesterMockFatalf struct { // TesterMockFatalfExpectation specifies expectation struct of the Tester.Fatalf type TesterMockFatalfExpectation struct { - mock *TesterMock - params *TesterMockFatalfParams + mock *TesterMock + params *TesterMockFatalfParams + paramPtrs *TesterMockFatalfParamPtrs Counter uint64 } @@ -991,6 +1183,12 @@ type TesterMockFatalfParams struct { args []interface{} } +// TesterMockFatalfParamPtrs contains pointers to parameters of the Tester.Fatalf +type TesterMockFatalfParamPtrs struct { + format *string + args *[]interface{} +} + // Expect sets up expected params for Tester.Fatalf func (mmFatalf *mTesterMockFatalf) Expect(format string, args ...interface{}) *mTesterMockFatalf { if mmFatalf.mock.funcFatalf != nil { @@ -1001,6 +1199,10 @@ func (mmFatalf *mTesterMockFatalf) Expect(format string, args ...interface{}) *m mmFatalf.defaultExpectation = &TesterMockFatalfExpectation{} } + if mmFatalf.defaultExpectation.paramPtrs != nil { + mmFatalf.mock.t.Fatalf("TesterMock.Fatalf mock is already set by ExpectParams functions") + } + mmFatalf.defaultExpectation.params = &TesterMockFatalfParams{format, args} for _, e := range mmFatalf.expectations { if minimock.Equal(e.params, mmFatalf.defaultExpectation.params) { @@ -1011,6 +1213,50 @@ func (mmFatalf *mTesterMockFatalf) Expect(format string, args ...interface{}) *m return mmFatalf } +// ExpectFormatParam1 sets up expected param format for Tester.Fatalf +func (mmFatalf *mTesterMockFatalf) ExpectFormatParam1(format string) *mTesterMockFatalf { + if mmFatalf.mock.funcFatalf != nil { + mmFatalf.mock.t.Fatalf("TesterMock.Fatalf mock is already set by Set") + } + + if mmFatalf.defaultExpectation == nil { + mmFatalf.defaultExpectation = &TesterMockFatalfExpectation{} + } + + if mmFatalf.defaultExpectation.params != nil { + mmFatalf.mock.t.Fatalf("TesterMock.Fatalf mock is already set by Expect") + } + + if mmFatalf.defaultExpectation.paramPtrs == nil { + mmFatalf.defaultExpectation.paramPtrs = &TesterMockFatalfParamPtrs{} + } + mmFatalf.defaultExpectation.paramPtrs.format = &format + + return mmFatalf +} + +// ExpectArgsParam2 sets up expected param args for Tester.Fatalf +func (mmFatalf *mTesterMockFatalf) ExpectArgsParam2(args ...interface{}) *mTesterMockFatalf { + if mmFatalf.mock.funcFatalf != nil { + mmFatalf.mock.t.Fatalf("TesterMock.Fatalf mock is already set by Set") + } + + if mmFatalf.defaultExpectation == nil { + mmFatalf.defaultExpectation = &TesterMockFatalfExpectation{} + } + + if mmFatalf.defaultExpectation.params != nil { + mmFatalf.mock.t.Fatalf("TesterMock.Fatalf mock is already set by Expect") + } + + if mmFatalf.defaultExpectation.paramPtrs == nil { + mmFatalf.defaultExpectation.paramPtrs = &TesterMockFatalfParamPtrs{} + } + mmFatalf.defaultExpectation.paramPtrs.args = &args + + return mmFatalf +} + // Inspect accepts an inspector function that has same arguments as the Tester.Fatalf func (mmFatalf *mTesterMockFatalf) Inspect(f func(format string, args ...interface{})) *mTesterMockFatalf { if mmFatalf.mock.inspectFuncFatalf != nil { @@ -1075,8 +1321,21 @@ func (mmFatalf *TesterMock) Fatalf(format string, args ...interface{}) { if mmFatalf.FatalfMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmFatalf.FatalfMock.defaultExpectation.Counter, 1) mm_want := mmFatalf.FatalfMock.defaultExpectation.params + mm_want_ptrs := mmFatalf.FatalfMock.defaultExpectation.paramPtrs + mm_got := TesterMockFatalfParams{format, args} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.format != nil && !minimock.Equal(*mm_want_ptrs.format, mm_got.format) { + mmFatalf.t.Errorf("TesterMock.Fatalf got unexpected parameter format, want: %#v, got: %#v%s\n", *mm_want_ptrs.format, mm_got.format, minimock.Diff(*mm_want_ptrs.format, mm_got.format)) + } + + if mm_want_ptrs.args != nil && !minimock.Equal(*mm_want_ptrs.args, mm_got.args) { + mmFatalf.t.Errorf("TesterMock.Fatalf got unexpected parameter args, want: %#v, got: %#v%s\n", *mm_want_ptrs.args, mm_got.args, minimock.Diff(*mm_want_ptrs.args, mm_got.args)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmFatalf.t.Errorf("TesterMock.Fatalf got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } diff --git a/tests/tester_mock_test.go b/tests/tester_mock_test.go index dcf6af9..64ad480 100644 --- a/tests/tester_mock_test.go +++ b/tests/tester_mock_test.go @@ -95,8 +95,9 @@ type mTesterMockCleanup struct { // TesterMockCleanupExpectation specifies expectation struct of the Tester.Cleanup type TesterMockCleanupExpectation struct { - mock *TesterMock - params *TesterMockCleanupParams + mock *TesterMock + params *TesterMockCleanupParams + paramPtrs *TesterMockCleanupParamPtrs Counter uint64 } @@ -106,6 +107,11 @@ type TesterMockCleanupParams struct { f func() } +// TesterMockCleanupParamPtrs contains pointers to parameters of the Tester.Cleanup +type TesterMockCleanupParamPtrs struct { + f *func() +} + // Expect sets up expected params for Tester.Cleanup func (mmCleanup *mTesterMockCleanup) Expect(f func()) *mTesterMockCleanup { if mmCleanup.mock.funcCleanup != nil { @@ -116,6 +122,10 @@ func (mmCleanup *mTesterMockCleanup) Expect(f func()) *mTesterMockCleanup { mmCleanup.defaultExpectation = &TesterMockCleanupExpectation{} } + if mmCleanup.defaultExpectation.paramPtrs != nil { + mmCleanup.mock.t.Fatalf("TesterMock.Cleanup mock is already set by ExpectParams functions") + } + mmCleanup.defaultExpectation.params = &TesterMockCleanupParams{f} for _, e := range mmCleanup.expectations { if minimock.Equal(e.params, mmCleanup.defaultExpectation.params) { @@ -126,6 +136,28 @@ func (mmCleanup *mTesterMockCleanup) Expect(f func()) *mTesterMockCleanup { return mmCleanup } +// ExpectFParam1 sets up expected param f for Tester.Cleanup +func (mmCleanup *mTesterMockCleanup) ExpectFParam1(f func()) *mTesterMockCleanup { + if mmCleanup.mock.funcCleanup != nil { + mmCleanup.mock.t.Fatalf("TesterMock.Cleanup mock is already set by Set") + } + + if mmCleanup.defaultExpectation == nil { + mmCleanup.defaultExpectation = &TesterMockCleanupExpectation{} + } + + if mmCleanup.defaultExpectation.params != nil { + mmCleanup.mock.t.Fatalf("TesterMock.Cleanup mock is already set by Expect") + } + + if mmCleanup.defaultExpectation.paramPtrs == nil { + mmCleanup.defaultExpectation.paramPtrs = &TesterMockCleanupParamPtrs{} + } + mmCleanup.defaultExpectation.paramPtrs.f = &f + + return mmCleanup +} + // Inspect accepts an inspector function that has same arguments as the Tester.Cleanup func (mmCleanup *mTesterMockCleanup) Inspect(f func(f func())) *mTesterMockCleanup { if mmCleanup.mock.inspectFuncCleanup != nil { @@ -190,8 +222,17 @@ func (mmCleanup *TesterMock) Cleanup(f func()) { if mmCleanup.CleanupMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmCleanup.CleanupMock.defaultExpectation.Counter, 1) mm_want := mmCleanup.CleanupMock.defaultExpectation.params + mm_want_ptrs := mmCleanup.CleanupMock.defaultExpectation.paramPtrs + mm_got := TesterMockCleanupParams{f} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.f != nil && !minimock.Equal(*mm_want_ptrs.f, mm_got.f) { + mmCleanup.t.Errorf("TesterMock.Cleanup got unexpected parameter f, want: %#v, got: %#v%s\n", *mm_want_ptrs.f, mm_got.f, minimock.Diff(*mm_want_ptrs.f, mm_got.f)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmCleanup.t.Errorf("TesterMock.Cleanup got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } @@ -282,8 +323,9 @@ type mTesterMockError struct { // TesterMockErrorExpectation specifies expectation struct of the Tester.Error type TesterMockErrorExpectation struct { - mock *TesterMock - params *TesterMockErrorParams + mock *TesterMock + params *TesterMockErrorParams + paramPtrs *TesterMockErrorParamPtrs Counter uint64 } @@ -293,6 +335,11 @@ type TesterMockErrorParams struct { p1 []interface{} } +// TesterMockErrorParamPtrs contains pointers to parameters of the Tester.Error +type TesterMockErrorParamPtrs struct { + p1 *[]interface{} +} + // Expect sets up expected params for Tester.Error func (mmError *mTesterMockError) Expect(p1 ...interface{}) *mTesterMockError { if mmError.mock.funcError != nil { @@ -303,6 +350,10 @@ func (mmError *mTesterMockError) Expect(p1 ...interface{}) *mTesterMockError { mmError.defaultExpectation = &TesterMockErrorExpectation{} } + if mmError.defaultExpectation.paramPtrs != nil { + mmError.mock.t.Fatalf("TesterMock.Error mock is already set by ExpectParams functions") + } + mmError.defaultExpectation.params = &TesterMockErrorParams{p1} for _, e := range mmError.expectations { if minimock.Equal(e.params, mmError.defaultExpectation.params) { @@ -313,6 +364,28 @@ func (mmError *mTesterMockError) Expect(p1 ...interface{}) *mTesterMockError { return mmError } +// ExpectP1Param1 sets up expected param p1 for Tester.Error +func (mmError *mTesterMockError) ExpectP1Param1(p1 ...interface{}) *mTesterMockError { + if mmError.mock.funcError != nil { + mmError.mock.t.Fatalf("TesterMock.Error mock is already set by Set") + } + + if mmError.defaultExpectation == nil { + mmError.defaultExpectation = &TesterMockErrorExpectation{} + } + + if mmError.defaultExpectation.params != nil { + mmError.mock.t.Fatalf("TesterMock.Error mock is already set by Expect") + } + + if mmError.defaultExpectation.paramPtrs == nil { + mmError.defaultExpectation.paramPtrs = &TesterMockErrorParamPtrs{} + } + mmError.defaultExpectation.paramPtrs.p1 = &p1 + + return mmError +} + // Inspect accepts an inspector function that has same arguments as the Tester.Error func (mmError *mTesterMockError) Inspect(f func(p1 ...interface{})) *mTesterMockError { if mmError.mock.inspectFuncError != nil { @@ -377,8 +450,17 @@ func (mmError *TesterMock) Error(p1 ...interface{}) { if mmError.ErrorMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmError.ErrorMock.defaultExpectation.Counter, 1) mm_want := mmError.ErrorMock.defaultExpectation.params + mm_want_ptrs := mmError.ErrorMock.defaultExpectation.paramPtrs + mm_got := TesterMockErrorParams{p1} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.p1 != nil && !minimock.Equal(*mm_want_ptrs.p1, mm_got.p1) { + mmError.t.Errorf("TesterMock.Error got unexpected parameter p1, want: %#v, got: %#v%s\n", *mm_want_ptrs.p1, mm_got.p1, minimock.Diff(*mm_want_ptrs.p1, mm_got.p1)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmError.t.Errorf("TesterMock.Error got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } @@ -469,8 +551,9 @@ type mTesterMockErrorf struct { // TesterMockErrorfExpectation specifies expectation struct of the Tester.Errorf type TesterMockErrorfExpectation struct { - mock *TesterMock - params *TesterMockErrorfParams + mock *TesterMock + params *TesterMockErrorfParams + paramPtrs *TesterMockErrorfParamPtrs Counter uint64 } @@ -481,6 +564,12 @@ type TesterMockErrorfParams struct { args []interface{} } +// TesterMockErrorfParamPtrs contains pointers to parameters of the Tester.Errorf +type TesterMockErrorfParamPtrs struct { + format *string + args *[]interface{} +} + // Expect sets up expected params for Tester.Errorf func (mmErrorf *mTesterMockErrorf) Expect(format string, args ...interface{}) *mTesterMockErrorf { if mmErrorf.mock.funcErrorf != nil { @@ -491,6 +580,10 @@ func (mmErrorf *mTesterMockErrorf) Expect(format string, args ...interface{}) *m mmErrorf.defaultExpectation = &TesterMockErrorfExpectation{} } + if mmErrorf.defaultExpectation.paramPtrs != nil { + mmErrorf.mock.t.Fatalf("TesterMock.Errorf mock is already set by ExpectParams functions") + } + mmErrorf.defaultExpectation.params = &TesterMockErrorfParams{format, args} for _, e := range mmErrorf.expectations { if minimock.Equal(e.params, mmErrorf.defaultExpectation.params) { @@ -501,6 +594,50 @@ func (mmErrorf *mTesterMockErrorf) Expect(format string, args ...interface{}) *m return mmErrorf } +// ExpectFormatParam1 sets up expected param format for Tester.Errorf +func (mmErrorf *mTesterMockErrorf) ExpectFormatParam1(format string) *mTesterMockErrorf { + if mmErrorf.mock.funcErrorf != nil { + mmErrorf.mock.t.Fatalf("TesterMock.Errorf mock is already set by Set") + } + + if mmErrorf.defaultExpectation == nil { + mmErrorf.defaultExpectation = &TesterMockErrorfExpectation{} + } + + if mmErrorf.defaultExpectation.params != nil { + mmErrorf.mock.t.Fatalf("TesterMock.Errorf mock is already set by Expect") + } + + if mmErrorf.defaultExpectation.paramPtrs == nil { + mmErrorf.defaultExpectation.paramPtrs = &TesterMockErrorfParamPtrs{} + } + mmErrorf.defaultExpectation.paramPtrs.format = &format + + return mmErrorf +} + +// ExpectArgsParam2 sets up expected param args for Tester.Errorf +func (mmErrorf *mTesterMockErrorf) ExpectArgsParam2(args ...interface{}) *mTesterMockErrorf { + if mmErrorf.mock.funcErrorf != nil { + mmErrorf.mock.t.Fatalf("TesterMock.Errorf mock is already set by Set") + } + + if mmErrorf.defaultExpectation == nil { + mmErrorf.defaultExpectation = &TesterMockErrorfExpectation{} + } + + if mmErrorf.defaultExpectation.params != nil { + mmErrorf.mock.t.Fatalf("TesterMock.Errorf mock is already set by Expect") + } + + if mmErrorf.defaultExpectation.paramPtrs == nil { + mmErrorf.defaultExpectation.paramPtrs = &TesterMockErrorfParamPtrs{} + } + mmErrorf.defaultExpectation.paramPtrs.args = &args + + return mmErrorf +} + // Inspect accepts an inspector function that has same arguments as the Tester.Errorf func (mmErrorf *mTesterMockErrorf) Inspect(f func(format string, args ...interface{})) *mTesterMockErrorf { if mmErrorf.mock.inspectFuncErrorf != nil { @@ -565,8 +702,21 @@ func (mmErrorf *TesterMock) Errorf(format string, args ...interface{}) { if mmErrorf.ErrorfMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmErrorf.ErrorfMock.defaultExpectation.Counter, 1) mm_want := mmErrorf.ErrorfMock.defaultExpectation.params + mm_want_ptrs := mmErrorf.ErrorfMock.defaultExpectation.paramPtrs + mm_got := TesterMockErrorfParams{format, args} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.format != nil && !minimock.Equal(*mm_want_ptrs.format, mm_got.format) { + mmErrorf.t.Errorf("TesterMock.Errorf got unexpected parameter format, want: %#v, got: %#v%s\n", *mm_want_ptrs.format, mm_got.format, minimock.Diff(*mm_want_ptrs.format, mm_got.format)) + } + + if mm_want_ptrs.args != nil && !minimock.Equal(*mm_want_ptrs.args, mm_got.args) { + mmErrorf.t.Errorf("TesterMock.Errorf got unexpected parameter args, want: %#v, got: %#v%s\n", *mm_want_ptrs.args, mm_got.args, minimock.Diff(*mm_want_ptrs.args, mm_got.args)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmErrorf.t.Errorf("TesterMock.Errorf got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } @@ -792,8 +942,9 @@ type mTesterMockFatal struct { // TesterMockFatalExpectation specifies expectation struct of the Tester.Fatal type TesterMockFatalExpectation struct { - mock *TesterMock - params *TesterMockFatalParams + mock *TesterMock + params *TesterMockFatalParams + paramPtrs *TesterMockFatalParamPtrs Counter uint64 } @@ -803,6 +954,11 @@ type TesterMockFatalParams struct { args []interface{} } +// TesterMockFatalParamPtrs contains pointers to parameters of the Tester.Fatal +type TesterMockFatalParamPtrs struct { + args *[]interface{} +} + // Expect sets up expected params for Tester.Fatal func (mmFatal *mTesterMockFatal) Expect(args ...interface{}) *mTesterMockFatal { if mmFatal.mock.funcFatal != nil { @@ -813,6 +969,10 @@ func (mmFatal *mTesterMockFatal) Expect(args ...interface{}) *mTesterMockFatal { mmFatal.defaultExpectation = &TesterMockFatalExpectation{} } + if mmFatal.defaultExpectation.paramPtrs != nil { + mmFatal.mock.t.Fatalf("TesterMock.Fatal mock is already set by ExpectParams functions") + } + mmFatal.defaultExpectation.params = &TesterMockFatalParams{args} for _, e := range mmFatal.expectations { if minimock.Equal(e.params, mmFatal.defaultExpectation.params) { @@ -823,6 +983,28 @@ func (mmFatal *mTesterMockFatal) Expect(args ...interface{}) *mTesterMockFatal { return mmFatal } +// ExpectArgsParam1 sets up expected param args for Tester.Fatal +func (mmFatal *mTesterMockFatal) ExpectArgsParam1(args ...interface{}) *mTesterMockFatal { + if mmFatal.mock.funcFatal != nil { + mmFatal.mock.t.Fatalf("TesterMock.Fatal mock is already set by Set") + } + + if mmFatal.defaultExpectation == nil { + mmFatal.defaultExpectation = &TesterMockFatalExpectation{} + } + + if mmFatal.defaultExpectation.params != nil { + mmFatal.mock.t.Fatalf("TesterMock.Fatal mock is already set by Expect") + } + + if mmFatal.defaultExpectation.paramPtrs == nil { + mmFatal.defaultExpectation.paramPtrs = &TesterMockFatalParamPtrs{} + } + mmFatal.defaultExpectation.paramPtrs.args = &args + + return mmFatal +} + // Inspect accepts an inspector function that has same arguments as the Tester.Fatal func (mmFatal *mTesterMockFatal) Inspect(f func(args ...interface{})) *mTesterMockFatal { if mmFatal.mock.inspectFuncFatal != nil { @@ -887,8 +1069,17 @@ func (mmFatal *TesterMock) Fatal(args ...interface{}) { if mmFatal.FatalMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmFatal.FatalMock.defaultExpectation.Counter, 1) mm_want := mmFatal.FatalMock.defaultExpectation.params + mm_want_ptrs := mmFatal.FatalMock.defaultExpectation.paramPtrs + mm_got := TesterMockFatalParams{args} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.args != nil && !minimock.Equal(*mm_want_ptrs.args, mm_got.args) { + mmFatal.t.Errorf("TesterMock.Fatal got unexpected parameter args, want: %#v, got: %#v%s\n", *mm_want_ptrs.args, mm_got.args, minimock.Diff(*mm_want_ptrs.args, mm_got.args)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmFatal.t.Errorf("TesterMock.Fatal got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } @@ -979,8 +1170,9 @@ type mTesterMockFatalf struct { // TesterMockFatalfExpectation specifies expectation struct of the Tester.Fatalf type TesterMockFatalfExpectation struct { - mock *TesterMock - params *TesterMockFatalfParams + mock *TesterMock + params *TesterMockFatalfParams + paramPtrs *TesterMockFatalfParamPtrs Counter uint64 } @@ -991,6 +1183,12 @@ type TesterMockFatalfParams struct { args []interface{} } +// TesterMockFatalfParamPtrs contains pointers to parameters of the Tester.Fatalf +type TesterMockFatalfParamPtrs struct { + format *string + args *[]interface{} +} + // Expect sets up expected params for Tester.Fatalf func (mmFatalf *mTesterMockFatalf) Expect(format string, args ...interface{}) *mTesterMockFatalf { if mmFatalf.mock.funcFatalf != nil { @@ -1001,6 +1199,10 @@ func (mmFatalf *mTesterMockFatalf) Expect(format string, args ...interface{}) *m mmFatalf.defaultExpectation = &TesterMockFatalfExpectation{} } + if mmFatalf.defaultExpectation.paramPtrs != nil { + mmFatalf.mock.t.Fatalf("TesterMock.Fatalf mock is already set by ExpectParams functions") + } + mmFatalf.defaultExpectation.params = &TesterMockFatalfParams{format, args} for _, e := range mmFatalf.expectations { if minimock.Equal(e.params, mmFatalf.defaultExpectation.params) { @@ -1011,6 +1213,50 @@ func (mmFatalf *mTesterMockFatalf) Expect(format string, args ...interface{}) *m return mmFatalf } +// ExpectFormatParam1 sets up expected param format for Tester.Fatalf +func (mmFatalf *mTesterMockFatalf) ExpectFormatParam1(format string) *mTesterMockFatalf { + if mmFatalf.mock.funcFatalf != nil { + mmFatalf.mock.t.Fatalf("TesterMock.Fatalf mock is already set by Set") + } + + if mmFatalf.defaultExpectation == nil { + mmFatalf.defaultExpectation = &TesterMockFatalfExpectation{} + } + + if mmFatalf.defaultExpectation.params != nil { + mmFatalf.mock.t.Fatalf("TesterMock.Fatalf mock is already set by Expect") + } + + if mmFatalf.defaultExpectation.paramPtrs == nil { + mmFatalf.defaultExpectation.paramPtrs = &TesterMockFatalfParamPtrs{} + } + mmFatalf.defaultExpectation.paramPtrs.format = &format + + return mmFatalf +} + +// ExpectArgsParam2 sets up expected param args for Tester.Fatalf +func (mmFatalf *mTesterMockFatalf) ExpectArgsParam2(args ...interface{}) *mTesterMockFatalf { + if mmFatalf.mock.funcFatalf != nil { + mmFatalf.mock.t.Fatalf("TesterMock.Fatalf mock is already set by Set") + } + + if mmFatalf.defaultExpectation == nil { + mmFatalf.defaultExpectation = &TesterMockFatalfExpectation{} + } + + if mmFatalf.defaultExpectation.params != nil { + mmFatalf.mock.t.Fatalf("TesterMock.Fatalf mock is already set by Expect") + } + + if mmFatalf.defaultExpectation.paramPtrs == nil { + mmFatalf.defaultExpectation.paramPtrs = &TesterMockFatalfParamPtrs{} + } + mmFatalf.defaultExpectation.paramPtrs.args = &args + + return mmFatalf +} + // Inspect accepts an inspector function that has same arguments as the Tester.Fatalf func (mmFatalf *mTesterMockFatalf) Inspect(f func(format string, args ...interface{})) *mTesterMockFatalf { if mmFatalf.mock.inspectFuncFatalf != nil { @@ -1075,8 +1321,21 @@ func (mmFatalf *TesterMock) Fatalf(format string, args ...interface{}) { if mmFatalf.FatalfMock.defaultExpectation != nil { mm_atomic.AddUint64(&mmFatalf.FatalfMock.defaultExpectation.Counter, 1) mm_want := mmFatalf.FatalfMock.defaultExpectation.params + mm_want_ptrs := mmFatalf.FatalfMock.defaultExpectation.paramPtrs + mm_got := TesterMockFatalfParams{format, args} - if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { + + if mm_want_ptrs != nil { + + if mm_want_ptrs.format != nil && !minimock.Equal(*mm_want_ptrs.format, mm_got.format) { + mmFatalf.t.Errorf("TesterMock.Fatalf got unexpected parameter format, want: %#v, got: %#v%s\n", *mm_want_ptrs.format, mm_got.format, minimock.Diff(*mm_want_ptrs.format, mm_got.format)) + } + + if mm_want_ptrs.args != nil && !minimock.Equal(*mm_want_ptrs.args, mm_got.args) { + mmFatalf.t.Errorf("TesterMock.Fatalf got unexpected parameter args, want: %#v, got: %#v%s\n", *mm_want_ptrs.args, mm_got.args, minimock.Diff(*mm_want_ptrs.args, mm_got.args)) + } + + } else if mm_want != nil && !minimock.Equal(*mm_want, mm_got) { mmFatalf.t.Errorf("TesterMock.Fatalf got unexpected parameters, want: %#v, got: %#v%s\n", *mm_want, mm_got, minimock.Diff(*mm_want, mm_got)) } diff --git a/tests/types.go b/tests/types.go index 35e2eb3..e6d423e 100644 --- a/tests/types.go +++ b/tests/types.go @@ -72,4 +72,8 @@ type ( AcceptContext(context.Context) AcceptContextWithOtherArgs(context.Context, int) (int, error) } + + actor interface { + Action(firstParam string, secondParam int) (int, error) + } )