From 110ff944b1f5264ecd143bace94144f150835554 Mon Sep 17 00:00:00 2001 From: LandonTClipp <11232769+LandonTClipp@users.noreply.github.com> Date: Thu, 2 Jan 2025 00:27:41 -0600 Subject: [PATCH] Add docs/examples etc. --- .mockery.yaml | 13 +- .mockery_moq.yaml | 22 +- Taskfile.yml | 2 +- docs/templates.md | 315 + mkdocs.yml | 1 + .../vektra/mockery/v3/pkg/fixtures/A_mock.go | 101 - .../v3/pkg/fixtures/AsyncProducer_mock.go | 197 - .../mockery/v3/pkg/fixtures/Blank_mock.go | 92 - .../v3/pkg/fixtures/ConsulLock_mock.go | 153 - .../v3/pkg/fixtures/EmbeddedGet_mock.go | 94 - .../mockery/v3/pkg/fixtures/Example_mock.go | 198 - .../ExpecterAndRolledVariadic_mock.go | 318 - .../mockery/v3/pkg/fixtures/Expecter_mock.go | 320 - .../mockery/v3/pkg/fixtures/Fooer_mock.go | 183 - .../v3/pkg/fixtures/FuncArgsCollision_mock.go | 92 - .../v3/pkg/fixtures/GenericInterface_mock.go | 92 - .../v3/pkg/fixtures/GetGeneric_mock.go | 94 - .../mockery/v3/pkg/fixtures/GetInt_mock.go | 91 - .../HasConflictingNestedImports_mock.go | 153 - .../pkg/fixtures/ImportsSameAsPackage_mock.go | 183 - .../InstantiatedGenericInterface_mock.go | 92 - .../mockery/v3/pkg/fixtures/Issue766_mock.go | 103 - .../v3/pkg/fixtures/KeyManager_mock.go | 107 - .../mockery/v3/pkg/fixtures/MapFunc_mock.go | 92 - .../v3/pkg/fixtures/MapToInterface_mock.go | 89 - .../mockery/v3/pkg/fixtures/MyReader_mock.go | 101 - .../pkg/fixtures/PanicOnNoReturnValue_mock.go | 91 - .../pkg/fixtures/ReplaceGenericSelf_mock.go | 93 - .../v3/pkg/fixtures/ReplaceGeneric_mock.go | 199 - .../v3/pkg/fixtures/Requester2_mock.go | 92 - .../v3/pkg/fixtures/Requester3_mock.go | 91 - .../v3/pkg/fixtures/Requester4_mock.go | 78 - .../fixtures/RequesterArgSameAsImport_mock.go | 95 - .../RequesterArgSameAsNamedImport_mock.go | 95 - .../fixtures/RequesterArgSameAsPkg_mock.go | 79 - .../v3/pkg/fixtures/RequesterArray_mock.go | 103 - .../v3/pkg/fixtures/RequesterElided_mock.go | 93 - .../v3/pkg/fixtures/RequesterGenerics_mock.go | 211 - .../v3/pkg/fixtures/RequesterIface_mock.go | 94 - .../v3/pkg/fixtures/RequesterNS_mock.go | 102 - .../v3/pkg/fixtures/RequesterPtr_mock.go | 103 - .../fixtures/RequesterReturnElided_mock.go | 173 - .../v3/pkg/fixtures/RequesterSlice_mock.go | 103 - .../RequesterVariadicOneArgument_mock.go | 292 - .../v3/pkg/fixtures/RequesterVariadic_mock.go | 296 - .../mockery/v3/pkg/fixtures/Requester_mock.go | 101 - .../mockery/v3/pkg/fixtures/Sibling_mock.go | 78 - .../v3/pkg/fixtures/StructWithTag_mock.go | 94 - .../v3/pkg/fixtures/UnsafeInterface_mock.go | 80 - .../mockery/v3/pkg/fixtures/UsesAny_mock.go | 93 - .../v3/pkg/fixtures/UsesOtherPkgIface_mock.go | 80 - .../VariadicNoReturnInterface_mock.go | 90 - .../pkg/fixtures/VariadicReturnFunc_mock.go | 94 - .../mockery/v3/pkg/fixtures/Variadic_mock.go | 94 - .../pkg/fixtures/requesterUnexported_mock.go | 78 - .../mockery/v3/pkg/fixtures/moq_test.go | 4530 ------------- pkg/fixtures/mocks.go | 5706 +++++++++++++++++ pkg/fixtures/mocks_moq.go | 74 + pkg/fixtures/panic_err_test.go | 6 +- pkg/fixtures/requester_test.go | 58 + 60 files changed, 6174 insertions(+), 10863 deletions(-) create mode 100644 docs/templates.md delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/A_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/AsyncProducer_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/Blank_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/ConsulLock_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/EmbeddedGet_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/Example_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/ExpecterAndRolledVariadic_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/Expecter_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/Fooer_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/FuncArgsCollision_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/GenericInterface_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/GetGeneric_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/GetInt_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/HasConflictingNestedImports_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/ImportsSameAsPackage_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/InstantiatedGenericInterface_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/Issue766_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/KeyManager_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/MapFunc_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/MapToInterface_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/MyReader_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/PanicOnNoReturnValue_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/ReplaceGenericSelf_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/ReplaceGeneric_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester2_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester3_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester4_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArgSameAsImport_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArgSameAsNamedImport_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArgSameAsPkg_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArray_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterElided_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterGenerics_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterIface_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterNS_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterPtr_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterReturnElided_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterSlice_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterVariadicOneArgument_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterVariadic_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/Sibling_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/StructWithTag_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/UnsafeInterface_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/UsesAny_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/UsesOtherPkgIface_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/VariadicNoReturnInterface_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/VariadicReturnFunc_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/Variadic_mock.go delete mode 100644 mocks/github.com/vektra/mockery/v3/pkg/fixtures/requesterUnexported_mock.go delete mode 100644 mocks/moq/github.com/vektra/mockery/v3/pkg/fixtures/moq_test.go create mode 100644 pkg/fixtures/mocks.go create mode 100644 pkg/fixtures/mocks_moq.go create mode 100644 pkg/fixtures/requester_test.go diff --git a/.mockery.yaml b/.mockery.yaml index 95ba0eae..6689289a 100644 --- a/.mockery.yaml +++ b/.mockery.yaml @@ -22,22 +22,27 @@ packages: github.com/vektra/mockery/v3/pkg/fixtures: config: all: True + dir: "{{.InterfaceDir}}" + filename: "mocks.go" + pkgname: "test" + mockname: "Mock{{.InterfaceName}}" interfaces: + Requester: RequesterArgSameAsNamedImport: RequesterVariadic: configs: - - mockname: RequesterVariadicOneArgument + - mockname: MockRequesterVariadicOneArgument template-data: unroll-variadic: False - - mockname: RequesterVariadic + - mockname: MockRequesterVariadic template-data: unroll-variadic: True Expecter: configs: - - mockname: ExpecterAndRolledVariadic + - mockname: MockExpecterAndRolledVariadic template-data: unroll-variadic: False - - mockname: Expecter + - mockname: MockExpecter template-data: unroll-variadic: True RequesterReturnElided: diff --git a/.mockery_moq.yaml b/.mockery_moq.yaml index ed2faee3..7f74dcf6 100644 --- a/.mockery_moq.yaml +++ b/.mockery_moq.yaml @@ -1,16 +1,10 @@ -mockname: "{{.InterfaceName}}Mock" -filename: "moq_test.go" template: moq -dir: "mocks/moq/{{.SrcPackagePath}}" -formatter: "goimports" - packages: - github.com/vektra/mockery/v3/pkg/fixtures: - config: - include-regex: '.*' - exclude-regex: 'RequesterGenerics|UnsafeInterface|requester_unexported' - pkgname: test - template-data: - with-resets: true - skip-ensure: true - stub-impl: false + github.com/vektra/mockery/v3/pkg/fixtures: + config: + dir: "{{.InterfaceDir}}" + filename: "mocks_moq.go" + pkgname: "test" + mockname: "Moq{{.InterfaceName}}" + interfaces: + Requester: \ No newline at end of file diff --git a/Taskfile.yml b/Taskfile.yml index 296c2d72..ab489e52 100644 --- a/Taskfile.yml +++ b/Taskfile.yml @@ -21,7 +21,7 @@ tasks: mocks.remove: desc: remove all mock files cmds: - - find . -name '*_mock.go' -o -name 'mock_*_test.go' | xargs -r rm + - find . -name '*_mock.go' -o -name 'mock_*_test.go' -o -name 'mocks.go' -o -name "mocks_moq.go" | xargs -r rm - rm -rf mocks/ mocks.generate.mockery: diff --git a/docs/templates.md b/docs/templates.md new file mode 100644 index 00000000..a5b212e6 --- /dev/null +++ b/docs/templates.md @@ -0,0 +1,315 @@ +Templates +========= + +Mockery, in its essence, renders templates. This project provides a number of pre-curated +templates that you can select with the `#!yaml template:` config parameter. + +## Template Options + +### `#!yaml template: "mockery"` + +Choosing this template will render a traditional "mockery-style" template. The +section below shows what will be rendered for the given interface. + +=== "Interface" + + ```go + package test + + type Requester interface { + Get(path string) (string, error) + } + ``` + +=== "`.mockery.yml`" + + ```yaml + template: mockery + packages: + github.com/vektra/mockery/v3/pkg/fixtures: + config: + dir: "{{.InterfaceDir}}" + filename: "mocks.go" + pkgname: "test" + mockname: "Mock{{.InterfaceName}}" + interfaces: + Requester: + ``` + +=== "`mocks.go`" + + ```go + // Code generated by mockery; DO NOT EDIT. + // github.com/vektra/mockery + + package test + + import ( + mock "github.com/stretchr/testify/mock" + ) + + + // NewRequester creates a new instance of Requester. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. + // The first argument is typically a *testing.T value. + func NewRequester (t interface { + mock.TestingT + Cleanup(func()) + }) *Requester { + // ... + } + + + // Requester is an autogenerated mock type for the Requester type + type Requester struct { + mock.Mock + } + + type Requester_Expecter struct { + mock *mock.Mock + } + + func (_m *Requester) EXPECT() *Requester_Expecter { + // ... + } + + + + // Get provides a mock function for the type Requester + func (_mock *Requester) Get(path string) (string, error) { + // ... + } + + + + // Requester_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' + type Requester_Get_Call struct { + *mock.Call + } + + + + // Get is a helper method to define mock.On call + // - path + func (_e *Requester_Expecter) Get(path interface{}, ) *Requester_Get_Call { + // ... + } + + func (_c *Requester_Get_Call) Run(run func(path string)) *Requester_Get_Call { + // ... + } + + func (_c *Requester_Get_Call) Return(s string, err error) *Requester_Get_Call { + // ... + } + + func (_c *Requester_Get_Call) RunAndReturn(run func(path string)(string, error)) *Requester_Get_Call { + // ... + } + ``` + +=== "Example Usage" + + ```go + package test + + import ( + "testing" + + "github.com/stretchr/testify/assert" + ) + + func TestRequesterMock(t *testing.T) { + m := NewMockRequester(t) + m.EXPECT().Get("foo").Return("bar", nil).Once() + retString, err := m.Get("foo") + assert.NoError(t, err) + assert.Equal(t, retString, "bar") + } + ``` + +As you can see, this mock utilizes `github.com/stretchr/testify` under the hood and registers call expectations with testify. When the mock receives a call to `Get()`, it retrieves the expected value from testify to be returned. + +This style of mock also has other interesting methods: + +=== "`#!go Run()`" + + Run a side effect when the argument matches. + + ```go + func TestRequesterMockRun(t *testing.T) { + m := NewMockRequester(t) + m.EXPECT().Get(mock.Anything).Return("", nil) + m.EXPECT().Get(mock.Anything).Run(func(path string) { + fmt.Printf("Side effect! Argument is: %s", path) + }) + retString, err := m.Get("hello") + assert.NoError(t, err) + assert.Equal(t, retString, "") + } + ``` + +=== "`#!go RunAndReturn()`" + + Run a function to perform side-effects, and return the result of the function. + + ```go + func TestRequesterMockRunAndReturn(t *testing.T) { + m := NewMockRequester(t) + m.EXPECT().Get(mock.Anything).RunAndReturn(func(path string) (string, error) { + return path + " world", nil + }) + retString, err := m.Get("hello") + assert.NoError(t, err) + assert.Equal(t, retString, "hello world") + } + ``` + +=== "`github.com/stretchr/testify/mock.Mock`" + + Because the mock embeds the testify `Mock` object, you can all any methods on that as well. + + ```go + func TestRequesterMockTestifyEmbed(t *testing.T) { + m := NewMockRequester(t) + m.EXPECT().Get(mock.Anything).Return("", nil).Twice() + m.Get("hello") + m.Get("world") + assert.Equal(t, len(m.Mock.Calls), 2) + } + ``` +#### `template-data` + +| key | type | description | +|-----|------|-------------| +| `unroll-variadic` | `#!yaml bool` | If set to `#!yaml true`, will expand the variadic argument to testify using the `...` syntax. See [notes](./notes.md#variadic-arguments) for more details. | + +### `#!yaml template: "moq"` + +`moq` templates draw from the mocks generated from the project at https://github.com/matryer/moq. This project was folded into mockery, and thus moq-style mocks can be natively generated from within mockery. + + +=== "Interface" + + ```go + package test + + type Requester interface { + Get(path string) (string, error) + } + ``` + +=== "`.mockery.yml`" + + ```yaml + template: moq + packages: + github.com/vektra/mockery/v3/pkg/fixtures: + config: + dir: "{{.InterfaceDir}}" + filename: "mocks_moq.go" + pkgname: "test" + mockname: "Moq{{.InterfaceName}}" + interfaces: + Requester: + ``` + +=== "`mocks_moq.go`" + + ```go + // Code generated by mockery; DO NOT EDIT. + // github.com/vektra/mockery + + package test + + import ( + "sync" + ) + + // Ensure, that MoqRequester does implement Requester. + // If this is not the case, regenerate this file with moq. + var _ Requester = &MoqRequester{} + + // MoqRequester is a mock implementation of Requester. + // + // func TestSomethingThatUsesRequester(t *testing.T) { + // + // // make and configure a mocked Requester + // mockedRequester := &MoqRequester{ + // GetFunc: func(path string) (string, error) { + // panic("mock out the Get method") + // }, + // } + // + // // use mockedRequester in code that requires Requester + // // and then make assertions. + // + // } + type MoqRequester struct { + // GetFunc mocks the Get method. + GetFunc func(path string) (string, error) + + // calls tracks calls to the methods. + calls struct { + // Get holds details about calls to the Get method. + Get []struct { + // Path is the path argument value. + Path string + } + } + lockGet sync.RWMutex + } + + // Get calls GetFunc. + func (mock *MoqRequester) Get(path string) (string, error) { + // ... + } + + // GetCalls gets all the calls that were made to Get. + // Check the length with: + // + // len(mockedRequester.GetCalls()) + func (mock *MoqRequester) GetCalls() []struct { + Path string + } { + // ... + } + + ``` + +=== "Example Usage" + + ```go + func TestRequesterMoq(t *testing.T) { + m := &MoqRequester{ + GetFunc: func(path string) (string, error) { + fmt.Printf("Go path: %s\n", path) + return path + "/foo", nil + }, + } + result, err := m.Get("/path") + assert.NoError(t, err) + assert.Equal(t, "/path/foo", result) + } + ``` + +Moq-style mocks are far simpler, and probably more intuitive, than mockery-style mocks. All that's needed is to define the function that will be run when the mock's method is called. + +#### `template-data` + +`moq` accepts the following `#!yaml template-data:` keys: + +| key | type | description | +|-----|------|-------------| +| `skip-ensure` | `#!yaml bool` | Suppress mock implementation check, avoid import cycle if mocks generated outside of the tested package. | +| `stub-impl` | `#!yaml bool` | Return zero values when no mock implementation is provided, do not panic. | + +### `#!yaml template: "file://` + +You may also provide mockery a path to your own file using the `file://` protocol specifier. The string after `file://` will be the relative or absolute path of your template. + + +## Data Provided To Templates + +!!! warning "Construction" + + This section is under construction. diff --git a/mkdocs.yml b/mkdocs.yml index 1173c583..a252a87b 100644 --- a/mkdocs.yml +++ b/mkdocs.yml @@ -60,6 +60,7 @@ nav: - Getting Started: - Installation: installation.md - Configuration: configuration.md + - Templates: templates.md - Running: running.md - Examples: examples.md - Features: features.md diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/A_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/A_mock.go deleted file mode 100644 index 05fb02b8..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/A_mock.go +++ /dev/null @@ -1,101 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "github.com/vektra/mockery/v3/pkg/fixtures" - mock "github.com/stretchr/testify/mock" -) - - -// NewA creates a new instance of A. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewA (t interface { - mock.TestingT - Cleanup(func()) -}) *A { - mock := &A{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// A is an autogenerated mock type for the A type -type A struct { - mock.Mock -} - -type A_Expecter struct { - mock *mock.Mock -} - -func (_m *A) EXPECT() *A_Expecter { - return &A_Expecter{mock: &_m.Mock} -} - - - -// Call provides a mock function for the type A -func (_mock *A) Call() (test.B, error) { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for Call") - } - - - var r0 test.B - var r1 error - if returnFunc, ok := ret.Get(0).(func() (test.B, error)); ok { - return returnFunc() - } - if returnFunc, ok := ret.Get(0).(func() test.B); ok { - r0 = returnFunc() - } else { - r0 = ret.Get(0).(test.B) - } - if returnFunc, ok := ret.Get(1).(func() error); ok { - r1 = returnFunc() - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// A_Call_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Call' -type A_Call_Call struct { - *mock.Call -} - - - -// Call is a helper method to define mock.On call -func (_e *A_Expecter) Call() *A_Call_Call { - return &A_Call_Call{Call: _e.mock.On("Call", )} -} - -func (_c *A_Call_Call) Run(run func()) *A_Call_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *A_Call_Call) Return(b test.B, err error) *A_Call_Call { - _c.Call.Return(b, err) - return _c -} - -func (_c *A_Call_Call) RunAndReturn(run func()(test.B, error)) *A_Call_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/AsyncProducer_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/AsyncProducer_mock.go deleted file mode 100644 index 964601d5..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/AsyncProducer_mock.go +++ /dev/null @@ -1,197 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewAsyncProducer creates a new instance of AsyncProducer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewAsyncProducer (t interface { - mock.TestingT - Cleanup(func()) -}) *AsyncProducer { - mock := &AsyncProducer{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// AsyncProducer is an autogenerated mock type for the AsyncProducer type -type AsyncProducer struct { - mock.Mock -} - -type AsyncProducer_Expecter struct { - mock *mock.Mock -} - -func (_m *AsyncProducer) EXPECT() *AsyncProducer_Expecter { - return &AsyncProducer_Expecter{mock: &_m.Mock} -} - - - -// Input provides a mock function for the type AsyncProducer -func (_mock *AsyncProducer) Input() chan<- bool { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for Input") - } - - - var r0 chan<- bool - if returnFunc, ok := ret.Get(0).(func() chan<- bool); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(chan<- bool) - } - } - return r0 -} - - - -// AsyncProducer_Input_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Input' -type AsyncProducer_Input_Call struct { - *mock.Call -} - - - -// Input is a helper method to define mock.On call -func (_e *AsyncProducer_Expecter) Input() *AsyncProducer_Input_Call { - return &AsyncProducer_Input_Call{Call: _e.mock.On("Input", )} -} - -func (_c *AsyncProducer_Input_Call) Run(run func()) *AsyncProducer_Input_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *AsyncProducer_Input_Call) Return(boolCh chan<- bool) *AsyncProducer_Input_Call { - _c.Call.Return(boolCh) - return _c -} - -func (_c *AsyncProducer_Input_Call) RunAndReturn(run func()chan<- bool) *AsyncProducer_Input_Call { - _c.Call.Return(run) - return _c -} - - -// Output provides a mock function for the type AsyncProducer -func (_mock *AsyncProducer) Output() <-chan bool { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for Output") - } - - - var r0 <-chan bool - if returnFunc, ok := ret.Get(0).(func() <-chan bool); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(<-chan bool) - } - } - return r0 -} - - - -// AsyncProducer_Output_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Output' -type AsyncProducer_Output_Call struct { - *mock.Call -} - - - -// Output is a helper method to define mock.On call -func (_e *AsyncProducer_Expecter) Output() *AsyncProducer_Output_Call { - return &AsyncProducer_Output_Call{Call: _e.mock.On("Output", )} -} - -func (_c *AsyncProducer_Output_Call) Run(run func()) *AsyncProducer_Output_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *AsyncProducer_Output_Call) Return(boolCh <-chan bool) *AsyncProducer_Output_Call { - _c.Call.Return(boolCh) - return _c -} - -func (_c *AsyncProducer_Output_Call) RunAndReturn(run func()<-chan bool) *AsyncProducer_Output_Call { - _c.Call.Return(run) - return _c -} - - -// Whatever provides a mock function for the type AsyncProducer -func (_mock *AsyncProducer) Whatever() chan bool { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for Whatever") - } - - - var r0 chan bool - if returnFunc, ok := ret.Get(0).(func() chan bool); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(chan bool) - } - } - return r0 -} - - - -// AsyncProducer_Whatever_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Whatever' -type AsyncProducer_Whatever_Call struct { - *mock.Call -} - - - -// Whatever is a helper method to define mock.On call -func (_e *AsyncProducer_Expecter) Whatever() *AsyncProducer_Whatever_Call { - return &AsyncProducer_Whatever_Call{Call: _e.mock.On("Whatever", )} -} - -func (_c *AsyncProducer_Whatever_Call) Run(run func()) *AsyncProducer_Whatever_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *AsyncProducer_Whatever_Call) Return(boolCh chan bool) *AsyncProducer_Whatever_Call { - _c.Call.Return(boolCh) - return _c -} - -func (_c *AsyncProducer_Whatever_Call) RunAndReturn(run func()chan bool) *AsyncProducer_Whatever_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Blank_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Blank_mock.go deleted file mode 100644 index c69ec888..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Blank_mock.go +++ /dev/null @@ -1,92 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewBlank creates a new instance of Blank. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewBlank (t interface { - mock.TestingT - Cleanup(func()) -}) *Blank { - mock := &Blank{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// Blank is an autogenerated mock type for the Blank type -type Blank struct { - mock.Mock -} - -type Blank_Expecter struct { - mock *mock.Mock -} - -func (_m *Blank) EXPECT() *Blank_Expecter { - return &Blank_Expecter{mock: &_m.Mock} -} - - - -// Create provides a mock function for the type Blank -func (_mock *Blank) Create(x interface{}) error { - ret := _mock.Called(x) - - if len(ret) == 0 { - panic("no return value specified for Create") - } - - - var r0 error - if returnFunc, ok := ret.Get(0).(func(interface{}) error); ok { - r0 = returnFunc(x) - } else { - r0 = ret.Error(0) - } - return r0 -} - - - -// Blank_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' -type Blank_Create_Call struct { - *mock.Call -} - - - -// Create is a helper method to define mock.On call -// - x -func (_e *Blank_Expecter) Create(x interface{}, ) *Blank_Create_Call { - return &Blank_Create_Call{Call: _e.mock.On("Create",x, )} -} - -func (_c *Blank_Create_Call) Run(run func(x interface{})) *Blank_Create_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(interface{}),) - }) - return _c -} - -func (_c *Blank_Create_Call) Return(err error) *Blank_Create_Call { - _c.Call.Return(err) - return _c -} - -func (_c *Blank_Create_Call) RunAndReturn(run func(x interface{})error) *Blank_Create_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ConsulLock_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ConsulLock_mock.go deleted file mode 100644 index c2506a27..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ConsulLock_mock.go +++ /dev/null @@ -1,153 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewConsulLock creates a new instance of ConsulLock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewConsulLock (t interface { - mock.TestingT - Cleanup(func()) -}) *ConsulLock { - mock := &ConsulLock{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// ConsulLock is an autogenerated mock type for the ConsulLock type -type ConsulLock struct { - mock.Mock -} - -type ConsulLock_Expecter struct { - mock *mock.Mock -} - -func (_m *ConsulLock) EXPECT() *ConsulLock_Expecter { - return &ConsulLock_Expecter{mock: &_m.Mock} -} - - - -// Lock provides a mock function for the type ConsulLock -func (_mock *ConsulLock) Lock(valCh <-chan struct{}) (<-chan struct{}, error) { - ret := _mock.Called(valCh) - - if len(ret) == 0 { - panic("no return value specified for Lock") - } - - - var r0 <-chan struct{} - var r1 error - if returnFunc, ok := ret.Get(0).(func(<-chan struct{}) (<-chan struct{}, error)); ok { - return returnFunc(valCh) - } - if returnFunc, ok := ret.Get(0).(func(<-chan struct{}) <-chan struct{}); ok { - r0 = returnFunc(valCh) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(<-chan struct{}) - } - } - if returnFunc, ok := ret.Get(1).(func(<-chan struct{}) error); ok { - r1 = returnFunc(valCh) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// ConsulLock_Lock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Lock' -type ConsulLock_Lock_Call struct { - *mock.Call -} - - - -// Lock is a helper method to define mock.On call -// - valCh -func (_e *ConsulLock_Expecter) Lock(valCh interface{}, ) *ConsulLock_Lock_Call { - return &ConsulLock_Lock_Call{Call: _e.mock.On("Lock",valCh, )} -} - -func (_c *ConsulLock_Lock_Call) Run(run func(valCh <-chan struct{})) *ConsulLock_Lock_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(<-chan struct{}),) - }) - return _c -} - -func (_c *ConsulLock_Lock_Call) Return(valCh1 <-chan struct{}, err error) *ConsulLock_Lock_Call { - _c.Call.Return(valCh1, err) - return _c -} - -func (_c *ConsulLock_Lock_Call) RunAndReturn(run func(valCh <-chan struct{})(<-chan struct{}, error)) *ConsulLock_Lock_Call { - _c.Call.Return(run) - return _c -} - - -// Unlock provides a mock function for the type ConsulLock -func (_mock *ConsulLock) Unlock() error { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for Unlock") - } - - - var r0 error - if returnFunc, ok := ret.Get(0).(func() error); ok { - r0 = returnFunc() - } else { - r0 = ret.Error(0) - } - return r0 -} - - - -// ConsulLock_Unlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unlock' -type ConsulLock_Unlock_Call struct { - *mock.Call -} - - - -// Unlock is a helper method to define mock.On call -func (_e *ConsulLock_Expecter) Unlock() *ConsulLock_Unlock_Call { - return &ConsulLock_Unlock_Call{Call: _e.mock.On("Unlock", )} -} - -func (_c *ConsulLock_Unlock_Call) Run(run func()) *ConsulLock_Unlock_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *ConsulLock_Unlock_Call) Return(err error) *ConsulLock_Unlock_Call { - _c.Call.Return(err) - return _c -} - -func (_c *ConsulLock_Unlock_Call) RunAndReturn(run func()error) *ConsulLock_Unlock_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/EmbeddedGet_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/EmbeddedGet_mock.go deleted file mode 100644 index 80666261..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/EmbeddedGet_mock.go +++ /dev/null @@ -1,94 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "github.com/vektra/mockery/v3/pkg/fixtures/constraints" - mock "github.com/stretchr/testify/mock" -) - - -// NewEmbeddedGet creates a new instance of EmbeddedGet. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewEmbeddedGet[T constraints.Signed] (t interface { - mock.TestingT - Cleanup(func()) -}) *EmbeddedGet[T] { - mock := &EmbeddedGet[T]{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// EmbeddedGet is an autogenerated mock type for the EmbeddedGet type -type EmbeddedGet[T constraints.Signed] struct { - mock.Mock -} - -type EmbeddedGet_Expecter[T constraints.Signed] struct { - mock *mock.Mock -} - -func (_m *EmbeddedGet[T]) EXPECT() *EmbeddedGet_Expecter[T] { - return &EmbeddedGet_Expecter[T]{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type EmbeddedGet -func (_mock *EmbeddedGet[T]) Get() T { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 T - if returnFunc, ok := ret.Get(0).(func() T); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(T) - } - } - return r0 -} - - - -// EmbeddedGet_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type EmbeddedGet_Get_Call[T constraints.Signed] struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -func (_e *EmbeddedGet_Expecter[T]) Get() *EmbeddedGet_Get_Call[T] { - return &EmbeddedGet_Get_Call[T]{Call: _e.mock.On("Get", )} -} - -func (_c *EmbeddedGet_Get_Call[T]) Run(run func()) *EmbeddedGet_Get_Call[T] { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *EmbeddedGet_Get_Call[T]) Return(v T) *EmbeddedGet_Get_Call[T] { - _c.Call.Return(v) - return _c -} - -func (_c *EmbeddedGet_Get_Call[T]) RunAndReturn(run func()T) *EmbeddedGet_Get_Call[T] { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Example_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Example_mock.go deleted file mode 100644 index cb04f57a..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Example_mock.go +++ /dev/null @@ -1,198 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - http1 "github.com/vektra/mockery/v3/pkg/fixtures/12345678/http" - http0 "github.com/vektra/mockery/v3/pkg/fixtures/http" - "net/http" - mock "github.com/stretchr/testify/mock" -) - - -// NewExample creates a new instance of Example. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewExample (t interface { - mock.TestingT - Cleanup(func()) -}) *Example { - mock := &Example{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// Example is an autogenerated mock type for the Example type -type Example struct { - mock.Mock -} - -type Example_Expecter struct { - mock *mock.Mock -} - -func (_m *Example) EXPECT() *Example_Expecter { - return &Example_Expecter{mock: &_m.Mock} -} - - - -// A provides a mock function for the type Example -func (_mock *Example) A() http.Flusher { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for A") - } - - - var r0 http.Flusher - if returnFunc, ok := ret.Get(0).(func() http.Flusher); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(http.Flusher) - } - } - return r0 -} - - - -// Example_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A' -type Example_A_Call struct { - *mock.Call -} - - - -// A is a helper method to define mock.On call -func (_e *Example_Expecter) A() *Example_A_Call { - return &Example_A_Call{Call: _e.mock.On("A", )} -} - -func (_c *Example_A_Call) Run(run func()) *Example_A_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *Example_A_Call) Return(flusher http.Flusher) *Example_A_Call { - _c.Call.Return(flusher) - return _c -} - -func (_c *Example_A_Call) RunAndReturn(run func()http.Flusher) *Example_A_Call { - _c.Call.Return(run) - return _c -} - - -// B provides a mock function for the type Example -func (_mock *Example) B(fixtureshttp string) http0.MyStruct { - ret := _mock.Called(fixtureshttp) - - if len(ret) == 0 { - panic("no return value specified for B") - } - - - var r0 http0.MyStruct - if returnFunc, ok := ret.Get(0).(func(string) http0.MyStruct); ok { - r0 = returnFunc(fixtureshttp) - } else { - r0 = ret.Get(0).(http0.MyStruct) - } - return r0 -} - - - -// Example_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B' -type Example_B_Call struct { - *mock.Call -} - - - -// B is a helper method to define mock.On call -// - fixtureshttp -func (_e *Example_Expecter) B(fixtureshttp interface{}, ) *Example_B_Call { - return &Example_B_Call{Call: _e.mock.On("B",fixtureshttp, )} -} - -func (_c *Example_B_Call) Run(run func(fixtureshttp string)) *Example_B_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *Example_B_Call) Return(myStruct http0.MyStruct) *Example_B_Call { - _c.Call.Return(myStruct) - return _c -} - -func (_c *Example_B_Call) RunAndReturn(run func(fixtureshttp string)http0.MyStruct) *Example_B_Call { - _c.Call.Return(run) - return _c -} - - -// C provides a mock function for the type Example -func (_mock *Example) C(fixtureshttp string) http1.MyStruct { - ret := _mock.Called(fixtureshttp) - - if len(ret) == 0 { - panic("no return value specified for C") - } - - - var r0 http1.MyStruct - if returnFunc, ok := ret.Get(0).(func(string) http1.MyStruct); ok { - r0 = returnFunc(fixtureshttp) - } else { - r0 = ret.Get(0).(http1.MyStruct) - } - return r0 -} - - - -// Example_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C' -type Example_C_Call struct { - *mock.Call -} - - - -// C is a helper method to define mock.On call -// - fixtureshttp -func (_e *Example_Expecter) C(fixtureshttp interface{}, ) *Example_C_Call { - return &Example_C_Call{Call: _e.mock.On("C",fixtureshttp, )} -} - -func (_c *Example_C_Call) Run(run func(fixtureshttp string)) *Example_C_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *Example_C_Call) Return(myStruct http1.MyStruct) *Example_C_Call { - _c.Call.Return(myStruct) - return _c -} - -func (_c *Example_C_Call) RunAndReturn(run func(fixtureshttp string)http1.MyStruct) *Example_C_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ExpecterAndRolledVariadic_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ExpecterAndRolledVariadic_mock.go deleted file mode 100644 index 99970df0..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ExpecterAndRolledVariadic_mock.go +++ /dev/null @@ -1,318 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewExpecterAndRolledVariadic creates a new instance of ExpecterAndRolledVariadic. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewExpecterAndRolledVariadic (t interface { - mock.TestingT - Cleanup(func()) -}) *ExpecterAndRolledVariadic { - mock := &ExpecterAndRolledVariadic{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// ExpecterAndRolledVariadic is an autogenerated mock type for the Expecter type -type ExpecterAndRolledVariadic struct { - mock.Mock -} - -type ExpecterAndRolledVariadic_Expecter struct { - mock *mock.Mock -} - -func (_m *ExpecterAndRolledVariadic) EXPECT() *ExpecterAndRolledVariadic_Expecter { - return &ExpecterAndRolledVariadic_Expecter{mock: &_m.Mock} -} - - - -// ManyArgsReturns provides a mock function for the type ExpecterAndRolledVariadic -func (_mock *ExpecterAndRolledVariadic) ManyArgsReturns(str string, i int) ([]string, error) { - ret := _mock.Called(str, i) - - if len(ret) == 0 { - panic("no return value specified for ManyArgsReturns") - } - - - var r0 []string - var r1 error - if returnFunc, ok := ret.Get(0).(func(string, int) ([]string, error)); ok { - return returnFunc(str, i) - } - if returnFunc, ok := ret.Get(0).(func(string, int) []string); ok { - r0 = returnFunc(str, i) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]string) - } - } - if returnFunc, ok := ret.Get(1).(func(string, int) error); ok { - r1 = returnFunc(str, i) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// ExpecterAndRolledVariadic_ManyArgsReturns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManyArgsReturns' -type ExpecterAndRolledVariadic_ManyArgsReturns_Call struct { - *mock.Call -} - - - -// ManyArgsReturns is a helper method to define mock.On call -// - str -// - i -func (_e *ExpecterAndRolledVariadic_Expecter) ManyArgsReturns(str interface{}, i interface{}, ) *ExpecterAndRolledVariadic_ManyArgsReturns_Call { - return &ExpecterAndRolledVariadic_ManyArgsReturns_Call{Call: _e.mock.On("ManyArgsReturns",str,i, )} -} - -func (_c *ExpecterAndRolledVariadic_ManyArgsReturns_Call) Run(run func(str string, i int)) *ExpecterAndRolledVariadic_ManyArgsReturns_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),args[1].(int),) - }) - return _c -} - -func (_c *ExpecterAndRolledVariadic_ManyArgsReturns_Call) Return(strs []string, err error) *ExpecterAndRolledVariadic_ManyArgsReturns_Call { - _c.Call.Return(strs, err) - return _c -} - -func (_c *ExpecterAndRolledVariadic_ManyArgsReturns_Call) RunAndReturn(run func(str string, i int)([]string, error)) *ExpecterAndRolledVariadic_ManyArgsReturns_Call { - _c.Call.Return(run) - return _c -} - - -// NoArg provides a mock function for the type ExpecterAndRolledVariadic -func (_mock *ExpecterAndRolledVariadic) NoArg() string { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for NoArg") - } - - - var r0 string - if returnFunc, ok := ret.Get(0).(func() string); ok { - r0 = returnFunc() - } else { - r0 = ret.Get(0).(string) - } - return r0 -} - - - -// ExpecterAndRolledVariadic_NoArg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoArg' -type ExpecterAndRolledVariadic_NoArg_Call struct { - *mock.Call -} - - - -// NoArg is a helper method to define mock.On call -func (_e *ExpecterAndRolledVariadic_Expecter) NoArg() *ExpecterAndRolledVariadic_NoArg_Call { - return &ExpecterAndRolledVariadic_NoArg_Call{Call: _e.mock.On("NoArg", )} -} - -func (_c *ExpecterAndRolledVariadic_NoArg_Call) Run(run func()) *ExpecterAndRolledVariadic_NoArg_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *ExpecterAndRolledVariadic_NoArg_Call) Return(s string) *ExpecterAndRolledVariadic_NoArg_Call { - _c.Call.Return(s) - return _c -} - -func (_c *ExpecterAndRolledVariadic_NoArg_Call) RunAndReturn(run func()string) *ExpecterAndRolledVariadic_NoArg_Call { - _c.Call.Return(run) - return _c -} - - -// NoReturn provides a mock function for the type ExpecterAndRolledVariadic -func (_mock *ExpecterAndRolledVariadic) NoReturn(str string) { _mock.Called(str) - return -} - - - -// ExpecterAndRolledVariadic_NoReturn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoReturn' -type ExpecterAndRolledVariadic_NoReturn_Call struct { - *mock.Call -} - - - -// NoReturn is a helper method to define mock.On call -// - str -func (_e *ExpecterAndRolledVariadic_Expecter) NoReturn(str interface{}, ) *ExpecterAndRolledVariadic_NoReturn_Call { - return &ExpecterAndRolledVariadic_NoReturn_Call{Call: _e.mock.On("NoReturn",str, )} -} - -func (_c *ExpecterAndRolledVariadic_NoReturn_Call) Run(run func(str string)) *ExpecterAndRolledVariadic_NoReturn_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *ExpecterAndRolledVariadic_NoReturn_Call) Return() *ExpecterAndRolledVariadic_NoReturn_Call { - _c.Call.Return() - return _c -} - -func (_c *ExpecterAndRolledVariadic_NoReturn_Call) RunAndReturn(run func(str string)) *ExpecterAndRolledVariadic_NoReturn_Call { - _c.Run(run) - return _c -} - - -// Variadic provides a mock function for the type ExpecterAndRolledVariadic -func (_mock *ExpecterAndRolledVariadic) Variadic(ints ...int) error { - var tmpRet mock.Arguments - if len(ints) > 0 {tmpRet = _mock.Called(ints) - } else {tmpRet = _mock.Called() - } - ret := tmpRet - - if len(ret) == 0 { - panic("no return value specified for Variadic") - } - - - var r0 error - if returnFunc, ok := ret.Get(0).(func(...int) error); ok { - r0 = returnFunc(ints...) - } else { - r0 = ret.Error(0) - } - return r0 -} - - - -// ExpecterAndRolledVariadic_Variadic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Variadic' -type ExpecterAndRolledVariadic_Variadic_Call struct { - *mock.Call -} - - - -// Variadic is a helper method to define mock.On call -// - ints -func (_e *ExpecterAndRolledVariadic_Expecter) Variadic(ints ...interface{}, ) *ExpecterAndRolledVariadic_Variadic_Call { - return &ExpecterAndRolledVariadic_Variadic_Call{Call: _e.mock.On("Variadic", - append([]interface{}{ }, ints... )... )} -} - -func (_c *ExpecterAndRolledVariadic_Variadic_Call) Run(run func(ints ...int)) *ExpecterAndRolledVariadic_Variadic_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]int, len(args) - 0) - for i, a := range args[0:] { - if a != nil { - variadicArgs[i] = a.(int) - } - } - run(variadicArgs...) - }) - return _c -} - -func (_c *ExpecterAndRolledVariadic_Variadic_Call) Return(err error) *ExpecterAndRolledVariadic_Variadic_Call { - _c.Call.Return(err) - return _c -} - -func (_c *ExpecterAndRolledVariadic_Variadic_Call) RunAndReturn(run func(ints ...int)error) *ExpecterAndRolledVariadic_Variadic_Call { - _c.Call.Return(run) - return _c -} - - -// VariadicMany provides a mock function for the type ExpecterAndRolledVariadic -func (_mock *ExpecterAndRolledVariadic) VariadicMany(i int, a string, intfs ...interface{}) error { - var tmpRet mock.Arguments - if len(intfs) > 0 {tmpRet = _mock.Called(i, a, intfs) - } else {tmpRet = _mock.Called(i, a) - } - ret := tmpRet - - if len(ret) == 0 { - panic("no return value specified for VariadicMany") - } - - - var r0 error - if returnFunc, ok := ret.Get(0).(func(int, string, ...interface{}) error); ok { - r0 = returnFunc(i, a, intfs...) - } else { - r0 = ret.Error(0) - } - return r0 -} - - - -// ExpecterAndRolledVariadic_VariadicMany_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicMany' -type ExpecterAndRolledVariadic_VariadicMany_Call struct { - *mock.Call -} - - - -// VariadicMany is a helper method to define mock.On call -// - i -// - a -// - intfs -func (_e *ExpecterAndRolledVariadic_Expecter) VariadicMany(i interface{}, a interface{}, intfs ...interface{}, ) *ExpecterAndRolledVariadic_VariadicMany_Call { - return &ExpecterAndRolledVariadic_VariadicMany_Call{Call: _e.mock.On("VariadicMany", - append([]interface{}{ i, a, }, intfs... )... )} -} - -func (_c *ExpecterAndRolledVariadic_VariadicMany_Call) Run(run func(i int, a string, intfs ...interface{})) *ExpecterAndRolledVariadic_VariadicMany_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]interface{}, len(args) - 2) - for i, a := range args[2:] { - if a != nil { - variadicArgs[i] = a.(interface{}) - } - } - run(args[0].(int),args[1].(string),variadicArgs...) - }) - return _c -} - -func (_c *ExpecterAndRolledVariadic_VariadicMany_Call) Return(err error) *ExpecterAndRolledVariadic_VariadicMany_Call { - _c.Call.Return(err) - return _c -} - -func (_c *ExpecterAndRolledVariadic_VariadicMany_Call) RunAndReturn(run func(i int, a string, intfs ...interface{})error) *ExpecterAndRolledVariadic_VariadicMany_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Expecter_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Expecter_mock.go deleted file mode 100644 index 30c05a7d..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Expecter_mock.go +++ /dev/null @@ -1,320 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewExpecter creates a new instance of Expecter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewExpecter (t interface { - mock.TestingT - Cleanup(func()) -}) *Expecter { - mock := &Expecter{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// Expecter is an autogenerated mock type for the Expecter type -type Expecter struct { - mock.Mock -} - -type Expecter_Expecter struct { - mock *mock.Mock -} - -func (_m *Expecter) EXPECT() *Expecter_Expecter { - return &Expecter_Expecter{mock: &_m.Mock} -} - - - -// ManyArgsReturns provides a mock function for the type Expecter -func (_mock *Expecter) ManyArgsReturns(str string, i int) ([]string, error) { - ret := _mock.Called(str, i) - - if len(ret) == 0 { - panic("no return value specified for ManyArgsReturns") - } - - - var r0 []string - var r1 error - if returnFunc, ok := ret.Get(0).(func(string, int) ([]string, error)); ok { - return returnFunc(str, i) - } - if returnFunc, ok := ret.Get(0).(func(string, int) []string); ok { - r0 = returnFunc(str, i) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]string) - } - } - if returnFunc, ok := ret.Get(1).(func(string, int) error); ok { - r1 = returnFunc(str, i) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// Expecter_ManyArgsReturns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManyArgsReturns' -type Expecter_ManyArgsReturns_Call struct { - *mock.Call -} - - - -// ManyArgsReturns is a helper method to define mock.On call -// - str -// - i -func (_e *Expecter_Expecter) ManyArgsReturns(str interface{}, i interface{}, ) *Expecter_ManyArgsReturns_Call { - return &Expecter_ManyArgsReturns_Call{Call: _e.mock.On("ManyArgsReturns",str,i, )} -} - -func (_c *Expecter_ManyArgsReturns_Call) Run(run func(str string, i int)) *Expecter_ManyArgsReturns_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),args[1].(int),) - }) - return _c -} - -func (_c *Expecter_ManyArgsReturns_Call) Return(strs []string, err error) *Expecter_ManyArgsReturns_Call { - _c.Call.Return(strs, err) - return _c -} - -func (_c *Expecter_ManyArgsReturns_Call) RunAndReturn(run func(str string, i int)([]string, error)) *Expecter_ManyArgsReturns_Call { - _c.Call.Return(run) - return _c -} - - -// NoArg provides a mock function for the type Expecter -func (_mock *Expecter) NoArg() string { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for NoArg") - } - - - var r0 string - if returnFunc, ok := ret.Get(0).(func() string); ok { - r0 = returnFunc() - } else { - r0 = ret.Get(0).(string) - } - return r0 -} - - - -// Expecter_NoArg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoArg' -type Expecter_NoArg_Call struct { - *mock.Call -} - - - -// NoArg is a helper method to define mock.On call -func (_e *Expecter_Expecter) NoArg() *Expecter_NoArg_Call { - return &Expecter_NoArg_Call{Call: _e.mock.On("NoArg", )} -} - -func (_c *Expecter_NoArg_Call) Run(run func()) *Expecter_NoArg_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *Expecter_NoArg_Call) Return(s string) *Expecter_NoArg_Call { - _c.Call.Return(s) - return _c -} - -func (_c *Expecter_NoArg_Call) RunAndReturn(run func()string) *Expecter_NoArg_Call { - _c.Call.Return(run) - return _c -} - - -// NoReturn provides a mock function for the type Expecter -func (_mock *Expecter) NoReturn(str string) { _mock.Called(str) - return -} - - - -// Expecter_NoReturn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoReturn' -type Expecter_NoReturn_Call struct { - *mock.Call -} - - - -// NoReturn is a helper method to define mock.On call -// - str -func (_e *Expecter_Expecter) NoReturn(str interface{}, ) *Expecter_NoReturn_Call { - return &Expecter_NoReturn_Call{Call: _e.mock.On("NoReturn",str, )} -} - -func (_c *Expecter_NoReturn_Call) Run(run func(str string)) *Expecter_NoReturn_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *Expecter_NoReturn_Call) Return() *Expecter_NoReturn_Call { - _c.Call.Return() - return _c -} - -func (_c *Expecter_NoReturn_Call) RunAndReturn(run func(str string)) *Expecter_NoReturn_Call { - _c.Run(run) - return _c -} - - -// Variadic provides a mock function for the type Expecter -func (_mock *Expecter) Variadic(ints ...int) error { - // int - _va := make([]interface{}, len(ints)) - for _i := range ints { - _va[_i] = ints[_i] - } - var _ca []interface{} - _ca = append(_ca, _va...) - ret := _mock.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for Variadic") - } - - - var r0 error - if returnFunc, ok := ret.Get(0).(func(...int) error); ok { - r0 = returnFunc(ints...) - } else { - r0 = ret.Error(0) - } - return r0 -} - - - -// Expecter_Variadic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Variadic' -type Expecter_Variadic_Call struct { - *mock.Call -} - - - -// Variadic is a helper method to define mock.On call -// - ints -func (_e *Expecter_Expecter) Variadic(ints ...interface{}, ) *Expecter_Variadic_Call { - return &Expecter_Variadic_Call{Call: _e.mock.On("Variadic", - append([]interface{}{ }, ints... )... )} -} - -func (_c *Expecter_Variadic_Call) Run(run func(ints ...int)) *Expecter_Variadic_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]int, len(args) - 0) - for i, a := range args[0:] { - if a != nil { - variadicArgs[i] = a.(int) - } - } - run(variadicArgs...) - }) - return _c -} - -func (_c *Expecter_Variadic_Call) Return(err error) *Expecter_Variadic_Call { - _c.Call.Return(err) - return _c -} - -func (_c *Expecter_Variadic_Call) RunAndReturn(run func(ints ...int)error) *Expecter_Variadic_Call { - _c.Call.Return(run) - return _c -} - - -// VariadicMany provides a mock function for the type Expecter -func (_mock *Expecter) VariadicMany(i int, a string, intfs ...interface{}) error { - var _ca []interface{} - _ca = append(_ca, i, a) - _ca = append(_ca, intfs...) - ret := _mock.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for VariadicMany") - } - - - var r0 error - if returnFunc, ok := ret.Get(0).(func(int, string, ...interface{}) error); ok { - r0 = returnFunc(i, a, intfs...) - } else { - r0 = ret.Error(0) - } - return r0 -} - - - -// Expecter_VariadicMany_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicMany' -type Expecter_VariadicMany_Call struct { - *mock.Call -} - - - -// VariadicMany is a helper method to define mock.On call -// - i -// - a -// - intfs -func (_e *Expecter_Expecter) VariadicMany(i interface{}, a interface{}, intfs ...interface{}, ) *Expecter_VariadicMany_Call { - return &Expecter_VariadicMany_Call{Call: _e.mock.On("VariadicMany", - append([]interface{}{ i, a, }, intfs... )... )} -} - -func (_c *Expecter_VariadicMany_Call) Run(run func(i int, a string, intfs ...interface{})) *Expecter_VariadicMany_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]interface{}, len(args) - 2) - for i, a := range args[2:] { - if a != nil { - variadicArgs[i] = a.(interface{}) - } - } - run(args[0].(int),args[1].(string),variadicArgs...) - }) - return _c -} - -func (_c *Expecter_VariadicMany_Call) Return(err error) *Expecter_VariadicMany_Call { - _c.Call.Return(err) - return _c -} - -func (_c *Expecter_VariadicMany_Call) RunAndReturn(run func(i int, a string, intfs ...interface{})error) *Expecter_VariadicMany_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Fooer_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Fooer_mock.go deleted file mode 100644 index ae953962..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Fooer_mock.go +++ /dev/null @@ -1,183 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewFooer creates a new instance of Fooer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewFooer (t interface { - mock.TestingT - Cleanup(func()) -}) *Fooer { - mock := &Fooer{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// Fooer is an autogenerated mock type for the Fooer type -type Fooer struct { - mock.Mock -} - -type Fooer_Expecter struct { - mock *mock.Mock -} - -func (_m *Fooer) EXPECT() *Fooer_Expecter { - return &Fooer_Expecter{mock: &_m.Mock} -} - - - -// Bar provides a mock function for the type Fooer -func (_mock *Fooer) Bar(f func([]int)) { _mock.Called(f) - return -} - - - -// Fooer_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar' -type Fooer_Bar_Call struct { - *mock.Call -} - - - -// Bar is a helper method to define mock.On call -// - f -func (_e *Fooer_Expecter) Bar(f interface{}, ) *Fooer_Bar_Call { - return &Fooer_Bar_Call{Call: _e.mock.On("Bar",f, )} -} - -func (_c *Fooer_Bar_Call) Run(run func(f func([]int))) *Fooer_Bar_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(func([]int)),) - }) - return _c -} - -func (_c *Fooer_Bar_Call) Return() *Fooer_Bar_Call { - _c.Call.Return() - return _c -} - -func (_c *Fooer_Bar_Call) RunAndReturn(run func(f func([]int))) *Fooer_Bar_Call { - _c.Run(run) - return _c -} - - -// Baz provides a mock function for the type Fooer -func (_mock *Fooer) Baz(path string) func(x string) string { - ret := _mock.Called(path) - - if len(ret) == 0 { - panic("no return value specified for Baz") - } - - - var r0 func(x string) string - if returnFunc, ok := ret.Get(0).(func(string) func(x string) string); ok { - r0 = returnFunc(path) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(func(x string) string) - } - } - return r0 -} - - - -// Fooer_Baz_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Baz' -type Fooer_Baz_Call struct { - *mock.Call -} - - - -// Baz is a helper method to define mock.On call -// - path -func (_e *Fooer_Expecter) Baz(path interface{}, ) *Fooer_Baz_Call { - return &Fooer_Baz_Call{Call: _e.mock.On("Baz",path, )} -} - -func (_c *Fooer_Baz_Call) Run(run func(path string)) *Fooer_Baz_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *Fooer_Baz_Call) Return(fn func(x string) string) *Fooer_Baz_Call { - _c.Call.Return(fn) - return _c -} - -func (_c *Fooer_Baz_Call) RunAndReturn(run func(path string)func(x string) string) *Fooer_Baz_Call { - _c.Call.Return(run) - return _c -} - - -// Foo provides a mock function for the type Fooer -func (_mock *Fooer) Foo(f func(x string) string) error { - ret := _mock.Called(f) - - if len(ret) == 0 { - panic("no return value specified for Foo") - } - - - var r0 error - if returnFunc, ok := ret.Get(0).(func(func(x string) string) error); ok { - r0 = returnFunc(f) - } else { - r0 = ret.Error(0) - } - return r0 -} - - - -// Fooer_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo' -type Fooer_Foo_Call struct { - *mock.Call -} - - - -// Foo is a helper method to define mock.On call -// - f -func (_e *Fooer_Expecter) Foo(f interface{}, ) *Fooer_Foo_Call { - return &Fooer_Foo_Call{Call: _e.mock.On("Foo",f, )} -} - -func (_c *Fooer_Foo_Call) Run(run func(f func(x string) string)) *Fooer_Foo_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(func(x string) string),) - }) - return _c -} - -func (_c *Fooer_Foo_Call) Return(err error) *Fooer_Foo_Call { - _c.Call.Return(err) - return _c -} - -func (_c *Fooer_Foo_Call) RunAndReturn(run func(f func(x string) string)error) *Fooer_Foo_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/FuncArgsCollision_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/FuncArgsCollision_mock.go deleted file mode 100644 index c7816641..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/FuncArgsCollision_mock.go +++ /dev/null @@ -1,92 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewFuncArgsCollision creates a new instance of FuncArgsCollision. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewFuncArgsCollision (t interface { - mock.TestingT - Cleanup(func()) -}) *FuncArgsCollision { - mock := &FuncArgsCollision{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// FuncArgsCollision is an autogenerated mock type for the FuncArgsCollision type -type FuncArgsCollision struct { - mock.Mock -} - -type FuncArgsCollision_Expecter struct { - mock *mock.Mock -} - -func (_m *FuncArgsCollision) EXPECT() *FuncArgsCollision_Expecter { - return &FuncArgsCollision_Expecter{mock: &_m.Mock} -} - - - -// Foo provides a mock function for the type FuncArgsCollision -func (_mock *FuncArgsCollision) Foo(ret interface{}) error { - ret1 := _mock.Called(ret) - - if len(ret1) == 0 { - panic("no return value specified for Foo") - } - - - var r0 error - if returnFunc, ok := ret1.Get(0).(func(interface{}) error); ok { - r0 = returnFunc(ret) - } else { - r0 = ret1.Error(0) - } - return r0 -} - - - -// FuncArgsCollision_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo' -type FuncArgsCollision_Foo_Call struct { - *mock.Call -} - - - -// Foo is a helper method to define mock.On call -// - ret -func (_e *FuncArgsCollision_Expecter) Foo(ret interface{}, ) *FuncArgsCollision_Foo_Call { - return &FuncArgsCollision_Foo_Call{Call: _e.mock.On("Foo",ret, )} -} - -func (_c *FuncArgsCollision_Foo_Call) Run(run func(ret interface{})) *FuncArgsCollision_Foo_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(interface{}),) - }) - return _c -} - -func (_c *FuncArgsCollision_Foo_Call) Return(err error) *FuncArgsCollision_Foo_Call { - _c.Call.Return(err) - return _c -} - -func (_c *FuncArgsCollision_Foo_Call) RunAndReturn(run func(ret interface{})error) *FuncArgsCollision_Foo_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/GenericInterface_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/GenericInterface_mock.go deleted file mode 100644 index 014d04c9..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/GenericInterface_mock.go +++ /dev/null @@ -1,92 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewGenericInterface creates a new instance of GenericInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewGenericInterface[M any] (t interface { - mock.TestingT - Cleanup(func()) -}) *GenericInterface[M] { - mock := &GenericInterface[M]{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// GenericInterface is an autogenerated mock type for the GenericInterface type -type GenericInterface[M any] struct { - mock.Mock -} - -type GenericInterface_Expecter[M any] struct { - mock *mock.Mock -} - -func (_m *GenericInterface[M]) EXPECT() *GenericInterface_Expecter[M] { - return &GenericInterface_Expecter[M]{mock: &_m.Mock} -} - - - -// Func provides a mock function for the type GenericInterface -func (_mock *GenericInterface[M]) Func(arg *M) int { - ret := _mock.Called(arg) - - if len(ret) == 0 { - panic("no return value specified for Func") - } - - - var r0 int - if returnFunc, ok := ret.Get(0).(func(*M) int); ok { - r0 = returnFunc(arg) - } else { - r0 = ret.Get(0).(int) - } - return r0 -} - - - -// GenericInterface_Func_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Func' -type GenericInterface_Func_Call[M any] struct { - *mock.Call -} - - - -// Func is a helper method to define mock.On call -// - arg -func (_e *GenericInterface_Expecter[M]) Func(arg interface{}, ) *GenericInterface_Func_Call[M] { - return &GenericInterface_Func_Call[M]{Call: _e.mock.On("Func",arg, )} -} - -func (_c *GenericInterface_Func_Call[M]) Run(run func(arg *M)) *GenericInterface_Func_Call[M] { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*M),) - }) - return _c -} - -func (_c *GenericInterface_Func_Call[M]) Return(n int) *GenericInterface_Func_Call[M] { - _c.Call.Return(n) - return _c -} - -func (_c *GenericInterface_Func_Call[M]) RunAndReturn(run func(arg *M)int) *GenericInterface_Func_Call[M] { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/GetGeneric_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/GetGeneric_mock.go deleted file mode 100644 index dc188f35..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/GetGeneric_mock.go +++ /dev/null @@ -1,94 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "github.com/vektra/mockery/v3/pkg/fixtures/constraints" - mock "github.com/stretchr/testify/mock" -) - - -// NewGetGeneric creates a new instance of GetGeneric. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewGetGeneric[T constraints.Integer] (t interface { - mock.TestingT - Cleanup(func()) -}) *GetGeneric[T] { - mock := &GetGeneric[T]{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// GetGeneric is an autogenerated mock type for the GetGeneric type -type GetGeneric[T constraints.Integer] struct { - mock.Mock -} - -type GetGeneric_Expecter[T constraints.Integer] struct { - mock *mock.Mock -} - -func (_m *GetGeneric[T]) EXPECT() *GetGeneric_Expecter[T] { - return &GetGeneric_Expecter[T]{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type GetGeneric -func (_mock *GetGeneric[T]) Get() T { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 T - if returnFunc, ok := ret.Get(0).(func() T); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(T) - } - } - return r0 -} - - - -// GetGeneric_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type GetGeneric_Get_Call[T constraints.Integer] struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -func (_e *GetGeneric_Expecter[T]) Get() *GetGeneric_Get_Call[T] { - return &GetGeneric_Get_Call[T]{Call: _e.mock.On("Get", )} -} - -func (_c *GetGeneric_Get_Call[T]) Run(run func()) *GetGeneric_Get_Call[T] { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *GetGeneric_Get_Call[T]) Return(v T) *GetGeneric_Get_Call[T] { - _c.Call.Return(v) - return _c -} - -func (_c *GetGeneric_Get_Call[T]) RunAndReturn(run func()T) *GetGeneric_Get_Call[T] { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/GetInt_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/GetInt_mock.go deleted file mode 100644 index 391d06fd..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/GetInt_mock.go +++ /dev/null @@ -1,91 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewGetInt creates a new instance of GetInt. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewGetInt (t interface { - mock.TestingT - Cleanup(func()) -}) *GetInt { - mock := &GetInt{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// GetInt is an autogenerated mock type for the GetInt type -type GetInt struct { - mock.Mock -} - -type GetInt_Expecter struct { - mock *mock.Mock -} - -func (_m *GetInt) EXPECT() *GetInt_Expecter { - return &GetInt_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type GetInt -func (_mock *GetInt) Get() int { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 int - if returnFunc, ok := ret.Get(0).(func() int); ok { - r0 = returnFunc() - } else { - r0 = ret.Get(0).(int) - } - return r0 -} - - - -// GetInt_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type GetInt_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -func (_e *GetInt_Expecter) Get() *GetInt_Get_Call { - return &GetInt_Get_Call{Call: _e.mock.On("Get", )} -} - -func (_c *GetInt_Get_Call) Run(run func()) *GetInt_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *GetInt_Get_Call) Return(n int) *GetInt_Get_Call { - _c.Call.Return(n) - return _c -} - -func (_c *GetInt_Get_Call) RunAndReturn(run func()int) *GetInt_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/HasConflictingNestedImports_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/HasConflictingNestedImports_mock.go deleted file mode 100644 index 901c7a71..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/HasConflictingNestedImports_mock.go +++ /dev/null @@ -1,153 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - http0 "github.com/vektra/mockery/v3/pkg/fixtures/http" - "net/http" - mock "github.com/stretchr/testify/mock" -) - - -// NewHasConflictingNestedImports creates a new instance of HasConflictingNestedImports. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewHasConflictingNestedImports (t interface { - mock.TestingT - Cleanup(func()) -}) *HasConflictingNestedImports { - mock := &HasConflictingNestedImports{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// HasConflictingNestedImports is an autogenerated mock type for the HasConflictingNestedImports type -type HasConflictingNestedImports struct { - mock.Mock -} - -type HasConflictingNestedImports_Expecter struct { - mock *mock.Mock -} - -func (_m *HasConflictingNestedImports) EXPECT() *HasConflictingNestedImports_Expecter { - return &HasConflictingNestedImports_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type HasConflictingNestedImports -func (_mock *HasConflictingNestedImports) Get(path string) (http.Response, error) { - ret := _mock.Called(path) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 http.Response - var r1 error - if returnFunc, ok := ret.Get(0).(func(string) (http.Response, error)); ok { - return returnFunc(path) - } - if returnFunc, ok := ret.Get(0).(func(string) http.Response); ok { - r0 = returnFunc(path) - } else { - r0 = ret.Get(0).(http.Response) - } - if returnFunc, ok := ret.Get(1).(func(string) error); ok { - r1 = returnFunc(path) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// HasConflictingNestedImports_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type HasConflictingNestedImports_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - path -func (_e *HasConflictingNestedImports_Expecter) Get(path interface{}, ) *HasConflictingNestedImports_Get_Call { - return &HasConflictingNestedImports_Get_Call{Call: _e.mock.On("Get",path, )} -} - -func (_c *HasConflictingNestedImports_Get_Call) Run(run func(path string)) *HasConflictingNestedImports_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *HasConflictingNestedImports_Get_Call) Return(response http.Response, err error) *HasConflictingNestedImports_Get_Call { - _c.Call.Return(response, err) - return _c -} - -func (_c *HasConflictingNestedImports_Get_Call) RunAndReturn(run func(path string)(http.Response, error)) *HasConflictingNestedImports_Get_Call { - _c.Call.Return(run) - return _c -} - - -// Z provides a mock function for the type HasConflictingNestedImports -func (_mock *HasConflictingNestedImports) Z() http0.MyStruct { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for Z") - } - - - var r0 http0.MyStruct - if returnFunc, ok := ret.Get(0).(func() http0.MyStruct); ok { - r0 = returnFunc() - } else { - r0 = ret.Get(0).(http0.MyStruct) - } - return r0 -} - - - -// HasConflictingNestedImports_Z_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Z' -type HasConflictingNestedImports_Z_Call struct { - *mock.Call -} - - - -// Z is a helper method to define mock.On call -func (_e *HasConflictingNestedImports_Expecter) Z() *HasConflictingNestedImports_Z_Call { - return &HasConflictingNestedImports_Z_Call{Call: _e.mock.On("Z", )} -} - -func (_c *HasConflictingNestedImports_Z_Call) Run(run func()) *HasConflictingNestedImports_Z_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *HasConflictingNestedImports_Z_Call) Return(myStruct http0.MyStruct) *HasConflictingNestedImports_Z_Call { - _c.Call.Return(myStruct) - return _c -} - -func (_c *HasConflictingNestedImports_Z_Call) RunAndReturn(run func()http0.MyStruct) *HasConflictingNestedImports_Z_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ImportsSameAsPackage_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ImportsSameAsPackage_mock.go deleted file mode 100644 index 3b2db42e..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ImportsSameAsPackage_mock.go +++ /dev/null @@ -1,183 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - test0 "github.com/vektra/mockery/v3/pkg/fixtures" - "github.com/vektra/mockery/v3/pkg/fixtures/redefined_type_b" - mock "github.com/stretchr/testify/mock" -) - - -// NewImportsSameAsPackage creates a new instance of ImportsSameAsPackage. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewImportsSameAsPackage (t interface { - mock.TestingT - Cleanup(func()) -}) *ImportsSameAsPackage { - mock := &ImportsSameAsPackage{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// ImportsSameAsPackage is an autogenerated mock type for the ImportsSameAsPackage type -type ImportsSameAsPackage struct { - mock.Mock -} - -type ImportsSameAsPackage_Expecter struct { - mock *mock.Mock -} - -func (_m *ImportsSameAsPackage) EXPECT() *ImportsSameAsPackage_Expecter { - return &ImportsSameAsPackage_Expecter{mock: &_m.Mock} -} - - - -// A provides a mock function for the type ImportsSameAsPackage -func (_mock *ImportsSameAsPackage) A() test.B { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for A") - } - - - var r0 test.B - if returnFunc, ok := ret.Get(0).(func() test.B); ok { - r0 = returnFunc() - } else { - r0 = ret.Get(0).(test.B) - } - return r0 -} - - - -// ImportsSameAsPackage_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A' -type ImportsSameAsPackage_A_Call struct { - *mock.Call -} - - - -// A is a helper method to define mock.On call -func (_e *ImportsSameAsPackage_Expecter) A() *ImportsSameAsPackage_A_Call { - return &ImportsSameAsPackage_A_Call{Call: _e.mock.On("A", )} -} - -func (_c *ImportsSameAsPackage_A_Call) Run(run func()) *ImportsSameAsPackage_A_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *ImportsSameAsPackage_A_Call) Return(b test.B) *ImportsSameAsPackage_A_Call { - _c.Call.Return(b) - return _c -} - -func (_c *ImportsSameAsPackage_A_Call) RunAndReturn(run func()test.B) *ImportsSameAsPackage_A_Call { - _c.Call.Return(run) - return _c -} - - -// B provides a mock function for the type ImportsSameAsPackage -func (_mock *ImportsSameAsPackage) B() test0.KeyManager { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for B") - } - - - var r0 test0.KeyManager - if returnFunc, ok := ret.Get(0).(func() test0.KeyManager); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(test0.KeyManager) - } - } - return r0 -} - - - -// ImportsSameAsPackage_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B' -type ImportsSameAsPackage_B_Call struct { - *mock.Call -} - - - -// B is a helper method to define mock.On call -func (_e *ImportsSameAsPackage_Expecter) B() *ImportsSameAsPackage_B_Call { - return &ImportsSameAsPackage_B_Call{Call: _e.mock.On("B", )} -} - -func (_c *ImportsSameAsPackage_B_Call) Run(run func()) *ImportsSameAsPackage_B_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *ImportsSameAsPackage_B_Call) Return(keyManager test0.KeyManager) *ImportsSameAsPackage_B_Call { - _c.Call.Return(keyManager) - return _c -} - -func (_c *ImportsSameAsPackage_B_Call) RunAndReturn(run func()test0.KeyManager) *ImportsSameAsPackage_B_Call { - _c.Call.Return(run) - return _c -} - - -// C provides a mock function for the type ImportsSameAsPackage -func (_mock *ImportsSameAsPackage) C(c test0.C) { _mock.Called(c) - return -} - - - -// ImportsSameAsPackage_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C' -type ImportsSameAsPackage_C_Call struct { - *mock.Call -} - - - -// C is a helper method to define mock.On call -// - c -func (_e *ImportsSameAsPackage_Expecter) C(c interface{}, ) *ImportsSameAsPackage_C_Call { - return &ImportsSameAsPackage_C_Call{Call: _e.mock.On("C",c, )} -} - -func (_c *ImportsSameAsPackage_C_Call) Run(run func(c test0.C)) *ImportsSameAsPackage_C_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(test0.C),) - }) - return _c -} - -func (_c *ImportsSameAsPackage_C_Call) Return() *ImportsSameAsPackage_C_Call { - _c.Call.Return() - return _c -} - -func (_c *ImportsSameAsPackage_C_Call) RunAndReturn(run func(c test0.C)) *ImportsSameAsPackage_C_Call { - _c.Run(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/InstantiatedGenericInterface_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/InstantiatedGenericInterface_mock.go deleted file mode 100644 index ea1998fd..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/InstantiatedGenericInterface_mock.go +++ /dev/null @@ -1,92 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewInstantiatedGenericInterface creates a new instance of InstantiatedGenericInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewInstantiatedGenericInterface (t interface { - mock.TestingT - Cleanup(func()) -}) *InstantiatedGenericInterface { - mock := &InstantiatedGenericInterface{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// InstantiatedGenericInterface is an autogenerated mock type for the InstantiatedGenericInterface type -type InstantiatedGenericInterface struct { - mock.Mock -} - -type InstantiatedGenericInterface_Expecter struct { - mock *mock.Mock -} - -func (_m *InstantiatedGenericInterface) EXPECT() *InstantiatedGenericInterface_Expecter { - return &InstantiatedGenericInterface_Expecter{mock: &_m.Mock} -} - - - -// Func provides a mock function for the type InstantiatedGenericInterface -func (_mock *InstantiatedGenericInterface) Func(arg *float32) int { - ret := _mock.Called(arg) - - if len(ret) == 0 { - panic("no return value specified for Func") - } - - - var r0 int - if returnFunc, ok := ret.Get(0).(func(*float32) int); ok { - r0 = returnFunc(arg) - } else { - r0 = ret.Get(0).(int) - } - return r0 -} - - - -// InstantiatedGenericInterface_Func_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Func' -type InstantiatedGenericInterface_Func_Call struct { - *mock.Call -} - - - -// Func is a helper method to define mock.On call -// - arg -func (_e *InstantiatedGenericInterface_Expecter) Func(arg interface{}, ) *InstantiatedGenericInterface_Func_Call { - return &InstantiatedGenericInterface_Func_Call{Call: _e.mock.On("Func",arg, )} -} - -func (_c *InstantiatedGenericInterface_Func_Call) Run(run func(arg *float32)) *InstantiatedGenericInterface_Func_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*float32),) - }) - return _c -} - -func (_c *InstantiatedGenericInterface_Func_Call) Return(n int) *InstantiatedGenericInterface_Func_Call { - _c.Call.Return(n) - return _c -} - -func (_c *InstantiatedGenericInterface_Func_Call) RunAndReturn(run func(arg *float32)int) *InstantiatedGenericInterface_Func_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Issue766_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Issue766_mock.go deleted file mode 100644 index cc28720e..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Issue766_mock.go +++ /dev/null @@ -1,103 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewIssue766 creates a new instance of Issue766. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewIssue766 (t interface { - mock.TestingT - Cleanup(func()) -}) *Issue766 { - mock := &Issue766{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// Issue766 is an autogenerated mock type for the Issue766 type -type Issue766 struct { - mock.Mock -} - -type Issue766_Expecter struct { - mock *mock.Mock -} - -func (_m *Issue766) EXPECT() *Issue766_Expecter { - return &Issue766_Expecter{mock: &_m.Mock} -} - - - -// FetchData provides a mock function for the type Issue766 -func (_mock *Issue766) FetchData(fetchFunc func(x ...int) ([]int, error)) ([]int, error) { - ret := _mock.Called(fetchFunc) - - if len(ret) == 0 { - panic("no return value specified for FetchData") - } - - - var r0 []int - var r1 error - if returnFunc, ok := ret.Get(0).(func(func(x ...int) ([]int, error)) ([]int, error)); ok { - return returnFunc(fetchFunc) - } - if returnFunc, ok := ret.Get(0).(func(func(x ...int) ([]int, error)) []int); ok { - r0 = returnFunc(fetchFunc) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]int) - } - } - if returnFunc, ok := ret.Get(1).(func(func(x ...int) ([]int, error)) error); ok { - r1 = returnFunc(fetchFunc) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// Issue766_FetchData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FetchData' -type Issue766_FetchData_Call struct { - *mock.Call -} - - - -// FetchData is a helper method to define mock.On call -// - fetchFunc -func (_e *Issue766_Expecter) FetchData(fetchFunc interface{}, ) *Issue766_FetchData_Call { - return &Issue766_FetchData_Call{Call: _e.mock.On("FetchData",fetchFunc, )} -} - -func (_c *Issue766_FetchData_Call) Run(run func(fetchFunc func(x ...int) ([]int, error))) *Issue766_FetchData_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(func(x ...int) ([]int, error)),) - }) - return _c -} - -func (_c *Issue766_FetchData_Call) Return(ints []int, err error) *Issue766_FetchData_Call { - _c.Call.Return(ints, err) - return _c -} - -func (_c *Issue766_FetchData_Call) RunAndReturn(run func(fetchFunc func(x ...int) ([]int, error))([]int, error)) *Issue766_FetchData_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/KeyManager_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/KeyManager_mock.go deleted file mode 100644 index 70dd369c..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/KeyManager_mock.go +++ /dev/null @@ -1,107 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "github.com/vektra/mockery/v3/pkg/fixtures" - mock "github.com/stretchr/testify/mock" -) - - -// NewKeyManager creates a new instance of KeyManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewKeyManager (t interface { - mock.TestingT - Cleanup(func()) -}) *KeyManager { - mock := &KeyManager{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// KeyManager is an autogenerated mock type for the KeyManager type -type KeyManager struct { - mock.Mock -} - -type KeyManager_Expecter struct { - mock *mock.Mock -} - -func (_m *KeyManager) EXPECT() *KeyManager_Expecter { - return &KeyManager_Expecter{mock: &_m.Mock} -} - - - -// GetKey provides a mock function for the type KeyManager -func (_mock *KeyManager) GetKey(s string, v uint16) ([]byte, *test.Err) { - ret := _mock.Called(s, v) - - if len(ret) == 0 { - panic("no return value specified for GetKey") - } - - - var r0 []byte - var r1 *test.Err - if returnFunc, ok := ret.Get(0).(func(string, uint16) ([]byte, *test.Err)); ok { - return returnFunc(s, v) - } - if returnFunc, ok := ret.Get(0).(func(string, uint16) []byte); ok { - r0 = returnFunc(s, v) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]byte) - } - } - if returnFunc, ok := ret.Get(1).(func(string, uint16) *test.Err); ok { - r1 = returnFunc(s, v) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(*test.Err) - } - } - return r0, r1 -} - - - -// KeyManager_GetKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKey' -type KeyManager_GetKey_Call struct { - *mock.Call -} - - - -// GetKey is a helper method to define mock.On call -// - s -// - v -func (_e *KeyManager_Expecter) GetKey(s interface{}, v interface{}, ) *KeyManager_GetKey_Call { - return &KeyManager_GetKey_Call{Call: _e.mock.On("GetKey",s,v, )} -} - -func (_c *KeyManager_GetKey_Call) Run(run func(s string, v uint16)) *KeyManager_GetKey_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),args[1].(uint16),) - }) - return _c -} - -func (_c *KeyManager_GetKey_Call) Return(bytes []byte, err *test.Err) *KeyManager_GetKey_Call { - _c.Call.Return(bytes, err) - return _c -} - -func (_c *KeyManager_GetKey_Call) RunAndReturn(run func(s string, v uint16)([]byte, *test.Err)) *KeyManager_GetKey_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/MapFunc_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/MapFunc_mock.go deleted file mode 100644 index 5960d34b..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/MapFunc_mock.go +++ /dev/null @@ -1,92 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewMapFunc creates a new instance of MapFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewMapFunc (t interface { - mock.TestingT - Cleanup(func()) -}) *MapFunc { - mock := &MapFunc{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// MapFunc is an autogenerated mock type for the MapFunc type -type MapFunc struct { - mock.Mock -} - -type MapFunc_Expecter struct { - mock *mock.Mock -} - -func (_m *MapFunc) EXPECT() *MapFunc_Expecter { - return &MapFunc_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type MapFunc -func (_mock *MapFunc) Get(m map[string]func(string) string) error { - ret := _mock.Called(m) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 error - if returnFunc, ok := ret.Get(0).(func(map[string]func(string) string) error); ok { - r0 = returnFunc(m) - } else { - r0 = ret.Error(0) - } - return r0 -} - - - -// MapFunc_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type MapFunc_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - m -func (_e *MapFunc_Expecter) Get(m interface{}, ) *MapFunc_Get_Call { - return &MapFunc_Get_Call{Call: _e.mock.On("Get",m, )} -} - -func (_c *MapFunc_Get_Call) Run(run func(m map[string]func(string) string)) *MapFunc_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(map[string]func(string) string),) - }) - return _c -} - -func (_c *MapFunc_Get_Call) Return(err error) *MapFunc_Get_Call { - _c.Call.Return(err) - return _c -} - -func (_c *MapFunc_Get_Call) RunAndReturn(run func(m map[string]func(string) string)error) *MapFunc_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/MapToInterface_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/MapToInterface_mock.go deleted file mode 100644 index babbbcbb..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/MapToInterface_mock.go +++ /dev/null @@ -1,89 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewMapToInterface creates a new instance of MapToInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewMapToInterface (t interface { - mock.TestingT - Cleanup(func()) -}) *MapToInterface { - mock := &MapToInterface{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// MapToInterface is an autogenerated mock type for the MapToInterface type -type MapToInterface struct { - mock.Mock -} - -type MapToInterface_Expecter struct { - mock *mock.Mock -} - -func (_m *MapToInterface) EXPECT() *MapToInterface_Expecter { - return &MapToInterface_Expecter{mock: &_m.Mock} -} - - - -// Foo provides a mock function for the type MapToInterface -func (_mock *MapToInterface) Foo(arg1 ...map[string]interface{}) { - if len(arg1) > 0 {_mock.Called(arg1) - } else {_mock.Called() - } - return -} - - - -// MapToInterface_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo' -type MapToInterface_Foo_Call struct { - *mock.Call -} - - - -// Foo is a helper method to define mock.On call -// - arg1 -func (_e *MapToInterface_Expecter) Foo(arg1 ...interface{}, ) *MapToInterface_Foo_Call { - return &MapToInterface_Foo_Call{Call: _e.mock.On("Foo", - append([]interface{}{ }, arg1... )... )} -} - -func (_c *MapToInterface_Foo_Call) Run(run func(arg1 ...map[string]interface{})) *MapToInterface_Foo_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]map[string]interface{}, len(args) - 0) - for i, a := range args[0:] { - if a != nil { - variadicArgs[i] = a.(map[string]interface{}) - } - } - run(variadicArgs...) - }) - return _c -} - -func (_c *MapToInterface_Foo_Call) Return() *MapToInterface_Foo_Call { - _c.Call.Return() - return _c -} - -func (_c *MapToInterface_Foo_Call) RunAndReturn(run func(arg1 ...map[string]interface{})) *MapToInterface_Foo_Call { - _c.Run(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/MyReader_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/MyReader_mock.go deleted file mode 100644 index c219c686..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/MyReader_mock.go +++ /dev/null @@ -1,101 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewMyReader creates a new instance of MyReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewMyReader (t interface { - mock.TestingT - Cleanup(func()) -}) *MyReader { - mock := &MyReader{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// MyReader is an autogenerated mock type for the MyReader type -type MyReader struct { - mock.Mock -} - -type MyReader_Expecter struct { - mock *mock.Mock -} - -func (_m *MyReader) EXPECT() *MyReader_Expecter { - return &MyReader_Expecter{mock: &_m.Mock} -} - - - -// Read provides a mock function for the type MyReader -func (_mock *MyReader) Read(p []byte) (int, error) { - ret := _mock.Called(p) - - if len(ret) == 0 { - panic("no return value specified for Read") - } - - - var r0 int - var r1 error - if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok { - return returnFunc(p) - } - if returnFunc, ok := ret.Get(0).(func([]byte) int); ok { - r0 = returnFunc(p) - } else { - r0 = ret.Get(0).(int) - } - if returnFunc, ok := ret.Get(1).(func([]byte) error); ok { - r1 = returnFunc(p) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// MyReader_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' -type MyReader_Read_Call struct { - *mock.Call -} - - - -// Read is a helper method to define mock.On call -// - p -func (_e *MyReader_Expecter) Read(p interface{}, ) *MyReader_Read_Call { - return &MyReader_Read_Call{Call: _e.mock.On("Read",p, )} -} - -func (_c *MyReader_Read_Call) Run(run func(p []byte)) *MyReader_Read_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].([]byte),) - }) - return _c -} - -func (_c *MyReader_Read_Call) Return(n int, err error) *MyReader_Read_Call { - _c.Call.Return(n, err) - return _c -} - -func (_c *MyReader_Read_Call) RunAndReturn(run func(p []byte)(int, error)) *MyReader_Read_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/PanicOnNoReturnValue_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/PanicOnNoReturnValue_mock.go deleted file mode 100644 index bb10ab40..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/PanicOnNoReturnValue_mock.go +++ /dev/null @@ -1,91 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewPanicOnNoReturnValue creates a new instance of PanicOnNoReturnValue. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewPanicOnNoReturnValue (t interface { - mock.TestingT - Cleanup(func()) -}) *PanicOnNoReturnValue { - mock := &PanicOnNoReturnValue{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// PanicOnNoReturnValue is an autogenerated mock type for the PanicOnNoReturnValue type -type PanicOnNoReturnValue struct { - mock.Mock -} - -type PanicOnNoReturnValue_Expecter struct { - mock *mock.Mock -} - -func (_m *PanicOnNoReturnValue) EXPECT() *PanicOnNoReturnValue_Expecter { - return &PanicOnNoReturnValue_Expecter{mock: &_m.Mock} -} - - - -// DoSomething provides a mock function for the type PanicOnNoReturnValue -func (_mock *PanicOnNoReturnValue) DoSomething() string { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for DoSomething") - } - - - var r0 string - if returnFunc, ok := ret.Get(0).(func() string); ok { - r0 = returnFunc() - } else { - r0 = ret.Get(0).(string) - } - return r0 -} - - - -// PanicOnNoReturnValue_DoSomething_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoSomething' -type PanicOnNoReturnValue_DoSomething_Call struct { - *mock.Call -} - - - -// DoSomething is a helper method to define mock.On call -func (_e *PanicOnNoReturnValue_Expecter) DoSomething() *PanicOnNoReturnValue_DoSomething_Call { - return &PanicOnNoReturnValue_DoSomething_Call{Call: _e.mock.On("DoSomething", )} -} - -func (_c *PanicOnNoReturnValue_DoSomething_Call) Run(run func()) *PanicOnNoReturnValue_DoSomething_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *PanicOnNoReturnValue_DoSomething_Call) Return(s string) *PanicOnNoReturnValue_DoSomething_Call { - _c.Call.Return(s) - return _c -} - -func (_c *PanicOnNoReturnValue_DoSomething_Call) RunAndReturn(run func()string) *PanicOnNoReturnValue_DoSomething_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ReplaceGenericSelf_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ReplaceGenericSelf_mock.go deleted file mode 100644 index 05e0b491..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ReplaceGenericSelf_mock.go +++ /dev/null @@ -1,93 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewReplaceGenericSelf creates a new instance of ReplaceGenericSelf. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewReplaceGenericSelf[T any] (t interface { - mock.TestingT - Cleanup(func()) -}) *ReplaceGenericSelf[T] { - mock := &ReplaceGenericSelf[T]{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// ReplaceGenericSelf is an autogenerated mock type for the ReplaceGenericSelf type -type ReplaceGenericSelf[T any] struct { - mock.Mock -} - -type ReplaceGenericSelf_Expecter[T any] struct { - mock *mock.Mock -} - -func (_m *ReplaceGenericSelf[T]) EXPECT() *ReplaceGenericSelf_Expecter[T] { - return &ReplaceGenericSelf_Expecter[T]{mock: &_m.Mock} -} - - - -// A provides a mock function for the type ReplaceGenericSelf -func (_mock *ReplaceGenericSelf[T]) A() T { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for A") - } - - - var r0 T - if returnFunc, ok := ret.Get(0).(func() T); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(T) - } - } - return r0 -} - - - -// ReplaceGenericSelf_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A' -type ReplaceGenericSelf_A_Call[T any] struct { - *mock.Call -} - - - -// A is a helper method to define mock.On call -func (_e *ReplaceGenericSelf_Expecter[T]) A() *ReplaceGenericSelf_A_Call[T] { - return &ReplaceGenericSelf_A_Call[T]{Call: _e.mock.On("A", )} -} - -func (_c *ReplaceGenericSelf_A_Call[T]) Run(run func()) *ReplaceGenericSelf_A_Call[T] { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *ReplaceGenericSelf_A_Call[T]) Return(v T) *ReplaceGenericSelf_A_Call[T] { - _c.Call.Return(v) - return _c -} - -func (_c *ReplaceGenericSelf_A_Call[T]) RunAndReturn(run func()T) *ReplaceGenericSelf_A_Call[T] { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ReplaceGeneric_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ReplaceGeneric_mock.go deleted file mode 100644 index f506456f..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/ReplaceGeneric_mock.go +++ /dev/null @@ -1,199 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "github.com/vektra/mockery/v3/pkg/fixtures/constraints" - mock "github.com/stretchr/testify/mock" -) - - -// NewReplaceGeneric creates a new instance of ReplaceGeneric. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewReplaceGeneric[TImport any, TConstraint constraints.Signed, TKeep any] (t interface { - mock.TestingT - Cleanup(func()) -}) *ReplaceGeneric[TImport, TConstraint, TKeep] { - mock := &ReplaceGeneric[TImport, TConstraint, TKeep]{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// ReplaceGeneric is an autogenerated mock type for the ReplaceGeneric type -type ReplaceGeneric[TImport any, TConstraint constraints.Signed, TKeep any] struct { - mock.Mock -} - -type ReplaceGeneric_Expecter[TImport any, TConstraint constraints.Signed, TKeep any] struct { - mock *mock.Mock -} - -func (_m *ReplaceGeneric[TImport, TConstraint, TKeep]) EXPECT() *ReplaceGeneric_Expecter[TImport, TConstraint, TKeep] { - return &ReplaceGeneric_Expecter[TImport, TConstraint, TKeep]{mock: &_m.Mock} -} - - - -// A provides a mock function for the type ReplaceGeneric -func (_mock *ReplaceGeneric[TImport, TConstraint, TKeep]) A(t1 TImport) TKeep { - ret := _mock.Called(t1) - - if len(ret) == 0 { - panic("no return value specified for A") - } - - - var r0 TKeep - if returnFunc, ok := ret.Get(0).(func(TImport) TKeep); ok { - r0 = returnFunc(t1) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(TKeep) - } - } - return r0 -} - - - -// ReplaceGeneric_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A' -type ReplaceGeneric_A_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct { - *mock.Call -} - - - -// A is a helper method to define mock.On call -// - t1 -func (_e *ReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) A(t1 interface{}, ) *ReplaceGeneric_A_Call[TImport, TConstraint, TKeep] { - return &ReplaceGeneric_A_Call[TImport, TConstraint, TKeep]{Call: _e.mock.On("A",t1, )} -} - -func (_c *ReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) Run(run func(t1 TImport)) *ReplaceGeneric_A_Call[TImport, TConstraint, TKeep] { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(TImport),) - }) - return _c -} - -func (_c *ReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) Return(v TKeep) *ReplaceGeneric_A_Call[TImport, TConstraint, TKeep] { - _c.Call.Return(v) - return _c -} - -func (_c *ReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func(t1 TImport)TKeep) *ReplaceGeneric_A_Call[TImport, TConstraint, TKeep] { - _c.Call.Return(run) - return _c -} - - -// B provides a mock function for the type ReplaceGeneric -func (_mock *ReplaceGeneric[TImport, TConstraint, TKeep]) B() TImport { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for B") - } - - - var r0 TImport - if returnFunc, ok := ret.Get(0).(func() TImport); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(TImport) - } - } - return r0 -} - - - -// ReplaceGeneric_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B' -type ReplaceGeneric_B_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct { - *mock.Call -} - - - -// B is a helper method to define mock.On call -func (_e *ReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) B() *ReplaceGeneric_B_Call[TImport, TConstraint, TKeep] { - return &ReplaceGeneric_B_Call[TImport, TConstraint, TKeep]{Call: _e.mock.On("B", )} -} - -func (_c *ReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) Run(run func()) *ReplaceGeneric_B_Call[TImport, TConstraint, TKeep] { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *ReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) Return(v TImport) *ReplaceGeneric_B_Call[TImport, TConstraint, TKeep] { - _c.Call.Return(v) - return _c -} - -func (_c *ReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func()TImport) *ReplaceGeneric_B_Call[TImport, TConstraint, TKeep] { - _c.Call.Return(run) - return _c -} - - -// C provides a mock function for the type ReplaceGeneric -func (_mock *ReplaceGeneric[TImport, TConstraint, TKeep]) C() TConstraint { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for C") - } - - - var r0 TConstraint - if returnFunc, ok := ret.Get(0).(func() TConstraint); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(TConstraint) - } - } - return r0 -} - - - -// ReplaceGeneric_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C' -type ReplaceGeneric_C_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct { - *mock.Call -} - - - -// C is a helper method to define mock.On call -func (_e *ReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) C() *ReplaceGeneric_C_Call[TImport, TConstraint, TKeep] { - return &ReplaceGeneric_C_Call[TImport, TConstraint, TKeep]{Call: _e.mock.On("C", )} -} - -func (_c *ReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) Run(run func()) *ReplaceGeneric_C_Call[TImport, TConstraint, TKeep] { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *ReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) Return(v TConstraint) *ReplaceGeneric_C_Call[TImport, TConstraint, TKeep] { - _c.Call.Return(v) - return _c -} - -func (_c *ReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func()TConstraint) *ReplaceGeneric_C_Call[TImport, TConstraint, TKeep] { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester2_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester2_mock.go deleted file mode 100644 index d7d4d489..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester2_mock.go +++ /dev/null @@ -1,92 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewRequester2 creates a new instance of Requester2. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequester2 (t interface { - mock.TestingT - Cleanup(func()) -}) *Requester2 { - mock := &Requester2{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// Requester2 is an autogenerated mock type for the Requester2 type -type Requester2 struct { - mock.Mock -} - -type Requester2_Expecter struct { - mock *mock.Mock -} - -func (_m *Requester2) EXPECT() *Requester2_Expecter { - return &Requester2_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type Requester2 -func (_mock *Requester2) Get(path string) error { - ret := _mock.Called(path) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 error - if returnFunc, ok := ret.Get(0).(func(string) error); ok { - r0 = returnFunc(path) - } else { - r0 = ret.Error(0) - } - return r0 -} - - - -// Requester2_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type Requester2_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - path -func (_e *Requester2_Expecter) Get(path interface{}, ) *Requester2_Get_Call { - return &Requester2_Get_Call{Call: _e.mock.On("Get",path, )} -} - -func (_c *Requester2_Get_Call) Run(run func(path string)) *Requester2_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *Requester2_Get_Call) Return(err error) *Requester2_Get_Call { - _c.Call.Return(err) - return _c -} - -func (_c *Requester2_Get_Call) RunAndReturn(run func(path string)error) *Requester2_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester3_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester3_mock.go deleted file mode 100644 index b8df3b71..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester3_mock.go +++ /dev/null @@ -1,91 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewRequester3 creates a new instance of Requester3. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequester3 (t interface { - mock.TestingT - Cleanup(func()) -}) *Requester3 { - mock := &Requester3{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// Requester3 is an autogenerated mock type for the Requester3 type -type Requester3 struct { - mock.Mock -} - -type Requester3_Expecter struct { - mock *mock.Mock -} - -func (_m *Requester3) EXPECT() *Requester3_Expecter { - return &Requester3_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type Requester3 -func (_mock *Requester3) Get() error { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 error - if returnFunc, ok := ret.Get(0).(func() error); ok { - r0 = returnFunc() - } else { - r0 = ret.Error(0) - } - return r0 -} - - - -// Requester3_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type Requester3_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -func (_e *Requester3_Expecter) Get() *Requester3_Get_Call { - return &Requester3_Get_Call{Call: _e.mock.On("Get", )} -} - -func (_c *Requester3_Get_Call) Run(run func()) *Requester3_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *Requester3_Get_Call) Return(err error) *Requester3_Get_Call { - _c.Call.Return(err) - return _c -} - -func (_c *Requester3_Get_Call) RunAndReturn(run func()error) *Requester3_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester4_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester4_mock.go deleted file mode 100644 index 6302bae1..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester4_mock.go +++ /dev/null @@ -1,78 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewRequester4 creates a new instance of Requester4. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequester4 (t interface { - mock.TestingT - Cleanup(func()) -}) *Requester4 { - mock := &Requester4{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// Requester4 is an autogenerated mock type for the Requester4 type -type Requester4 struct { - mock.Mock -} - -type Requester4_Expecter struct { - mock *mock.Mock -} - -func (_m *Requester4) EXPECT() *Requester4_Expecter { - return &Requester4_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type Requester4 -func (_mock *Requester4) Get() { _mock.Called() - return -} - - - -// Requester4_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type Requester4_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -func (_e *Requester4_Expecter) Get() *Requester4_Get_Call { - return &Requester4_Get_Call{Call: _e.mock.On("Get", )} -} - -func (_c *Requester4_Get_Call) Run(run func()) *Requester4_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *Requester4_Get_Call) Return() *Requester4_Get_Call { - _c.Call.Return() - return _c -} - -func (_c *Requester4_Get_Call) RunAndReturn(run func()) *Requester4_Get_Call { - _c.Run(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArgSameAsImport_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArgSameAsImport_mock.go deleted file mode 100644 index c995532e..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArgSameAsImport_mock.go +++ /dev/null @@ -1,95 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "encoding/json" - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterArgSameAsImport creates a new instance of RequesterArgSameAsImport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterArgSameAsImport (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterArgSameAsImport { - mock := &RequesterArgSameAsImport{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterArgSameAsImport is an autogenerated mock type for the RequesterArgSameAsImport type -type RequesterArgSameAsImport struct { - mock.Mock -} - -type RequesterArgSameAsImport_Expecter struct { - mock *mock.Mock -} - -func (_m *RequesterArgSameAsImport) EXPECT() *RequesterArgSameAsImport_Expecter { - return &RequesterArgSameAsImport_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type RequesterArgSameAsImport -func (_mock *RequesterArgSameAsImport) Get(json1 string) *json.RawMessage { - ret := _mock.Called(json1) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 *json.RawMessage - if returnFunc, ok := ret.Get(0).(func(string) *json.RawMessage); ok { - r0 = returnFunc(json1) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*json.RawMessage) - } - } - return r0 -} - - - -// RequesterArgSameAsImport_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type RequesterArgSameAsImport_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - json1 -func (_e *RequesterArgSameAsImport_Expecter) Get(json1 interface{}, ) *RequesterArgSameAsImport_Get_Call { - return &RequesterArgSameAsImport_Get_Call{Call: _e.mock.On("Get",json1, )} -} - -func (_c *RequesterArgSameAsImport_Get_Call) Run(run func(json1 string)) *RequesterArgSameAsImport_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *RequesterArgSameAsImport_Get_Call) Return(rawMessage *json.RawMessage) *RequesterArgSameAsImport_Get_Call { - _c.Call.Return(rawMessage) - return _c -} - -func (_c *RequesterArgSameAsImport_Get_Call) RunAndReturn(run func(json1 string)*json.RawMessage) *RequesterArgSameAsImport_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArgSameAsNamedImport_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArgSameAsNamedImport_mock.go deleted file mode 100644 index 9b7313ce..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArgSameAsNamedImport_mock.go +++ /dev/null @@ -1,95 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "encoding/json" - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterArgSameAsNamedImport creates a new instance of RequesterArgSameAsNamedImport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterArgSameAsNamedImport (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterArgSameAsNamedImport { - mock := &RequesterArgSameAsNamedImport{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterArgSameAsNamedImport is an autogenerated mock type for the RequesterArgSameAsNamedImport type -type RequesterArgSameAsNamedImport struct { - mock.Mock -} - -type RequesterArgSameAsNamedImport_Expecter struct { - mock *mock.Mock -} - -func (_m *RequesterArgSameAsNamedImport) EXPECT() *RequesterArgSameAsNamedImport_Expecter { - return &RequesterArgSameAsNamedImport_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type RequesterArgSameAsNamedImport -func (_mock *RequesterArgSameAsNamedImport) Get(json1 string) *json.RawMessage { - ret := _mock.Called(json1) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 *json.RawMessage - if returnFunc, ok := ret.Get(0).(func(string) *json.RawMessage); ok { - r0 = returnFunc(json1) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*json.RawMessage) - } - } - return r0 -} - - - -// RequesterArgSameAsNamedImport_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type RequesterArgSameAsNamedImport_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - json1 -func (_e *RequesterArgSameAsNamedImport_Expecter) Get(json1 interface{}, ) *RequesterArgSameAsNamedImport_Get_Call { - return &RequesterArgSameAsNamedImport_Get_Call{Call: _e.mock.On("Get",json1, )} -} - -func (_c *RequesterArgSameAsNamedImport_Get_Call) Run(run func(json1 string)) *RequesterArgSameAsNamedImport_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *RequesterArgSameAsNamedImport_Get_Call) Return(rawMessage *json.RawMessage) *RequesterArgSameAsNamedImport_Get_Call { - _c.Call.Return(rawMessage) - return _c -} - -func (_c *RequesterArgSameAsNamedImport_Get_Call) RunAndReturn(run func(json1 string)*json.RawMessage) *RequesterArgSameAsNamedImport_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArgSameAsPkg_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArgSameAsPkg_mock.go deleted file mode 100644 index 9b61f9d5..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArgSameAsPkg_mock.go +++ /dev/null @@ -1,79 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterArgSameAsPkg creates a new instance of RequesterArgSameAsPkg. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterArgSameAsPkg (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterArgSameAsPkg { - mock := &RequesterArgSameAsPkg{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterArgSameAsPkg is an autogenerated mock type for the RequesterArgSameAsPkg type -type RequesterArgSameAsPkg struct { - mock.Mock -} - -type RequesterArgSameAsPkg_Expecter struct { - mock *mock.Mock -} - -func (_m *RequesterArgSameAsPkg) EXPECT() *RequesterArgSameAsPkg_Expecter { - return &RequesterArgSameAsPkg_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type RequesterArgSameAsPkg -func (_mock *RequesterArgSameAsPkg) Get(test string) { _mock.Called(test) - return -} - - - -// RequesterArgSameAsPkg_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type RequesterArgSameAsPkg_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - test -func (_e *RequesterArgSameAsPkg_Expecter) Get(test interface{}, ) *RequesterArgSameAsPkg_Get_Call { - return &RequesterArgSameAsPkg_Get_Call{Call: _e.mock.On("Get",test, )} -} - -func (_c *RequesterArgSameAsPkg_Get_Call) Run(run func(test string)) *RequesterArgSameAsPkg_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *RequesterArgSameAsPkg_Get_Call) Return() *RequesterArgSameAsPkg_Get_Call { - _c.Call.Return() - return _c -} - -func (_c *RequesterArgSameAsPkg_Get_Call) RunAndReturn(run func(test string)) *RequesterArgSameAsPkg_Get_Call { - _c.Run(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArray_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArray_mock.go deleted file mode 100644 index fcf1548a..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterArray_mock.go +++ /dev/null @@ -1,103 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterArray creates a new instance of RequesterArray. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterArray (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterArray { - mock := &RequesterArray{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterArray is an autogenerated mock type for the RequesterArray type -type RequesterArray struct { - mock.Mock -} - -type RequesterArray_Expecter struct { - mock *mock.Mock -} - -func (_m *RequesterArray) EXPECT() *RequesterArray_Expecter { - return &RequesterArray_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type RequesterArray -func (_mock *RequesterArray) Get(path string) ([2]string, error) { - ret := _mock.Called(path) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 [2]string - var r1 error - if returnFunc, ok := ret.Get(0).(func(string) ([2]string, error)); ok { - return returnFunc(path) - } - if returnFunc, ok := ret.Get(0).(func(string) [2]string); ok { - r0 = returnFunc(path) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([2]string) - } - } - if returnFunc, ok := ret.Get(1).(func(string) error); ok { - r1 = returnFunc(path) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// RequesterArray_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type RequesterArray_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - path -func (_e *RequesterArray_Expecter) Get(path interface{}, ) *RequesterArray_Get_Call { - return &RequesterArray_Get_Call{Call: _e.mock.On("Get",path, )} -} - -func (_c *RequesterArray_Get_Call) Run(run func(path string)) *RequesterArray_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *RequesterArray_Get_Call) Return(strings [2]string, err error) *RequesterArray_Get_Call { - _c.Call.Return(strings, err) - return _c -} - -func (_c *RequesterArray_Get_Call) RunAndReturn(run func(path string)([2]string, error)) *RequesterArray_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterElided_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterElided_mock.go deleted file mode 100644 index 9dbc2e40..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterElided_mock.go +++ /dev/null @@ -1,93 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterElided creates a new instance of RequesterElided. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterElided (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterElided { - mock := &RequesterElided{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterElided is an autogenerated mock type for the RequesterElided type -type RequesterElided struct { - mock.Mock -} - -type RequesterElided_Expecter struct { - mock *mock.Mock -} - -func (_m *RequesterElided) EXPECT() *RequesterElided_Expecter { - return &RequesterElided_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type RequesterElided -func (_mock *RequesterElided) Get(path string, url string) error { - ret := _mock.Called(path, url) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 error - if returnFunc, ok := ret.Get(0).(func(string, string) error); ok { - r0 = returnFunc(path, url) - } else { - r0 = ret.Error(0) - } - return r0 -} - - - -// RequesterElided_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type RequesterElided_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - path -// - url -func (_e *RequesterElided_Expecter) Get(path interface{}, url interface{}, ) *RequesterElided_Get_Call { - return &RequesterElided_Get_Call{Call: _e.mock.On("Get",path,url, )} -} - -func (_c *RequesterElided_Get_Call) Run(run func(path string, url string)) *RequesterElided_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),args[1].(string),) - }) - return _c -} - -func (_c *RequesterElided_Get_Call) Return(err error) *RequesterElided_Get_Call { - _c.Call.Return(err) - return _c -} - -func (_c *RequesterElided_Get_Call) RunAndReturn(run func(path string, url string)error) *RequesterElided_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterGenerics_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterGenerics_mock.go deleted file mode 100644 index e44cdb4d..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterGenerics_mock.go +++ /dev/null @@ -1,211 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "github.com/vektra/mockery/v3/pkg/fixtures" - "github.com/vektra/mockery/v3/pkg/fixtures/constraints" - "io" - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterGenerics creates a new instance of RequesterGenerics. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterGenerics[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf test.GetInt, TExternalIntf io.Writer, TGenIntf test.GetGeneric[TSigned], TInlineType interface{~int | ~uint}, TInlineTypeGeneric interface{~int | test.GenericType[int, test.GetInt]; comparable}] (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - mock := &RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterGenerics is an autogenerated mock type for the RequesterGenerics type -type RequesterGenerics[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf test.GetInt, TExternalIntf io.Writer, TGenIntf test.GetGeneric[TSigned], TInlineType interface{~int | ~uint}, TInlineTypeGeneric interface{~int | test.GenericType[int, test.GetInt]; comparable}] struct { - mock.Mock -} - -type RequesterGenerics_Expecter[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf test.GetInt, TExternalIntf io.Writer, TGenIntf test.GetGeneric[TSigned], TInlineType interface{~int | ~uint}, TInlineTypeGeneric interface{~int | test.GenericType[int, test.GetInt]; comparable}] struct { - mock *mock.Mock -} - -func (_m *RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) EXPECT() *RequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - return &RequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{mock: &_m.Mock} -} - - - -// GenericAnonymousStructs provides a mock function for the type RequesterGenerics -func (_mock *RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericAnonymousStructs(val struct{Type1 TExternalIntf}) struct{Type2 test.GenericType[string, test.EmbeddedGet[int]]} { - ret := _mock.Called(val) - - if len(ret) == 0 { - panic("no return value specified for GenericAnonymousStructs") - } - - - var r0 struct{Type2 test.GenericType[string, test.EmbeddedGet[int]]} - if returnFunc, ok := ret.Get(0).(func(struct{Type1 TExternalIntf}) struct{Type2 test.GenericType[string, test.EmbeddedGet[int]]}); ok { - r0 = returnFunc(val) - } else { - r0 = ret.Get(0).(struct{Type2 test.GenericType[string, test.EmbeddedGet[int]]}) - } - return r0 -} - - - -// RequesterGenerics_GenericAnonymousStructs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericAnonymousStructs' -type RequesterGenerics_GenericAnonymousStructs_Call[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf test.GetInt, TExternalIntf io.Writer, TGenIntf test.GetGeneric[TSigned], TInlineType interface{~int | ~uint}, TInlineTypeGeneric interface{~int | test.GenericType[int, test.GetInt]; comparable}] struct { - *mock.Call -} - - - -// GenericAnonymousStructs is a helper method to define mock.On call -// - val -func (_e *RequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericAnonymousStructs(val interface{}, ) *RequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - return &RequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{Call: _e.mock.On("GenericAnonymousStructs",val, )} -} - -func (_c *RequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run(run func(val struct{Type1 TExternalIntf})) *RequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(struct{Type1 TExternalIntf}),) - }) - return _c -} - -func (_c *RequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return(val1 struct{Type2 test.GenericType[string, test.EmbeddedGet[int]]}) *RequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - _c.Call.Return(val1) - return _c -} - -func (_c *RequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn(run func(val struct{Type1 TExternalIntf})struct{Type2 test.GenericType[string, test.EmbeddedGet[int]]}) *RequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - _c.Call.Return(run) - return _c -} - - -// GenericArguments provides a mock function for the type RequesterGenerics -func (_mock *RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericArguments(v TAny, v1 TComparable) (TSigned, TIntf) { - ret := _mock.Called(v, v1) - - if len(ret) == 0 { - panic("no return value specified for GenericArguments") - } - - - var r0 TSigned - var r1 TIntf - if returnFunc, ok := ret.Get(0).(func(TAny, TComparable) (TSigned, TIntf)); ok { - return returnFunc(v, v1) - } - if returnFunc, ok := ret.Get(0).(func(TAny, TComparable) TSigned); ok { - r0 = returnFunc(v, v1) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(TSigned) - } - } - if returnFunc, ok := ret.Get(1).(func(TAny, TComparable) TIntf); ok { - r1 = returnFunc(v, v1) - } else { - if ret.Get(1) != nil { - r1 = ret.Get(1).(TIntf) - } - } - return r0, r1 -} - - - -// RequesterGenerics_GenericArguments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericArguments' -type RequesterGenerics_GenericArguments_Call[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf test.GetInt, TExternalIntf io.Writer, TGenIntf test.GetGeneric[TSigned], TInlineType interface{~int | ~uint}, TInlineTypeGeneric interface{~int | test.GenericType[int, test.GetInt]; comparable}] struct { - *mock.Call -} - - - -// GenericArguments is a helper method to define mock.On call -// - v -// - v1 -func (_e *RequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericArguments(v interface{}, v1 interface{}, ) *RequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - return &RequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{Call: _e.mock.On("GenericArguments",v,v1, )} -} - -func (_c *RequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run(run func(v TAny, v1 TComparable)) *RequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(TAny),args[1].(TComparable),) - }) - return _c -} - -func (_c *RequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return(v2 TSigned, v3 TIntf) *RequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - _c.Call.Return(v2, v3) - return _c -} - -func (_c *RequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn(run func(v TAny, v1 TComparable)(TSigned, TIntf)) *RequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - _c.Call.Return(run) - return _c -} - - -// GenericStructs provides a mock function for the type RequesterGenerics -func (_mock *RequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericStructs(genericType test.GenericType[TAny, TIntf]) test.GenericType[TSigned, TIntf] { - ret := _mock.Called(genericType) - - if len(ret) == 0 { - panic("no return value specified for GenericStructs") - } - - - var r0 test.GenericType[TSigned, TIntf] - if returnFunc, ok := ret.Get(0).(func(test.GenericType[TAny, TIntf]) test.GenericType[TSigned, TIntf]); ok { - r0 = returnFunc(genericType) - } else { - r0 = ret.Get(0).(test.GenericType[TSigned, TIntf]) - } - return r0 -} - - - -// RequesterGenerics_GenericStructs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericStructs' -type RequesterGenerics_GenericStructs_Call[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf test.GetInt, TExternalIntf io.Writer, TGenIntf test.GetGeneric[TSigned], TInlineType interface{~int | ~uint}, TInlineTypeGeneric interface{~int | test.GenericType[int, test.GetInt]; comparable}] struct { - *mock.Call -} - - - -// GenericStructs is a helper method to define mock.On call -// - genericType -func (_e *RequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericStructs(genericType interface{}, ) *RequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - return &RequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{Call: _e.mock.On("GenericStructs",genericType, )} -} - -func (_c *RequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run(run func(genericType test.GenericType[TAny, TIntf])) *RequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(test.GenericType[TAny, TIntf]),) - }) - return _c -} - -func (_c *RequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return(genericType1 test.GenericType[TSigned, TIntf]) *RequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - _c.Call.Return(genericType1) - return _c -} - -func (_c *RequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn(run func(genericType test.GenericType[TAny, TIntf])test.GenericType[TSigned, TIntf]) *RequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterIface_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterIface_mock.go deleted file mode 100644 index 1642eeee..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterIface_mock.go +++ /dev/null @@ -1,94 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "io" - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterIface creates a new instance of RequesterIface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterIface (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterIface { - mock := &RequesterIface{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterIface is an autogenerated mock type for the RequesterIface type -type RequesterIface struct { - mock.Mock -} - -type RequesterIface_Expecter struct { - mock *mock.Mock -} - -func (_m *RequesterIface) EXPECT() *RequesterIface_Expecter { - return &RequesterIface_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type RequesterIface -func (_mock *RequesterIface) Get() io.Reader { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 io.Reader - if returnFunc, ok := ret.Get(0).(func() io.Reader); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(io.Reader) - } - } - return r0 -} - - - -// RequesterIface_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type RequesterIface_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -func (_e *RequesterIface_Expecter) Get() *RequesterIface_Get_Call { - return &RequesterIface_Get_Call{Call: _e.mock.On("Get", )} -} - -func (_c *RequesterIface_Get_Call) Run(run func()) *RequesterIface_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *RequesterIface_Get_Call) Return(reader io.Reader) *RequesterIface_Get_Call { - _c.Call.Return(reader) - return _c -} - -func (_c *RequesterIface_Get_Call) RunAndReturn(run func()io.Reader) *RequesterIface_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterNS_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterNS_mock.go deleted file mode 100644 index cd767360..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterNS_mock.go +++ /dev/null @@ -1,102 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "net/http" - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterNS creates a new instance of RequesterNS. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterNS (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterNS { - mock := &RequesterNS{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterNS is an autogenerated mock type for the RequesterNS type -type RequesterNS struct { - mock.Mock -} - -type RequesterNS_Expecter struct { - mock *mock.Mock -} - -func (_m *RequesterNS) EXPECT() *RequesterNS_Expecter { - return &RequesterNS_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type RequesterNS -func (_mock *RequesterNS) Get(path string) (http.Response, error) { - ret := _mock.Called(path) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 http.Response - var r1 error - if returnFunc, ok := ret.Get(0).(func(string) (http.Response, error)); ok { - return returnFunc(path) - } - if returnFunc, ok := ret.Get(0).(func(string) http.Response); ok { - r0 = returnFunc(path) - } else { - r0 = ret.Get(0).(http.Response) - } - if returnFunc, ok := ret.Get(1).(func(string) error); ok { - r1 = returnFunc(path) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// RequesterNS_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type RequesterNS_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - path -func (_e *RequesterNS_Expecter) Get(path interface{}, ) *RequesterNS_Get_Call { - return &RequesterNS_Get_Call{Call: _e.mock.On("Get",path, )} -} - -func (_c *RequesterNS_Get_Call) Run(run func(path string)) *RequesterNS_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *RequesterNS_Get_Call) Return(response http.Response, err error) *RequesterNS_Get_Call { - _c.Call.Return(response, err) - return _c -} - -func (_c *RequesterNS_Get_Call) RunAndReturn(run func(path string)(http.Response, error)) *RequesterNS_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterPtr_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterPtr_mock.go deleted file mode 100644 index 526d6d20..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterPtr_mock.go +++ /dev/null @@ -1,103 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterPtr creates a new instance of RequesterPtr. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterPtr (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterPtr { - mock := &RequesterPtr{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterPtr is an autogenerated mock type for the RequesterPtr type -type RequesterPtr struct { - mock.Mock -} - -type RequesterPtr_Expecter struct { - mock *mock.Mock -} - -func (_m *RequesterPtr) EXPECT() *RequesterPtr_Expecter { - return &RequesterPtr_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type RequesterPtr -func (_mock *RequesterPtr) Get(path string) (*string, error) { - ret := _mock.Called(path) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 *string - var r1 error - if returnFunc, ok := ret.Get(0).(func(string) (*string, error)); ok { - return returnFunc(path) - } - if returnFunc, ok := ret.Get(0).(func(string) *string); ok { - r0 = returnFunc(path) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*string) - } - } - if returnFunc, ok := ret.Get(1).(func(string) error); ok { - r1 = returnFunc(path) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// RequesterPtr_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type RequesterPtr_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - path -func (_e *RequesterPtr_Expecter) Get(path interface{}, ) *RequesterPtr_Get_Call { - return &RequesterPtr_Get_Call{Call: _e.mock.On("Get",path, )} -} - -func (_c *RequesterPtr_Get_Call) Run(run func(path string)) *RequesterPtr_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *RequesterPtr_Get_Call) Return(s *string, err error) *RequesterPtr_Get_Call { - _c.Call.Return(s, err) - return _c -} - -func (_c *RequesterPtr_Get_Call) RunAndReturn(run func(path string)(*string, error)) *RequesterPtr_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterReturnElided_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterReturnElided_mock.go deleted file mode 100644 index 043915e3..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterReturnElided_mock.go +++ /dev/null @@ -1,173 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterReturnElided creates a new instance of RequesterReturnElided. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterReturnElided (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterReturnElided { - mock := &RequesterReturnElided{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterReturnElided is an autogenerated mock type for the RequesterReturnElided type -type RequesterReturnElided struct { - mock.Mock -} - -type RequesterReturnElided_Expecter struct { - mock *mock.Mock -} - -func (_m *RequesterReturnElided) EXPECT() *RequesterReturnElided_Expecter { - return &RequesterReturnElided_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type RequesterReturnElided -func (_mock *RequesterReturnElided) Get(path string) (int, int, int, error) { - ret := _mock.Called(path) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 int - var r1 int - var r2 int - var r3 error - if returnFunc, ok := ret.Get(0).(func(string) (int, int, int, error)); ok { - return returnFunc(path) - } - if returnFunc, ok := ret.Get(0).(func(string) int); ok { - r0 = returnFunc(path) - } else { - r0 = ret.Get(0).(int) - } - if returnFunc, ok := ret.Get(1).(func(string) int); ok { - r1 = returnFunc(path) - } else { - r1 = ret.Get(1).(int) - } - if returnFunc, ok := ret.Get(2).(func(string) int); ok { - r2 = returnFunc(path) - } else { - r2 = ret.Get(2).(int) - } - if returnFunc, ok := ret.Get(3).(func(string) error); ok { - r3 = returnFunc(path) - } else { - r3 = ret.Error(3) - } - return r0, r1, r2, r3 -} - - - -// RequesterReturnElided_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type RequesterReturnElided_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - path -func (_e *RequesterReturnElided_Expecter) Get(path interface{}, ) *RequesterReturnElided_Get_Call { - return &RequesterReturnElided_Get_Call{Call: _e.mock.On("Get",path, )} -} - -func (_c *RequesterReturnElided_Get_Call) Run(run func(path string)) *RequesterReturnElided_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *RequesterReturnElided_Get_Call) Return(a int, b int, c int, err error) *RequesterReturnElided_Get_Call { - _c.Call.Return(a, b, c, err) - return _c -} - -func (_c *RequesterReturnElided_Get_Call) RunAndReturn(run func(path string)(int, int, int, error)) *RequesterReturnElided_Get_Call { - _c.Call.Return(run) - return _c -} - - -// Put provides a mock function for the type RequesterReturnElided -func (_mock *RequesterReturnElided) Put(path string) (int, error) { - ret := _mock.Called(path) - - if len(ret) == 0 { - panic("no return value specified for Put") - } - - - var r0 int - var r1 error - if returnFunc, ok := ret.Get(0).(func(string) (int, error)); ok { - return returnFunc(path) - } - if returnFunc, ok := ret.Get(0).(func(string) int); ok { - r0 = returnFunc(path) - } else { - r0 = ret.Get(0).(int) - } - if returnFunc, ok := ret.Get(1).(func(string) error); ok { - r1 = returnFunc(path) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// RequesterReturnElided_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' -type RequesterReturnElided_Put_Call struct { - *mock.Call -} - - - -// Put is a helper method to define mock.On call -// - path -func (_e *RequesterReturnElided_Expecter) Put(path interface{}, ) *RequesterReturnElided_Put_Call { - return &RequesterReturnElided_Put_Call{Call: _e.mock.On("Put",path, )} -} - -func (_c *RequesterReturnElided_Put_Call) Run(run func(path string)) *RequesterReturnElided_Put_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *RequesterReturnElided_Put_Call) Return(n int, err error) *RequesterReturnElided_Put_Call { - _c.Call.Return(n, err) - return _c -} - -func (_c *RequesterReturnElided_Put_Call) RunAndReturn(run func(path string)(int, error)) *RequesterReturnElided_Put_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterSlice_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterSlice_mock.go deleted file mode 100644 index b0c585a8..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterSlice_mock.go +++ /dev/null @@ -1,103 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterSlice creates a new instance of RequesterSlice. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterSlice (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterSlice { - mock := &RequesterSlice{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterSlice is an autogenerated mock type for the RequesterSlice type -type RequesterSlice struct { - mock.Mock -} - -type RequesterSlice_Expecter struct { - mock *mock.Mock -} - -func (_m *RequesterSlice) EXPECT() *RequesterSlice_Expecter { - return &RequesterSlice_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type RequesterSlice -func (_mock *RequesterSlice) Get(path string) ([]string, error) { - ret := _mock.Called(path) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 []string - var r1 error - if returnFunc, ok := ret.Get(0).(func(string) ([]string, error)); ok { - return returnFunc(path) - } - if returnFunc, ok := ret.Get(0).(func(string) []string); ok { - r0 = returnFunc(path) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).([]string) - } - } - if returnFunc, ok := ret.Get(1).(func(string) error); ok { - r1 = returnFunc(path) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// RequesterSlice_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type RequesterSlice_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - path -func (_e *RequesterSlice_Expecter) Get(path interface{}, ) *RequesterSlice_Get_Call { - return &RequesterSlice_Get_Call{Call: _e.mock.On("Get",path, )} -} - -func (_c *RequesterSlice_Get_Call) Run(run func(path string)) *RequesterSlice_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *RequesterSlice_Get_Call) Return(strings []string, err error) *RequesterSlice_Get_Call { - _c.Call.Return(strings, err) - return _c -} - -func (_c *RequesterSlice_Get_Call) RunAndReturn(run func(path string)([]string, error)) *RequesterSlice_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterVariadicOneArgument_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterVariadicOneArgument_mock.go deleted file mode 100644 index b7fa5a9a..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterVariadicOneArgument_mock.go +++ /dev/null @@ -1,292 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "io" - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterVariadicOneArgument creates a new instance of RequesterVariadicOneArgument. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterVariadicOneArgument (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterVariadicOneArgument { - mock := &RequesterVariadicOneArgument{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterVariadicOneArgument is an autogenerated mock type for the RequesterVariadic type -type RequesterVariadicOneArgument struct { - mock.Mock -} - -type RequesterVariadicOneArgument_Expecter struct { - mock *mock.Mock -} - -func (_m *RequesterVariadicOneArgument) EXPECT() *RequesterVariadicOneArgument_Expecter { - return &RequesterVariadicOneArgument_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type RequesterVariadicOneArgument -func (_mock *RequesterVariadicOneArgument) Get(values ...string) bool { - var tmpRet mock.Arguments - if len(values) > 0 {tmpRet = _mock.Called(values) - } else {tmpRet = _mock.Called() - } - ret := tmpRet - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 bool - if returnFunc, ok := ret.Get(0).(func(...string) bool); ok { - r0 = returnFunc(values...) - } else { - r0 = ret.Get(0).(bool) - } - return r0 -} - - - -// RequesterVariadicOneArgument_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type RequesterVariadicOneArgument_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - values -func (_e *RequesterVariadicOneArgument_Expecter) Get(values ...interface{}, ) *RequesterVariadicOneArgument_Get_Call { - return &RequesterVariadicOneArgument_Get_Call{Call: _e.mock.On("Get", - append([]interface{}{ }, values... )... )} -} - -func (_c *RequesterVariadicOneArgument_Get_Call) Run(run func(values ...string)) *RequesterVariadicOneArgument_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]string, len(args) - 0) - for i, a := range args[0:] { - if a != nil { - variadicArgs[i] = a.(string) - } - } - run(variadicArgs...) - }) - return _c -} - -func (_c *RequesterVariadicOneArgument_Get_Call) Return(b bool) *RequesterVariadicOneArgument_Get_Call { - _c.Call.Return(b) - return _c -} - -func (_c *RequesterVariadicOneArgument_Get_Call) RunAndReturn(run func(values ...string)bool) *RequesterVariadicOneArgument_Get_Call { - _c.Call.Return(run) - return _c -} - - -// MultiWriteToFile provides a mock function for the type RequesterVariadicOneArgument -func (_mock *RequesterVariadicOneArgument) MultiWriteToFile(filename string, w ...io.Writer) string { - var tmpRet mock.Arguments - if len(w) > 0 {tmpRet = _mock.Called(filename, w) - } else {tmpRet = _mock.Called(filename) - } - ret := tmpRet - - if len(ret) == 0 { - panic("no return value specified for MultiWriteToFile") - } - - - var r0 string - if returnFunc, ok := ret.Get(0).(func(string, ...io.Writer) string); ok { - r0 = returnFunc(filename, w...) - } else { - r0 = ret.Get(0).(string) - } - return r0 -} - - - -// RequesterVariadicOneArgument_MultiWriteToFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiWriteToFile' -type RequesterVariadicOneArgument_MultiWriteToFile_Call struct { - *mock.Call -} - - - -// MultiWriteToFile is a helper method to define mock.On call -// - filename -// - w -func (_e *RequesterVariadicOneArgument_Expecter) MultiWriteToFile(filename interface{}, w ...interface{}, ) *RequesterVariadicOneArgument_MultiWriteToFile_Call { - return &RequesterVariadicOneArgument_MultiWriteToFile_Call{Call: _e.mock.On("MultiWriteToFile", - append([]interface{}{ filename, }, w... )... )} -} - -func (_c *RequesterVariadicOneArgument_MultiWriteToFile_Call) Run(run func(filename string, w ...io.Writer)) *RequesterVariadicOneArgument_MultiWriteToFile_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]io.Writer, len(args) - 1) - for i, a := range args[1:] { - if a != nil { - variadicArgs[i] = a.(io.Writer) - } - } - run(args[0].(string),variadicArgs...) - }) - return _c -} - -func (_c *RequesterVariadicOneArgument_MultiWriteToFile_Call) Return(s string) *RequesterVariadicOneArgument_MultiWriteToFile_Call { - _c.Call.Return(s) - return _c -} - -func (_c *RequesterVariadicOneArgument_MultiWriteToFile_Call) RunAndReturn(run func(filename string, w ...io.Writer)string) *RequesterVariadicOneArgument_MultiWriteToFile_Call { - _c.Call.Return(run) - return _c -} - - -// OneInterface provides a mock function for the type RequesterVariadicOneArgument -func (_mock *RequesterVariadicOneArgument) OneInterface(a ...interface{}) bool { - var tmpRet mock.Arguments - if len(a) > 0 {tmpRet = _mock.Called(a) - } else {tmpRet = _mock.Called() - } - ret := tmpRet - - if len(ret) == 0 { - panic("no return value specified for OneInterface") - } - - - var r0 bool - if returnFunc, ok := ret.Get(0).(func(...interface{}) bool); ok { - r0 = returnFunc(a...) - } else { - r0 = ret.Get(0).(bool) - } - return r0 -} - - - -// RequesterVariadicOneArgument_OneInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OneInterface' -type RequesterVariadicOneArgument_OneInterface_Call struct { - *mock.Call -} - - - -// OneInterface is a helper method to define mock.On call -// - a -func (_e *RequesterVariadicOneArgument_Expecter) OneInterface(a ...interface{}, ) *RequesterVariadicOneArgument_OneInterface_Call { - return &RequesterVariadicOneArgument_OneInterface_Call{Call: _e.mock.On("OneInterface", - append([]interface{}{ }, a... )... )} -} - -func (_c *RequesterVariadicOneArgument_OneInterface_Call) Run(run func(a ...interface{})) *RequesterVariadicOneArgument_OneInterface_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]interface{}, len(args) - 0) - for i, a := range args[0:] { - if a != nil { - variadicArgs[i] = a.(interface{}) - } - } - run(variadicArgs...) - }) - return _c -} - -func (_c *RequesterVariadicOneArgument_OneInterface_Call) Return(b bool) *RequesterVariadicOneArgument_OneInterface_Call { - _c.Call.Return(b) - return _c -} - -func (_c *RequesterVariadicOneArgument_OneInterface_Call) RunAndReturn(run func(a ...interface{})bool) *RequesterVariadicOneArgument_OneInterface_Call { - _c.Call.Return(run) - return _c -} - - -// Sprintf provides a mock function for the type RequesterVariadicOneArgument -func (_mock *RequesterVariadicOneArgument) Sprintf(format string, a ...interface{}) string { - var tmpRet mock.Arguments - if len(a) > 0 {tmpRet = _mock.Called(format, a) - } else {tmpRet = _mock.Called(format) - } - ret := tmpRet - - if len(ret) == 0 { - panic("no return value specified for Sprintf") - } - - - var r0 string - if returnFunc, ok := ret.Get(0).(func(string, ...interface{}) string); ok { - r0 = returnFunc(format, a...) - } else { - r0 = ret.Get(0).(string) - } - return r0 -} - - - -// RequesterVariadicOneArgument_Sprintf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sprintf' -type RequesterVariadicOneArgument_Sprintf_Call struct { - *mock.Call -} - - - -// Sprintf is a helper method to define mock.On call -// - format -// - a -func (_e *RequesterVariadicOneArgument_Expecter) Sprintf(format interface{}, a ...interface{}, ) *RequesterVariadicOneArgument_Sprintf_Call { - return &RequesterVariadicOneArgument_Sprintf_Call{Call: _e.mock.On("Sprintf", - append([]interface{}{ format, }, a... )... )} -} - -func (_c *RequesterVariadicOneArgument_Sprintf_Call) Run(run func(format string, a ...interface{})) *RequesterVariadicOneArgument_Sprintf_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]interface{}, len(args) - 1) - for i, a := range args[1:] { - if a != nil { - variadicArgs[i] = a.(interface{}) - } - } - run(args[0].(string),variadicArgs...) - }) - return _c -} - -func (_c *RequesterVariadicOneArgument_Sprintf_Call) Return(s string) *RequesterVariadicOneArgument_Sprintf_Call { - _c.Call.Return(s) - return _c -} - -func (_c *RequesterVariadicOneArgument_Sprintf_Call) RunAndReturn(run func(format string, a ...interface{})string) *RequesterVariadicOneArgument_Sprintf_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterVariadic_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterVariadic_mock.go deleted file mode 100644 index d653f9e2..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/RequesterVariadic_mock.go +++ /dev/null @@ -1,296 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "io" - mock "github.com/stretchr/testify/mock" -) - - -// NewRequesterVariadic creates a new instance of RequesterVariadic. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequesterVariadic (t interface { - mock.TestingT - Cleanup(func()) -}) *RequesterVariadic { - mock := &RequesterVariadic{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// RequesterVariadic is an autogenerated mock type for the RequesterVariadic type -type RequesterVariadic struct { - mock.Mock -} - -type RequesterVariadic_Expecter struct { - mock *mock.Mock -} - -func (_m *RequesterVariadic) EXPECT() *RequesterVariadic_Expecter { - return &RequesterVariadic_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type RequesterVariadic -func (_mock *RequesterVariadic) Get(values ...string) bool { - // string - _va := make([]interface{}, len(values)) - for _i := range values { - _va[_i] = values[_i] - } - var _ca []interface{} - _ca = append(_ca, _va...) - ret := _mock.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 bool - if returnFunc, ok := ret.Get(0).(func(...string) bool); ok { - r0 = returnFunc(values...) - } else { - r0 = ret.Get(0).(bool) - } - return r0 -} - - - -// RequesterVariadic_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type RequesterVariadic_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - values -func (_e *RequesterVariadic_Expecter) Get(values ...interface{}, ) *RequesterVariadic_Get_Call { - return &RequesterVariadic_Get_Call{Call: _e.mock.On("Get", - append([]interface{}{ }, values... )... )} -} - -func (_c *RequesterVariadic_Get_Call) Run(run func(values ...string)) *RequesterVariadic_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]string, len(args) - 0) - for i, a := range args[0:] { - if a != nil { - variadicArgs[i] = a.(string) - } - } - run(variadicArgs...) - }) - return _c -} - -func (_c *RequesterVariadic_Get_Call) Return(b bool) *RequesterVariadic_Get_Call { - _c.Call.Return(b) - return _c -} - -func (_c *RequesterVariadic_Get_Call) RunAndReturn(run func(values ...string)bool) *RequesterVariadic_Get_Call { - _c.Call.Return(run) - return _c -} - - -// MultiWriteToFile provides a mock function for the type RequesterVariadic -func (_mock *RequesterVariadic) MultiWriteToFile(filename string, w ...io.Writer) string { - // io.Writer - _va := make([]interface{}, len(w)) - for _i := range w { - _va[_i] = w[_i] - } - var _ca []interface{} - _ca = append(_ca, filename) - _ca = append(_ca, _va...) - ret := _mock.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for MultiWriteToFile") - } - - - var r0 string - if returnFunc, ok := ret.Get(0).(func(string, ...io.Writer) string); ok { - r0 = returnFunc(filename, w...) - } else { - r0 = ret.Get(0).(string) - } - return r0 -} - - - -// RequesterVariadic_MultiWriteToFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiWriteToFile' -type RequesterVariadic_MultiWriteToFile_Call struct { - *mock.Call -} - - - -// MultiWriteToFile is a helper method to define mock.On call -// - filename -// - w -func (_e *RequesterVariadic_Expecter) MultiWriteToFile(filename interface{}, w ...interface{}, ) *RequesterVariadic_MultiWriteToFile_Call { - return &RequesterVariadic_MultiWriteToFile_Call{Call: _e.mock.On("MultiWriteToFile", - append([]interface{}{ filename, }, w... )... )} -} - -func (_c *RequesterVariadic_MultiWriteToFile_Call) Run(run func(filename string, w ...io.Writer)) *RequesterVariadic_MultiWriteToFile_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]io.Writer, len(args) - 1) - for i, a := range args[1:] { - if a != nil { - variadicArgs[i] = a.(io.Writer) - } - } - run(args[0].(string),variadicArgs...) - }) - return _c -} - -func (_c *RequesterVariadic_MultiWriteToFile_Call) Return(s string) *RequesterVariadic_MultiWriteToFile_Call { - _c.Call.Return(s) - return _c -} - -func (_c *RequesterVariadic_MultiWriteToFile_Call) RunAndReturn(run func(filename string, w ...io.Writer)string) *RequesterVariadic_MultiWriteToFile_Call { - _c.Call.Return(run) - return _c -} - - -// OneInterface provides a mock function for the type RequesterVariadic -func (_mock *RequesterVariadic) OneInterface(a ...interface{}) bool { - var _ca []interface{} - _ca = append(_ca, a...) - ret := _mock.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for OneInterface") - } - - - var r0 bool - if returnFunc, ok := ret.Get(0).(func(...interface{}) bool); ok { - r0 = returnFunc(a...) - } else { - r0 = ret.Get(0).(bool) - } - return r0 -} - - - -// RequesterVariadic_OneInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OneInterface' -type RequesterVariadic_OneInterface_Call struct { - *mock.Call -} - - - -// OneInterface is a helper method to define mock.On call -// - a -func (_e *RequesterVariadic_Expecter) OneInterface(a ...interface{}, ) *RequesterVariadic_OneInterface_Call { - return &RequesterVariadic_OneInterface_Call{Call: _e.mock.On("OneInterface", - append([]interface{}{ }, a... )... )} -} - -func (_c *RequesterVariadic_OneInterface_Call) Run(run func(a ...interface{})) *RequesterVariadic_OneInterface_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]interface{}, len(args) - 0) - for i, a := range args[0:] { - if a != nil { - variadicArgs[i] = a.(interface{}) - } - } - run(variadicArgs...) - }) - return _c -} - -func (_c *RequesterVariadic_OneInterface_Call) Return(b bool) *RequesterVariadic_OneInterface_Call { - _c.Call.Return(b) - return _c -} - -func (_c *RequesterVariadic_OneInterface_Call) RunAndReturn(run func(a ...interface{})bool) *RequesterVariadic_OneInterface_Call { - _c.Call.Return(run) - return _c -} - - -// Sprintf provides a mock function for the type RequesterVariadic -func (_mock *RequesterVariadic) Sprintf(format string, a ...interface{}) string { - var _ca []interface{} - _ca = append(_ca, format) - _ca = append(_ca, a...) - ret := _mock.Called(_ca...) - - if len(ret) == 0 { - panic("no return value specified for Sprintf") - } - - - var r0 string - if returnFunc, ok := ret.Get(0).(func(string, ...interface{}) string); ok { - r0 = returnFunc(format, a...) - } else { - r0 = ret.Get(0).(string) - } - return r0 -} - - - -// RequesterVariadic_Sprintf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sprintf' -type RequesterVariadic_Sprintf_Call struct { - *mock.Call -} - - - -// Sprintf is a helper method to define mock.On call -// - format -// - a -func (_e *RequesterVariadic_Expecter) Sprintf(format interface{}, a ...interface{}, ) *RequesterVariadic_Sprintf_Call { - return &RequesterVariadic_Sprintf_Call{Call: _e.mock.On("Sprintf", - append([]interface{}{ format, }, a... )... )} -} - -func (_c *RequesterVariadic_Sprintf_Call) Run(run func(format string, a ...interface{})) *RequesterVariadic_Sprintf_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]interface{}, len(args) - 1) - for i, a := range args[1:] { - if a != nil { - variadicArgs[i] = a.(interface{}) - } - } - run(args[0].(string),variadicArgs...) - }) - return _c -} - -func (_c *RequesterVariadic_Sprintf_Call) Return(s string) *RequesterVariadic_Sprintf_Call { - _c.Call.Return(s) - return _c -} - -func (_c *RequesterVariadic_Sprintf_Call) RunAndReturn(run func(format string, a ...interface{})string) *RequesterVariadic_Sprintf_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester_mock.go deleted file mode 100644 index ca4c3f72..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Requester_mock.go +++ /dev/null @@ -1,101 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewRequester creates a new instance of Requester. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewRequester (t interface { - mock.TestingT - Cleanup(func()) -}) *Requester { - mock := &Requester{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// Requester is an autogenerated mock type for the Requester type -type Requester struct { - mock.Mock -} - -type Requester_Expecter struct { - mock *mock.Mock -} - -func (_m *Requester) EXPECT() *Requester_Expecter { - return &Requester_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type Requester -func (_mock *Requester) Get(path string) (string, error) { - ret := _mock.Called(path) - - if len(ret) == 0 { - panic("no return value specified for Get") - } - - - var r0 string - var r1 error - if returnFunc, ok := ret.Get(0).(func(string) (string, error)); ok { - return returnFunc(path) - } - if returnFunc, ok := ret.Get(0).(func(string) string); ok { - r0 = returnFunc(path) - } else { - r0 = ret.Get(0).(string) - } - if returnFunc, ok := ret.Get(1).(func(string) error); ok { - r1 = returnFunc(path) - } else { - r1 = ret.Error(1) - } - return r0, r1 -} - - - -// Requester_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type Requester_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -// - path -func (_e *Requester_Expecter) Get(path interface{}, ) *Requester_Get_Call { - return &Requester_Get_Call{Call: _e.mock.On("Get",path, )} -} - -func (_c *Requester_Get_Call) Run(run func(path string)) *Requester_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *Requester_Get_Call) Return(s string, err error) *Requester_Get_Call { - _c.Call.Return(s, err) - return _c -} - -func (_c *Requester_Get_Call) RunAndReturn(run func(path string)(string, error)) *Requester_Get_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Sibling_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Sibling_mock.go deleted file mode 100644 index 1a083369..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Sibling_mock.go +++ /dev/null @@ -1,78 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewSibling creates a new instance of Sibling. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewSibling (t interface { - mock.TestingT - Cleanup(func()) -}) *Sibling { - mock := &Sibling{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// Sibling is an autogenerated mock type for the Sibling type -type Sibling struct { - mock.Mock -} - -type Sibling_Expecter struct { - mock *mock.Mock -} - -func (_m *Sibling) EXPECT() *Sibling_Expecter { - return &Sibling_Expecter{mock: &_m.Mock} -} - - - -// DoSomething provides a mock function for the type Sibling -func (_mock *Sibling) DoSomething() { _mock.Called() - return -} - - - -// Sibling_DoSomething_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoSomething' -type Sibling_DoSomething_Call struct { - *mock.Call -} - - - -// DoSomething is a helper method to define mock.On call -func (_e *Sibling_Expecter) DoSomething() *Sibling_DoSomething_Call { - return &Sibling_DoSomething_Call{Call: _e.mock.On("DoSomething", )} -} - -func (_c *Sibling_DoSomething_Call) Run(run func()) *Sibling_DoSomething_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *Sibling_DoSomething_Call) Return() *Sibling_DoSomething_Call { - _c.Call.Return() - return _c -} - -func (_c *Sibling_DoSomething_Call) RunAndReturn(run func()) *Sibling_DoSomething_Call { - _c.Run(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/StructWithTag_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/StructWithTag_mock.go deleted file mode 100644 index 030ea358..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/StructWithTag_mock.go +++ /dev/null @@ -1,94 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewStructWithTag creates a new instance of StructWithTag. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewStructWithTag (t interface { - mock.TestingT - Cleanup(func()) -}) *StructWithTag { - mock := &StructWithTag{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// StructWithTag is an autogenerated mock type for the StructWithTag type -type StructWithTag struct { - mock.Mock -} - -type StructWithTag_Expecter struct { - mock *mock.Mock -} - -func (_m *StructWithTag) EXPECT() *StructWithTag_Expecter { - return &StructWithTag_Expecter{mock: &_m.Mock} -} - - - -// MethodA provides a mock function for the type StructWithTag -func (_mock *StructWithTag) MethodA(v *struct{FieldA int "json:\"field_a\""; FieldB int "json:\"field_b\" xml:\"field_b\""}) *struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""} { - ret := _mock.Called(v) - - if len(ret) == 0 { - panic("no return value specified for MethodA") - } - - - var r0 *struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""} - if returnFunc, ok := ret.Get(0).(func(*struct{FieldA int "json:\"field_a\""; FieldB int "json:\"field_b\" xml:\"field_b\""}) *struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""}); ok { - r0 = returnFunc(v) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(*struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""}) - } - } - return r0 -} - - - -// StructWithTag_MethodA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MethodA' -type StructWithTag_MethodA_Call struct { - *mock.Call -} - - - -// MethodA is a helper method to define mock.On call -// - v -func (_e *StructWithTag_Expecter) MethodA(v interface{}, ) *StructWithTag_MethodA_Call { - return &StructWithTag_MethodA_Call{Call: _e.mock.On("MethodA",v, )} -} - -func (_c *StructWithTag_MethodA_Call) Run(run func(v *struct{FieldA int "json:\"field_a\""; FieldB int "json:\"field_b\" xml:\"field_b\""})) *StructWithTag_MethodA_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*struct{FieldA int "json:\"field_a\""; FieldB int "json:\"field_b\" xml:\"field_b\""}),) - }) - return _c -} - -func (_c *StructWithTag_MethodA_Call) Return(val *struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""}) *StructWithTag_MethodA_Call { - _c.Call.Return(val) - return _c -} - -func (_c *StructWithTag_MethodA_Call) RunAndReturn(run func(v *struct{FieldA int "json:\"field_a\""; FieldB int "json:\"field_b\" xml:\"field_b\""})*struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""}) *StructWithTag_MethodA_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/UnsafeInterface_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/UnsafeInterface_mock.go deleted file mode 100644 index 091508b4..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/UnsafeInterface_mock.go +++ /dev/null @@ -1,80 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "unsafe" - mock "github.com/stretchr/testify/mock" -) - - -// NewUnsafeInterface creates a new instance of UnsafeInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewUnsafeInterface (t interface { - mock.TestingT - Cleanup(func()) -}) *UnsafeInterface { - mock := &UnsafeInterface{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// UnsafeInterface is an autogenerated mock type for the UnsafeInterface type -type UnsafeInterface struct { - mock.Mock -} - -type UnsafeInterface_Expecter struct { - mock *mock.Mock -} - -func (_m *UnsafeInterface) EXPECT() *UnsafeInterface_Expecter { - return &UnsafeInterface_Expecter{mock: &_m.Mock} -} - - - -// Do provides a mock function for the type UnsafeInterface -func (_mock *UnsafeInterface) Do(ptr *unsafe.Pointer) { _mock.Called(ptr) - return -} - - - -// UnsafeInterface_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do' -type UnsafeInterface_Do_Call struct { - *mock.Call -} - - - -// Do is a helper method to define mock.On call -// - ptr -func (_e *UnsafeInterface_Expecter) Do(ptr interface{}, ) *UnsafeInterface_Do_Call { - return &UnsafeInterface_Do_Call{Call: _e.mock.On("Do",ptr, )} -} - -func (_c *UnsafeInterface_Do_Call) Run(run func(ptr *unsafe.Pointer)) *UnsafeInterface_Do_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(*unsafe.Pointer),) - }) - return _c -} - -func (_c *UnsafeInterface_Do_Call) Return() *UnsafeInterface_Do_Call { - _c.Call.Return() - return _c -} - -func (_c *UnsafeInterface_Do_Call) RunAndReturn(run func(ptr *unsafe.Pointer)) *UnsafeInterface_Do_Call { - _c.Run(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/UsesAny_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/UsesAny_mock.go deleted file mode 100644 index 33a12385..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/UsesAny_mock.go +++ /dev/null @@ -1,93 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewUsesAny creates a new instance of UsesAny. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewUsesAny (t interface { - mock.TestingT - Cleanup(func()) -}) *UsesAny { - mock := &UsesAny{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// UsesAny is an autogenerated mock type for the UsesAny type -type UsesAny struct { - mock.Mock -} - -type UsesAny_Expecter struct { - mock *mock.Mock -} - -func (_m *UsesAny) EXPECT() *UsesAny_Expecter { - return &UsesAny_Expecter{mock: &_m.Mock} -} - - - -// GetReader provides a mock function for the type UsesAny -func (_mock *UsesAny) GetReader() any { - ret := _mock.Called() - - if len(ret) == 0 { - panic("no return value specified for GetReader") - } - - - var r0 any - if returnFunc, ok := ret.Get(0).(func() any); ok { - r0 = returnFunc() - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(any) - } - } - return r0 -} - - - -// UsesAny_GetReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReader' -type UsesAny_GetReader_Call struct { - *mock.Call -} - - - -// GetReader is a helper method to define mock.On call -func (_e *UsesAny_Expecter) GetReader() *UsesAny_GetReader_Call { - return &UsesAny_GetReader_Call{Call: _e.mock.On("GetReader", )} -} - -func (_c *UsesAny_GetReader_Call) Run(run func()) *UsesAny_GetReader_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *UsesAny_GetReader_Call) Return(v any) *UsesAny_GetReader_Call { - _c.Call.Return(v) - return _c -} - -func (_c *UsesAny_GetReader_Call) RunAndReturn(run func()any) *UsesAny_GetReader_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/UsesOtherPkgIface_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/UsesOtherPkgIface_mock.go deleted file mode 100644 index fe10ba06..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/UsesOtherPkgIface_mock.go +++ /dev/null @@ -1,80 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "github.com/vektra/mockery/v3/pkg/fixtures" - mock "github.com/stretchr/testify/mock" -) - - -// NewUsesOtherPkgIface creates a new instance of UsesOtherPkgIface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewUsesOtherPkgIface (t interface { - mock.TestingT - Cleanup(func()) -}) *UsesOtherPkgIface { - mock := &UsesOtherPkgIface{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// UsesOtherPkgIface is an autogenerated mock type for the UsesOtherPkgIface type -type UsesOtherPkgIface struct { - mock.Mock -} - -type UsesOtherPkgIface_Expecter struct { - mock *mock.Mock -} - -func (_m *UsesOtherPkgIface) EXPECT() *UsesOtherPkgIface_Expecter { - return &UsesOtherPkgIface_Expecter{mock: &_m.Mock} -} - - - -// DoSomethingElse provides a mock function for the type UsesOtherPkgIface -func (_mock *UsesOtherPkgIface) DoSomethingElse(obj test.Sibling) { _mock.Called(obj) - return -} - - - -// UsesOtherPkgIface_DoSomethingElse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoSomethingElse' -type UsesOtherPkgIface_DoSomethingElse_Call struct { - *mock.Call -} - - - -// DoSomethingElse is a helper method to define mock.On call -// - obj -func (_e *UsesOtherPkgIface_Expecter) DoSomethingElse(obj interface{}, ) *UsesOtherPkgIface_DoSomethingElse_Call { - return &UsesOtherPkgIface_DoSomethingElse_Call{Call: _e.mock.On("DoSomethingElse",obj, )} -} - -func (_c *UsesOtherPkgIface_DoSomethingElse_Call) Run(run func(obj test.Sibling)) *UsesOtherPkgIface_DoSomethingElse_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(test.Sibling),) - }) - return _c -} - -func (_c *UsesOtherPkgIface_DoSomethingElse_Call) Return() *UsesOtherPkgIface_DoSomethingElse_Call { - _c.Call.Return() - return _c -} - -func (_c *UsesOtherPkgIface_DoSomethingElse_Call) RunAndReturn(run func(obj test.Sibling)) *UsesOtherPkgIface_DoSomethingElse_Call { - _c.Run(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/VariadicNoReturnInterface_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/VariadicNoReturnInterface_mock.go deleted file mode 100644 index bdafe9ad..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/VariadicNoReturnInterface_mock.go +++ /dev/null @@ -1,90 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewVariadicNoReturnInterface creates a new instance of VariadicNoReturnInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewVariadicNoReturnInterface (t interface { - mock.TestingT - Cleanup(func()) -}) *VariadicNoReturnInterface { - mock := &VariadicNoReturnInterface{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// VariadicNoReturnInterface is an autogenerated mock type for the VariadicNoReturnInterface type -type VariadicNoReturnInterface struct { - mock.Mock -} - -type VariadicNoReturnInterface_Expecter struct { - mock *mock.Mock -} - -func (_m *VariadicNoReturnInterface) EXPECT() *VariadicNoReturnInterface_Expecter { - return &VariadicNoReturnInterface_Expecter{mock: &_m.Mock} -} - - - -// VariadicNoReturn provides a mock function for the type VariadicNoReturnInterface -func (_mock *VariadicNoReturnInterface) VariadicNoReturn(j int, is ...interface{}) { - if len(is) > 0 {_mock.Called(j, is) - } else {_mock.Called(j) - } - return -} - - - -// VariadicNoReturnInterface_VariadicNoReturn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicNoReturn' -type VariadicNoReturnInterface_VariadicNoReturn_Call struct { - *mock.Call -} - - - -// VariadicNoReturn is a helper method to define mock.On call -// - j -// - is -func (_e *VariadicNoReturnInterface_Expecter) VariadicNoReturn(j interface{}, is ...interface{}, ) *VariadicNoReturnInterface_VariadicNoReturn_Call { - return &VariadicNoReturnInterface_VariadicNoReturn_Call{Call: _e.mock.On("VariadicNoReturn", - append([]interface{}{ j, }, is... )... )} -} - -func (_c *VariadicNoReturnInterface_VariadicNoReturn_Call) Run(run func(j int, is ...interface{})) *VariadicNoReturnInterface_VariadicNoReturn_Call { - _c.Call.Run(func(args mock.Arguments) { - variadicArgs := make([]interface{}, len(args) - 1) - for i, a := range args[1:] { - if a != nil { - variadicArgs[i] = a.(interface{}) - } - } - run(args[0].(int),variadicArgs...) - }) - return _c -} - -func (_c *VariadicNoReturnInterface_VariadicNoReturn_Call) Return() *VariadicNoReturnInterface_VariadicNoReturn_Call { - _c.Call.Return() - return _c -} - -func (_c *VariadicNoReturnInterface_VariadicNoReturn_Call) RunAndReturn(run func(j int, is ...interface{})) *VariadicNoReturnInterface_VariadicNoReturn_Call { - _c.Run(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/VariadicReturnFunc_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/VariadicReturnFunc_mock.go deleted file mode 100644 index 0c4bb98b..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/VariadicReturnFunc_mock.go +++ /dev/null @@ -1,94 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewVariadicReturnFunc creates a new instance of VariadicReturnFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewVariadicReturnFunc (t interface { - mock.TestingT - Cleanup(func()) -}) *VariadicReturnFunc { - mock := &VariadicReturnFunc{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// VariadicReturnFunc is an autogenerated mock type for the VariadicReturnFunc type -type VariadicReturnFunc struct { - mock.Mock -} - -type VariadicReturnFunc_Expecter struct { - mock *mock.Mock -} - -func (_m *VariadicReturnFunc) EXPECT() *VariadicReturnFunc_Expecter { - return &VariadicReturnFunc_Expecter{mock: &_m.Mock} -} - - - -// SampleMethod provides a mock function for the type VariadicReturnFunc -func (_mock *VariadicReturnFunc) SampleMethod(str string) func(str string, arr []int, a ...interface{}) { - ret := _mock.Called(str) - - if len(ret) == 0 { - panic("no return value specified for SampleMethod") - } - - - var r0 func(str string, arr []int, a ...interface{}) - if returnFunc, ok := ret.Get(0).(func(string) func(str string, arr []int, a ...interface{})); ok { - r0 = returnFunc(str) - } else { - if ret.Get(0) != nil { - r0 = ret.Get(0).(func(str string, arr []int, a ...interface{})) - } - } - return r0 -} - - - -// VariadicReturnFunc_SampleMethod_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SampleMethod' -type VariadicReturnFunc_SampleMethod_Call struct { - *mock.Call -} - - - -// SampleMethod is a helper method to define mock.On call -// - str -func (_e *VariadicReturnFunc_Expecter) SampleMethod(str interface{}, ) *VariadicReturnFunc_SampleMethod_Call { - return &VariadicReturnFunc_SampleMethod_Call{Call: _e.mock.On("SampleMethod",str, )} -} - -func (_c *VariadicReturnFunc_SampleMethod_Call) Run(run func(str string)) *VariadicReturnFunc_SampleMethod_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),) - }) - return _c -} - -func (_c *VariadicReturnFunc_SampleMethod_Call) Return(fn func(str string, arr []int, a ...interface{})) *VariadicReturnFunc_SampleMethod_Call { - _c.Call.Return(fn) - return _c -} - -func (_c *VariadicReturnFunc_SampleMethod_Call) RunAndReturn(run func(str string)func(str string, arr []int, a ...interface{})) *VariadicReturnFunc_SampleMethod_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Variadic_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Variadic_mock.go deleted file mode 100644 index 73c65fdb..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/Variadic_mock.go +++ /dev/null @@ -1,94 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - "github.com/vektra/mockery/v3/pkg/fixtures" - mock "github.com/stretchr/testify/mock" -) - - -// NewVariadic creates a new instance of Variadic. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewVariadic (t interface { - mock.TestingT - Cleanup(func()) -}) *Variadic { - mock := &Variadic{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// Variadic is an autogenerated mock type for the Variadic type -type Variadic struct { - mock.Mock -} - -type Variadic_Expecter struct { - mock *mock.Mock -} - -func (_m *Variadic) EXPECT() *Variadic_Expecter { - return &Variadic_Expecter{mock: &_m.Mock} -} - - - -// VariadicFunction provides a mock function for the type Variadic -func (_mock *Variadic) VariadicFunction(str string, vFunc test.VariadicFunction) error { - ret := _mock.Called(str, vFunc) - - if len(ret) == 0 { - panic("no return value specified for VariadicFunction") - } - - - var r0 error - if returnFunc, ok := ret.Get(0).(func(string, test.VariadicFunction) error); ok { - r0 = returnFunc(str, vFunc) - } else { - r0 = ret.Error(0) - } - return r0 -} - - - -// Variadic_VariadicFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicFunction' -type Variadic_VariadicFunction_Call struct { - *mock.Call -} - - - -// VariadicFunction is a helper method to define mock.On call -// - str -// - vFunc -func (_e *Variadic_Expecter) VariadicFunction(str interface{}, vFunc interface{}, ) *Variadic_VariadicFunction_Call { - return &Variadic_VariadicFunction_Call{Call: _e.mock.On("VariadicFunction",str,vFunc, )} -} - -func (_c *Variadic_VariadicFunction_Call) Run(run func(str string, vFunc test.VariadicFunction)) *Variadic_VariadicFunction_Call { - _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string),args[1].(test.VariadicFunction),) - }) - return _c -} - -func (_c *Variadic_VariadicFunction_Call) Return(err error) *Variadic_VariadicFunction_Call { - _c.Call.Return(err) - return _c -} - -func (_c *Variadic_VariadicFunction_Call) RunAndReturn(run func(str string, vFunc test.VariadicFunction)error) *Variadic_VariadicFunction_Call { - _c.Call.Return(run) - return _c -} - - diff --git a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/requesterUnexported_mock.go b/mocks/github.com/vektra/mockery/v3/pkg/fixtures/requesterUnexported_mock.go deleted file mode 100644 index 139133e0..00000000 --- a/mocks/github.com/vektra/mockery/v3/pkg/fixtures/requesterUnexported_mock.go +++ /dev/null @@ -1,78 +0,0 @@ - -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package mocks - -import ( - mock "github.com/stretchr/testify/mock" -) - - -// NewrequesterUnexported creates a new instance of requesterUnexported. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. -// The first argument is typically a *testing.T value. -func NewrequesterUnexported (t interface { - mock.TestingT - Cleanup(func()) -}) *requesterUnexported { - mock := &requesterUnexported{} - mock.Mock.Test(t) - - t.Cleanup(func() { mock.AssertExpectations(t) }) - - return mock -} - - -// requesterUnexported is an autogenerated mock type for the requesterUnexported type -type requesterUnexported struct { - mock.Mock -} - -type requesterUnexported_Expecter struct { - mock *mock.Mock -} - -func (_m *requesterUnexported) EXPECT() *requesterUnexported_Expecter { - return &requesterUnexported_Expecter{mock: &_m.Mock} -} - - - -// Get provides a mock function for the type requesterUnexported -func (_mock *requesterUnexported) Get() { _mock.Called() - return -} - - - -// requesterUnexported_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' -type requesterUnexported_Get_Call struct { - *mock.Call -} - - - -// Get is a helper method to define mock.On call -func (_e *requesterUnexported_Expecter) Get() *requesterUnexported_Get_Call { - return &requesterUnexported_Get_Call{Call: _e.mock.On("Get", )} -} - -func (_c *requesterUnexported_Get_Call) Run(run func()) *requesterUnexported_Get_Call { - _c.Call.Run(func(args mock.Arguments) { - run() - }) - return _c -} - -func (_c *requesterUnexported_Get_Call) Return() *requesterUnexported_Get_Call { - _c.Call.Return() - return _c -} - -func (_c *requesterUnexported_Get_Call) RunAndReturn(run func()) *requesterUnexported_Get_Call { - _c.Run(run) - return _c -} - - diff --git a/mocks/moq/github.com/vektra/mockery/v3/pkg/fixtures/moq_test.go b/mocks/moq/github.com/vektra/mockery/v3/pkg/fixtures/moq_test.go deleted file mode 100644 index 4b801a60..00000000 --- a/mocks/moq/github.com/vektra/mockery/v3/pkg/fixtures/moq_test.go +++ /dev/null @@ -1,4530 +0,0 @@ -// Code generated by mockery; DO NOT EDIT. -// github.com/vektra/mockery - -package test - -import ( - "encoding/json" - "io" - "net/http" - "sync" - - test "github.com/vektra/mockery/v3/pkg/fixtures" - http1 "github.com/vektra/mockery/v3/pkg/fixtures/12345678/http" - "github.com/vektra/mockery/v3/pkg/fixtures/constraints" - http0 "github.com/vektra/mockery/v3/pkg/fixtures/http" - test0 "github.com/vektra/mockery/v3/pkg/fixtures/redefined_type_b" -) - -// UsesAnyMock is a mock implementation of test.UsesAny. -// -// func TestSomethingThatUsesUsesAny(t *testing.T) { -// -// // make and configure a mocked test.UsesAny -// mockedUsesAny := &UsesAnyMock{ -// GetReaderFunc: func() any { -// panic("mock out the GetReader method") -// }, -// } -// -// // use mockedUsesAny in code that requires test.UsesAny -// // and then make assertions. -// -// } -type UsesAnyMock struct { - // GetReaderFunc mocks the GetReader method. - GetReaderFunc func() any - - // calls tracks calls to the methods. - calls struct { - // GetReader holds details about calls to the GetReader method. - GetReader []struct { - } - } - lockGetReader sync.RWMutex -} - -// GetReader calls GetReaderFunc. -func (mock *UsesAnyMock) GetReader() any { - if mock.GetReaderFunc == nil { - panic("UsesAnyMock.GetReaderFunc: method is nil but UsesAny.GetReader was just called") - } - callInfo := struct { - }{} - mock.lockGetReader.Lock() - mock.calls.GetReader = append(mock.calls.GetReader, callInfo) - mock.lockGetReader.Unlock() - return mock.GetReaderFunc() -} - -// GetReaderCalls gets all the calls that were made to GetReader. -// Check the length with: -// -// len(mockedUsesAny.GetReaderCalls()) -func (mock *UsesAnyMock) GetReaderCalls() []struct { -} { - var calls []struct { - } - mock.lockGetReader.RLock() - calls = mock.calls.GetReader - mock.lockGetReader.RUnlock() - return calls -} - -// ResetGetReaderCalls reset all the calls that were made to GetReader. -func (mock *UsesAnyMock) ResetGetReaderCalls() { - mock.lockGetReader.Lock() - mock.calls.GetReader = nil - mock.lockGetReader.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *UsesAnyMock) ResetCalls() { - mock.lockGetReader.Lock() - mock.calls.GetReader = nil - mock.lockGetReader.Unlock() -} - -// FooerMock is a mock implementation of test.Fooer. -// -// func TestSomethingThatUsesFooer(t *testing.T) { -// -// // make and configure a mocked test.Fooer -// mockedFooer := &FooerMock{ -// BarFunc: func(f func([]int)) { -// panic("mock out the Bar method") -// }, -// BazFunc: func(path string) func(x string) string { -// panic("mock out the Baz method") -// }, -// FooFunc: func(f func(x string) string) error { -// panic("mock out the Foo method") -// }, -// } -// -// // use mockedFooer in code that requires test.Fooer -// // and then make assertions. -// -// } -type FooerMock struct { - // BarFunc mocks the Bar method. - BarFunc func(f func([]int)) - - // BazFunc mocks the Baz method. - BazFunc func(path string) func(x string) string - - // FooFunc mocks the Foo method. - FooFunc func(f func(x string) string) error - - // calls tracks calls to the methods. - calls struct { - // Bar holds details about calls to the Bar method. - Bar []struct { - // F is the f argument value. - F func([]int) - } - // Baz holds details about calls to the Baz method. - Baz []struct { - // Path is the path argument value. - Path string - } - // Foo holds details about calls to the Foo method. - Foo []struct { - // F is the f argument value. - F func(x string) string - } - } - lockBar sync.RWMutex - lockBaz sync.RWMutex - lockFoo sync.RWMutex -} - -// Bar calls BarFunc. -func (mock *FooerMock) Bar(f func([]int)) { - if mock.BarFunc == nil { - panic("FooerMock.BarFunc: method is nil but Fooer.Bar was just called") - } - callInfo := struct { - F func([]int) - }{ - F: f, - } - mock.lockBar.Lock() - mock.calls.Bar = append(mock.calls.Bar, callInfo) - mock.lockBar.Unlock() - mock.BarFunc(f) -} - -// BarCalls gets all the calls that were made to Bar. -// Check the length with: -// -// len(mockedFooer.BarCalls()) -func (mock *FooerMock) BarCalls() []struct { - F func([]int) -} { - var calls []struct { - F func([]int) - } - mock.lockBar.RLock() - calls = mock.calls.Bar - mock.lockBar.RUnlock() - return calls -} - -// ResetBarCalls reset all the calls that were made to Bar. -func (mock *FooerMock) ResetBarCalls() { - mock.lockBar.Lock() - mock.calls.Bar = nil - mock.lockBar.Unlock() -} - -// Baz calls BazFunc. -func (mock *FooerMock) Baz(path string) func(x string) string { - if mock.BazFunc == nil { - panic("FooerMock.BazFunc: method is nil but Fooer.Baz was just called") - } - callInfo := struct { - Path string - }{ - Path: path, - } - mock.lockBaz.Lock() - mock.calls.Baz = append(mock.calls.Baz, callInfo) - mock.lockBaz.Unlock() - return mock.BazFunc(path) -} - -// BazCalls gets all the calls that were made to Baz. -// Check the length with: -// -// len(mockedFooer.BazCalls()) -func (mock *FooerMock) BazCalls() []struct { - Path string -} { - var calls []struct { - Path string - } - mock.lockBaz.RLock() - calls = mock.calls.Baz - mock.lockBaz.RUnlock() - return calls -} - -// ResetBazCalls reset all the calls that were made to Baz. -func (mock *FooerMock) ResetBazCalls() { - mock.lockBaz.Lock() - mock.calls.Baz = nil - mock.lockBaz.Unlock() -} - -// Foo calls FooFunc. -func (mock *FooerMock) Foo(f func(x string) string) error { - if mock.FooFunc == nil { - panic("FooerMock.FooFunc: method is nil but Fooer.Foo was just called") - } - callInfo := struct { - F func(x string) string - }{ - F: f, - } - mock.lockFoo.Lock() - mock.calls.Foo = append(mock.calls.Foo, callInfo) - mock.lockFoo.Unlock() - return mock.FooFunc(f) -} - -// FooCalls gets all the calls that were made to Foo. -// Check the length with: -// -// len(mockedFooer.FooCalls()) -func (mock *FooerMock) FooCalls() []struct { - F func(x string) string -} { - var calls []struct { - F func(x string) string - } - mock.lockFoo.RLock() - calls = mock.calls.Foo - mock.lockFoo.RUnlock() - return calls -} - -// ResetFooCalls reset all the calls that were made to Foo. -func (mock *FooerMock) ResetFooCalls() { - mock.lockFoo.Lock() - mock.calls.Foo = nil - mock.lockFoo.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *FooerMock) ResetCalls() { - mock.lockBar.Lock() - mock.calls.Bar = nil - mock.lockBar.Unlock() - - mock.lockBaz.Lock() - mock.calls.Baz = nil - mock.lockBaz.Unlock() - - mock.lockFoo.Lock() - mock.calls.Foo = nil - mock.lockFoo.Unlock() -} - -// MapFuncMock is a mock implementation of test.MapFunc. -// -// func TestSomethingThatUsesMapFunc(t *testing.T) { -// -// // make and configure a mocked test.MapFunc -// mockedMapFunc := &MapFuncMock{ -// GetFunc: func(m map[string]func(string) string) error { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedMapFunc in code that requires test.MapFunc -// // and then make assertions. -// -// } -type MapFuncMock struct { - // GetFunc mocks the Get method. - GetFunc func(m map[string]func(string) string) error - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // M is the m argument value. - M map[string]func(string) string - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *MapFuncMock) Get(m map[string]func(string) string) error { - if mock.GetFunc == nil { - panic("MapFuncMock.GetFunc: method is nil but MapFunc.Get was just called") - } - callInfo := struct { - M map[string]func(string) string - }{ - M: m, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(m) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedMapFunc.GetCalls()) -func (mock *MapFuncMock) GetCalls() []struct { - M map[string]func(string) string -} { - var calls []struct { - M map[string]func(string) string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *MapFuncMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *MapFuncMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// AsyncProducerMock is a mock implementation of test.AsyncProducer. -// -// func TestSomethingThatUsesAsyncProducer(t *testing.T) { -// -// // make and configure a mocked test.AsyncProducer -// mockedAsyncProducer := &AsyncProducerMock{ -// InputFunc: func() chan<- bool { -// panic("mock out the Input method") -// }, -// OutputFunc: func() <-chan bool { -// panic("mock out the Output method") -// }, -// WhateverFunc: func() chan bool { -// panic("mock out the Whatever method") -// }, -// } -// -// // use mockedAsyncProducer in code that requires test.AsyncProducer -// // and then make assertions. -// -// } -type AsyncProducerMock struct { - // InputFunc mocks the Input method. - InputFunc func() chan<- bool - - // OutputFunc mocks the Output method. - OutputFunc func() <-chan bool - - // WhateverFunc mocks the Whatever method. - WhateverFunc func() chan bool - - // calls tracks calls to the methods. - calls struct { - // Input holds details about calls to the Input method. - Input []struct { - } - // Output holds details about calls to the Output method. - Output []struct { - } - // Whatever holds details about calls to the Whatever method. - Whatever []struct { - } - } - lockInput sync.RWMutex - lockOutput sync.RWMutex - lockWhatever sync.RWMutex -} - -// Input calls InputFunc. -func (mock *AsyncProducerMock) Input() chan<- bool { - if mock.InputFunc == nil { - panic("AsyncProducerMock.InputFunc: method is nil but AsyncProducer.Input was just called") - } - callInfo := struct { - }{} - mock.lockInput.Lock() - mock.calls.Input = append(mock.calls.Input, callInfo) - mock.lockInput.Unlock() - return mock.InputFunc() -} - -// InputCalls gets all the calls that were made to Input. -// Check the length with: -// -// len(mockedAsyncProducer.InputCalls()) -func (mock *AsyncProducerMock) InputCalls() []struct { -} { - var calls []struct { - } - mock.lockInput.RLock() - calls = mock.calls.Input - mock.lockInput.RUnlock() - return calls -} - -// ResetInputCalls reset all the calls that were made to Input. -func (mock *AsyncProducerMock) ResetInputCalls() { - mock.lockInput.Lock() - mock.calls.Input = nil - mock.lockInput.Unlock() -} - -// Output calls OutputFunc. -func (mock *AsyncProducerMock) Output() <-chan bool { - if mock.OutputFunc == nil { - panic("AsyncProducerMock.OutputFunc: method is nil but AsyncProducer.Output was just called") - } - callInfo := struct { - }{} - mock.lockOutput.Lock() - mock.calls.Output = append(mock.calls.Output, callInfo) - mock.lockOutput.Unlock() - return mock.OutputFunc() -} - -// OutputCalls gets all the calls that were made to Output. -// Check the length with: -// -// len(mockedAsyncProducer.OutputCalls()) -func (mock *AsyncProducerMock) OutputCalls() []struct { -} { - var calls []struct { - } - mock.lockOutput.RLock() - calls = mock.calls.Output - mock.lockOutput.RUnlock() - return calls -} - -// ResetOutputCalls reset all the calls that were made to Output. -func (mock *AsyncProducerMock) ResetOutputCalls() { - mock.lockOutput.Lock() - mock.calls.Output = nil - mock.lockOutput.Unlock() -} - -// Whatever calls WhateverFunc. -func (mock *AsyncProducerMock) Whatever() chan bool { - if mock.WhateverFunc == nil { - panic("AsyncProducerMock.WhateverFunc: method is nil but AsyncProducer.Whatever was just called") - } - callInfo := struct { - }{} - mock.lockWhatever.Lock() - mock.calls.Whatever = append(mock.calls.Whatever, callInfo) - mock.lockWhatever.Unlock() - return mock.WhateverFunc() -} - -// WhateverCalls gets all the calls that were made to Whatever. -// Check the length with: -// -// len(mockedAsyncProducer.WhateverCalls()) -func (mock *AsyncProducerMock) WhateverCalls() []struct { -} { - var calls []struct { - } - mock.lockWhatever.RLock() - calls = mock.calls.Whatever - mock.lockWhatever.RUnlock() - return calls -} - -// ResetWhateverCalls reset all the calls that were made to Whatever. -func (mock *AsyncProducerMock) ResetWhateverCalls() { - mock.lockWhatever.Lock() - mock.calls.Whatever = nil - mock.lockWhatever.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *AsyncProducerMock) ResetCalls() { - mock.lockInput.Lock() - mock.calls.Input = nil - mock.lockInput.Unlock() - - mock.lockOutput.Lock() - mock.calls.Output = nil - mock.lockOutput.Unlock() - - mock.lockWhatever.Lock() - mock.calls.Whatever = nil - mock.lockWhatever.Unlock() -} - -// ConsulLockMock is a mock implementation of test.ConsulLock. -// -// func TestSomethingThatUsesConsulLock(t *testing.T) { -// -// // make and configure a mocked test.ConsulLock -// mockedConsulLock := &ConsulLockMock{ -// LockFunc: func(valCh <-chan struct{}) (<-chan struct{}, error) { -// panic("mock out the Lock method") -// }, -// UnlockFunc: func() error { -// panic("mock out the Unlock method") -// }, -// } -// -// // use mockedConsulLock in code that requires test.ConsulLock -// // and then make assertions. -// -// } -type ConsulLockMock struct { - // LockFunc mocks the Lock method. - LockFunc func(valCh <-chan struct{}) (<-chan struct{}, error) - - // UnlockFunc mocks the Unlock method. - UnlockFunc func() error - - // calls tracks calls to the methods. - calls struct { - // Lock holds details about calls to the Lock method. - Lock []struct { - // ValCh is the valCh argument value. - ValCh <-chan struct{} - } - // Unlock holds details about calls to the Unlock method. - Unlock []struct { - } - } - lockLock sync.RWMutex - lockUnlock sync.RWMutex -} - -// Lock calls LockFunc. -func (mock *ConsulLockMock) Lock(valCh <-chan struct{}) (<-chan struct{}, error) { - if mock.LockFunc == nil { - panic("ConsulLockMock.LockFunc: method is nil but ConsulLock.Lock was just called") - } - callInfo := struct { - ValCh <-chan struct{} - }{ - ValCh: valCh, - } - mock.lockLock.Lock() - mock.calls.Lock = append(mock.calls.Lock, callInfo) - mock.lockLock.Unlock() - return mock.LockFunc(valCh) -} - -// LockCalls gets all the calls that were made to Lock. -// Check the length with: -// -// len(mockedConsulLock.LockCalls()) -func (mock *ConsulLockMock) LockCalls() []struct { - ValCh <-chan struct{} -} { - var calls []struct { - ValCh <-chan struct{} - } - mock.lockLock.RLock() - calls = mock.calls.Lock - mock.lockLock.RUnlock() - return calls -} - -// ResetLockCalls reset all the calls that were made to Lock. -func (mock *ConsulLockMock) ResetLockCalls() { - mock.lockLock.Lock() - mock.calls.Lock = nil - mock.lockLock.Unlock() -} - -// Unlock calls UnlockFunc. -func (mock *ConsulLockMock) Unlock() error { - if mock.UnlockFunc == nil { - panic("ConsulLockMock.UnlockFunc: method is nil but ConsulLock.Unlock was just called") - } - callInfo := struct { - }{} - mock.lockUnlock.Lock() - mock.calls.Unlock = append(mock.calls.Unlock, callInfo) - mock.lockUnlock.Unlock() - return mock.UnlockFunc() -} - -// UnlockCalls gets all the calls that were made to Unlock. -// Check the length with: -// -// len(mockedConsulLock.UnlockCalls()) -func (mock *ConsulLockMock) UnlockCalls() []struct { -} { - var calls []struct { - } - mock.lockUnlock.RLock() - calls = mock.calls.Unlock - mock.lockUnlock.RUnlock() - return calls -} - -// ResetUnlockCalls reset all the calls that were made to Unlock. -func (mock *ConsulLockMock) ResetUnlockCalls() { - mock.lockUnlock.Lock() - mock.calls.Unlock = nil - mock.lockUnlock.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *ConsulLockMock) ResetCalls() { - mock.lockLock.Lock() - mock.calls.Lock = nil - mock.lockLock.Unlock() - - mock.lockUnlock.Lock() - mock.calls.Unlock = nil - mock.lockUnlock.Unlock() -} - -// KeyManagerMock is a mock implementation of test.KeyManager. -// -// func TestSomethingThatUsesKeyManager(t *testing.T) { -// -// // make and configure a mocked test.KeyManager -// mockedKeyManager := &KeyManagerMock{ -// GetKeyFunc: func(s string, v uint16) ([]byte, *test.Err) { -// panic("mock out the GetKey method") -// }, -// } -// -// // use mockedKeyManager in code that requires test.KeyManager -// // and then make assertions. -// -// } -type KeyManagerMock struct { - // GetKeyFunc mocks the GetKey method. - GetKeyFunc func(s string, v uint16) ([]byte, *test.Err) - - // calls tracks calls to the methods. - calls struct { - // GetKey holds details about calls to the GetKey method. - GetKey []struct { - // S is the s argument value. - S string - // V is the v argument value. - V uint16 - } - } - lockGetKey sync.RWMutex -} - -// GetKey calls GetKeyFunc. -func (mock *KeyManagerMock) GetKey(s string, v uint16) ([]byte, *test.Err) { - if mock.GetKeyFunc == nil { - panic("KeyManagerMock.GetKeyFunc: method is nil but KeyManager.GetKey was just called") - } - callInfo := struct { - S string - V uint16 - }{ - S: s, - V: v, - } - mock.lockGetKey.Lock() - mock.calls.GetKey = append(mock.calls.GetKey, callInfo) - mock.lockGetKey.Unlock() - return mock.GetKeyFunc(s, v) -} - -// GetKeyCalls gets all the calls that were made to GetKey. -// Check the length with: -// -// len(mockedKeyManager.GetKeyCalls()) -func (mock *KeyManagerMock) GetKeyCalls() []struct { - S string - V uint16 -} { - var calls []struct { - S string - V uint16 - } - mock.lockGetKey.RLock() - calls = mock.calls.GetKey - mock.lockGetKey.RUnlock() - return calls -} - -// ResetGetKeyCalls reset all the calls that were made to GetKey. -func (mock *KeyManagerMock) ResetGetKeyCalls() { - mock.lockGetKey.Lock() - mock.calls.GetKey = nil - mock.lockGetKey.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *KeyManagerMock) ResetCalls() { - mock.lockGetKey.Lock() - mock.calls.GetKey = nil - mock.lockGetKey.Unlock() -} - -// BlankMock is a mock implementation of test.Blank. -// -// func TestSomethingThatUsesBlank(t *testing.T) { -// -// // make and configure a mocked test.Blank -// mockedBlank := &BlankMock{ -// CreateFunc: func(x interface{}) error { -// panic("mock out the Create method") -// }, -// } -// -// // use mockedBlank in code that requires test.Blank -// // and then make assertions. -// -// } -type BlankMock struct { - // CreateFunc mocks the Create method. - CreateFunc func(x interface{}) error - - // calls tracks calls to the methods. - calls struct { - // Create holds details about calls to the Create method. - Create []struct { - // X is the x argument value. - X interface{} - } - } - lockCreate sync.RWMutex -} - -// Create calls CreateFunc. -func (mock *BlankMock) Create(x interface{}) error { - if mock.CreateFunc == nil { - panic("BlankMock.CreateFunc: method is nil but Blank.Create was just called") - } - callInfo := struct { - X interface{} - }{ - X: x, - } - mock.lockCreate.Lock() - mock.calls.Create = append(mock.calls.Create, callInfo) - mock.lockCreate.Unlock() - return mock.CreateFunc(x) -} - -// CreateCalls gets all the calls that were made to Create. -// Check the length with: -// -// len(mockedBlank.CreateCalls()) -func (mock *BlankMock) CreateCalls() []struct { - X interface{} -} { - var calls []struct { - X interface{} - } - mock.lockCreate.RLock() - calls = mock.calls.Create - mock.lockCreate.RUnlock() - return calls -} - -// ResetCreateCalls reset all the calls that were made to Create. -func (mock *BlankMock) ResetCreateCalls() { - mock.lockCreate.Lock() - mock.calls.Create = nil - mock.lockCreate.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *BlankMock) ResetCalls() { - mock.lockCreate.Lock() - mock.calls.Create = nil - mock.lockCreate.Unlock() -} - -// ExpecterMock is a mock implementation of test.Expecter. -// -// func TestSomethingThatUsesExpecter(t *testing.T) { -// -// // make and configure a mocked test.Expecter -// mockedExpecter := &ExpecterMock{ -// ManyArgsReturnsFunc: func(str string, i int) ([]string, error) { -// panic("mock out the ManyArgsReturns method") -// }, -// NoArgFunc: func() string { -// panic("mock out the NoArg method") -// }, -// NoReturnFunc: func(str string) { -// panic("mock out the NoReturn method") -// }, -// VariadicFunc: func(ints ...int) error { -// panic("mock out the Variadic method") -// }, -// VariadicManyFunc: func(i int, a string, intfs ...interface{}) error { -// panic("mock out the VariadicMany method") -// }, -// } -// -// // use mockedExpecter in code that requires test.Expecter -// // and then make assertions. -// -// } -type ExpecterMock struct { - // ManyArgsReturnsFunc mocks the ManyArgsReturns method. - ManyArgsReturnsFunc func(str string, i int) ([]string, error) - - // NoArgFunc mocks the NoArg method. - NoArgFunc func() string - - // NoReturnFunc mocks the NoReturn method. - NoReturnFunc func(str string) - - // VariadicFunc mocks the Variadic method. - VariadicFunc func(ints ...int) error - - // VariadicManyFunc mocks the VariadicMany method. - VariadicManyFunc func(i int, a string, intfs ...interface{}) error - - // calls tracks calls to the methods. - calls struct { - // ManyArgsReturns holds details about calls to the ManyArgsReturns method. - ManyArgsReturns []struct { - // Str is the str argument value. - Str string - // I is the i argument value. - I int - } - // NoArg holds details about calls to the NoArg method. - NoArg []struct { - } - // NoReturn holds details about calls to the NoReturn method. - NoReturn []struct { - // Str is the str argument value. - Str string - } - // Variadic holds details about calls to the Variadic method. - Variadic []struct { - // Ints is the ints argument value. - Ints []int - } - // VariadicMany holds details about calls to the VariadicMany method. - VariadicMany []struct { - // I is the i argument value. - I int - // A is the a argument value. - A string - // Intfs is the intfs argument value. - Intfs []interface{} - } - } - lockManyArgsReturns sync.RWMutex - lockNoArg sync.RWMutex - lockNoReturn sync.RWMutex - lockVariadic sync.RWMutex - lockVariadicMany sync.RWMutex -} - -// ManyArgsReturns calls ManyArgsReturnsFunc. -func (mock *ExpecterMock) ManyArgsReturns(str string, i int) ([]string, error) { - if mock.ManyArgsReturnsFunc == nil { - panic("ExpecterMock.ManyArgsReturnsFunc: method is nil but Expecter.ManyArgsReturns was just called") - } - callInfo := struct { - Str string - I int - }{ - Str: str, - I: i, - } - mock.lockManyArgsReturns.Lock() - mock.calls.ManyArgsReturns = append(mock.calls.ManyArgsReturns, callInfo) - mock.lockManyArgsReturns.Unlock() - return mock.ManyArgsReturnsFunc(str, i) -} - -// ManyArgsReturnsCalls gets all the calls that were made to ManyArgsReturns. -// Check the length with: -// -// len(mockedExpecter.ManyArgsReturnsCalls()) -func (mock *ExpecterMock) ManyArgsReturnsCalls() []struct { - Str string - I int -} { - var calls []struct { - Str string - I int - } - mock.lockManyArgsReturns.RLock() - calls = mock.calls.ManyArgsReturns - mock.lockManyArgsReturns.RUnlock() - return calls -} - -// ResetManyArgsReturnsCalls reset all the calls that were made to ManyArgsReturns. -func (mock *ExpecterMock) ResetManyArgsReturnsCalls() { - mock.lockManyArgsReturns.Lock() - mock.calls.ManyArgsReturns = nil - mock.lockManyArgsReturns.Unlock() -} - -// NoArg calls NoArgFunc. -func (mock *ExpecterMock) NoArg() string { - if mock.NoArgFunc == nil { - panic("ExpecterMock.NoArgFunc: method is nil but Expecter.NoArg was just called") - } - callInfo := struct { - }{} - mock.lockNoArg.Lock() - mock.calls.NoArg = append(mock.calls.NoArg, callInfo) - mock.lockNoArg.Unlock() - return mock.NoArgFunc() -} - -// NoArgCalls gets all the calls that were made to NoArg. -// Check the length with: -// -// len(mockedExpecter.NoArgCalls()) -func (mock *ExpecterMock) NoArgCalls() []struct { -} { - var calls []struct { - } - mock.lockNoArg.RLock() - calls = mock.calls.NoArg - mock.lockNoArg.RUnlock() - return calls -} - -// ResetNoArgCalls reset all the calls that were made to NoArg. -func (mock *ExpecterMock) ResetNoArgCalls() { - mock.lockNoArg.Lock() - mock.calls.NoArg = nil - mock.lockNoArg.Unlock() -} - -// NoReturn calls NoReturnFunc. -func (mock *ExpecterMock) NoReturn(str string) { - if mock.NoReturnFunc == nil { - panic("ExpecterMock.NoReturnFunc: method is nil but Expecter.NoReturn was just called") - } - callInfo := struct { - Str string - }{ - Str: str, - } - mock.lockNoReturn.Lock() - mock.calls.NoReturn = append(mock.calls.NoReturn, callInfo) - mock.lockNoReturn.Unlock() - mock.NoReturnFunc(str) -} - -// NoReturnCalls gets all the calls that were made to NoReturn. -// Check the length with: -// -// len(mockedExpecter.NoReturnCalls()) -func (mock *ExpecterMock) NoReturnCalls() []struct { - Str string -} { - var calls []struct { - Str string - } - mock.lockNoReturn.RLock() - calls = mock.calls.NoReturn - mock.lockNoReturn.RUnlock() - return calls -} - -// ResetNoReturnCalls reset all the calls that were made to NoReturn. -func (mock *ExpecterMock) ResetNoReturnCalls() { - mock.lockNoReturn.Lock() - mock.calls.NoReturn = nil - mock.lockNoReturn.Unlock() -} - -// Variadic calls VariadicFunc. -func (mock *ExpecterMock) Variadic(ints ...int) error { - if mock.VariadicFunc == nil { - panic("ExpecterMock.VariadicFunc: method is nil but Expecter.Variadic was just called") - } - callInfo := struct { - Ints []int - }{ - Ints: ints, - } - mock.lockVariadic.Lock() - mock.calls.Variadic = append(mock.calls.Variadic, callInfo) - mock.lockVariadic.Unlock() - return mock.VariadicFunc(ints...) -} - -// VariadicCalls gets all the calls that were made to Variadic. -// Check the length with: -// -// len(mockedExpecter.VariadicCalls()) -func (mock *ExpecterMock) VariadicCalls() []struct { - Ints []int -} { - var calls []struct { - Ints []int - } - mock.lockVariadic.RLock() - calls = mock.calls.Variadic - mock.lockVariadic.RUnlock() - return calls -} - -// ResetVariadicCalls reset all the calls that were made to Variadic. -func (mock *ExpecterMock) ResetVariadicCalls() { - mock.lockVariadic.Lock() - mock.calls.Variadic = nil - mock.lockVariadic.Unlock() -} - -// VariadicMany calls VariadicManyFunc. -func (mock *ExpecterMock) VariadicMany(i int, a string, intfs ...interface{}) error { - if mock.VariadicManyFunc == nil { - panic("ExpecterMock.VariadicManyFunc: method is nil but Expecter.VariadicMany was just called") - } - callInfo := struct { - I int - A string - Intfs []interface{} - }{ - I: i, - A: a, - Intfs: intfs, - } - mock.lockVariadicMany.Lock() - mock.calls.VariadicMany = append(mock.calls.VariadicMany, callInfo) - mock.lockVariadicMany.Unlock() - return mock.VariadicManyFunc(i, a, intfs...) -} - -// VariadicManyCalls gets all the calls that were made to VariadicMany. -// Check the length with: -// -// len(mockedExpecter.VariadicManyCalls()) -func (mock *ExpecterMock) VariadicManyCalls() []struct { - I int - A string - Intfs []interface{} -} { - var calls []struct { - I int - A string - Intfs []interface{} - } - mock.lockVariadicMany.RLock() - calls = mock.calls.VariadicMany - mock.lockVariadicMany.RUnlock() - return calls -} - -// ResetVariadicManyCalls reset all the calls that were made to VariadicMany. -func (mock *ExpecterMock) ResetVariadicManyCalls() { - mock.lockVariadicMany.Lock() - mock.calls.VariadicMany = nil - mock.lockVariadicMany.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *ExpecterMock) ResetCalls() { - mock.lockManyArgsReturns.Lock() - mock.calls.ManyArgsReturns = nil - mock.lockManyArgsReturns.Unlock() - - mock.lockNoArg.Lock() - mock.calls.NoArg = nil - mock.lockNoArg.Unlock() - - mock.lockNoReturn.Lock() - mock.calls.NoReturn = nil - mock.lockNoReturn.Unlock() - - mock.lockVariadic.Lock() - mock.calls.Variadic = nil - mock.lockVariadic.Unlock() - - mock.lockVariadicMany.Lock() - mock.calls.VariadicMany = nil - mock.lockVariadicMany.Unlock() -} - -// VariadicNoReturnInterfaceMock is a mock implementation of test.VariadicNoReturnInterface. -// -// func TestSomethingThatUsesVariadicNoReturnInterface(t *testing.T) { -// -// // make and configure a mocked test.VariadicNoReturnInterface -// mockedVariadicNoReturnInterface := &VariadicNoReturnInterfaceMock{ -// VariadicNoReturnFunc: func(j int, is ...interface{}) { -// panic("mock out the VariadicNoReturn method") -// }, -// } -// -// // use mockedVariadicNoReturnInterface in code that requires test.VariadicNoReturnInterface -// // and then make assertions. -// -// } -type VariadicNoReturnInterfaceMock struct { - // VariadicNoReturnFunc mocks the VariadicNoReturn method. - VariadicNoReturnFunc func(j int, is ...interface{}) - - // calls tracks calls to the methods. - calls struct { - // VariadicNoReturn holds details about calls to the VariadicNoReturn method. - VariadicNoReturn []struct { - // J is the j argument value. - J int - // Is is the is argument value. - Is []interface{} - } - } - lockVariadicNoReturn sync.RWMutex -} - -// VariadicNoReturn calls VariadicNoReturnFunc. -func (mock *VariadicNoReturnInterfaceMock) VariadicNoReturn(j int, is ...interface{}) { - if mock.VariadicNoReturnFunc == nil { - panic("VariadicNoReturnInterfaceMock.VariadicNoReturnFunc: method is nil but VariadicNoReturnInterface.VariadicNoReturn was just called") - } - callInfo := struct { - J int - Is []interface{} - }{ - J: j, - Is: is, - } - mock.lockVariadicNoReturn.Lock() - mock.calls.VariadicNoReturn = append(mock.calls.VariadicNoReturn, callInfo) - mock.lockVariadicNoReturn.Unlock() - mock.VariadicNoReturnFunc(j, is...) -} - -// VariadicNoReturnCalls gets all the calls that were made to VariadicNoReturn. -// Check the length with: -// -// len(mockedVariadicNoReturnInterface.VariadicNoReturnCalls()) -func (mock *VariadicNoReturnInterfaceMock) VariadicNoReturnCalls() []struct { - J int - Is []interface{} -} { - var calls []struct { - J int - Is []interface{} - } - mock.lockVariadicNoReturn.RLock() - calls = mock.calls.VariadicNoReturn - mock.lockVariadicNoReturn.RUnlock() - return calls -} - -// ResetVariadicNoReturnCalls reset all the calls that were made to VariadicNoReturn. -func (mock *VariadicNoReturnInterfaceMock) ResetVariadicNoReturnCalls() { - mock.lockVariadicNoReturn.Lock() - mock.calls.VariadicNoReturn = nil - mock.lockVariadicNoReturn.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *VariadicNoReturnInterfaceMock) ResetCalls() { - mock.lockVariadicNoReturn.Lock() - mock.calls.VariadicNoReturn = nil - mock.lockVariadicNoReturn.Unlock() -} - -// FuncArgsCollisionMock is a mock implementation of test.FuncArgsCollision. -// -// func TestSomethingThatUsesFuncArgsCollision(t *testing.T) { -// -// // make and configure a mocked test.FuncArgsCollision -// mockedFuncArgsCollision := &FuncArgsCollisionMock{ -// FooFunc: func(ret interface{}) error { -// panic("mock out the Foo method") -// }, -// } -// -// // use mockedFuncArgsCollision in code that requires test.FuncArgsCollision -// // and then make assertions. -// -// } -type FuncArgsCollisionMock struct { - // FooFunc mocks the Foo method. - FooFunc func(ret interface{}) error - - // calls tracks calls to the methods. - calls struct { - // Foo holds details about calls to the Foo method. - Foo []struct { - // Ret is the ret argument value. - Ret interface{} - } - } - lockFoo sync.RWMutex -} - -// Foo calls FooFunc. -func (mock *FuncArgsCollisionMock) Foo(ret interface{}) error { - if mock.FooFunc == nil { - panic("FuncArgsCollisionMock.FooFunc: method is nil but FuncArgsCollision.Foo was just called") - } - callInfo := struct { - Ret interface{} - }{ - Ret: ret, - } - mock.lockFoo.Lock() - mock.calls.Foo = append(mock.calls.Foo, callInfo) - mock.lockFoo.Unlock() - return mock.FooFunc(ret) -} - -// FooCalls gets all the calls that were made to Foo. -// Check the length with: -// -// len(mockedFuncArgsCollision.FooCalls()) -func (mock *FuncArgsCollisionMock) FooCalls() []struct { - Ret interface{} -} { - var calls []struct { - Ret interface{} - } - mock.lockFoo.RLock() - calls = mock.calls.Foo - mock.lockFoo.RUnlock() - return calls -} - -// ResetFooCalls reset all the calls that were made to Foo. -func (mock *FuncArgsCollisionMock) ResetFooCalls() { - mock.lockFoo.Lock() - mock.calls.Foo = nil - mock.lockFoo.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *FuncArgsCollisionMock) ResetCalls() { - mock.lockFoo.Lock() - mock.calls.Foo = nil - mock.lockFoo.Unlock() -} - -// GetIntMock is a mock implementation of test.GetInt. -// -// func TestSomethingThatUsesGetInt(t *testing.T) { -// -// // make and configure a mocked test.GetInt -// mockedGetInt := &GetIntMock{ -// GetFunc: func() int { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedGetInt in code that requires test.GetInt -// // and then make assertions. -// -// } -type GetIntMock struct { - // GetFunc mocks the Get method. - GetFunc func() int - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *GetIntMock) Get() int { - if mock.GetFunc == nil { - panic("GetIntMock.GetFunc: method is nil but GetInt.Get was just called") - } - callInfo := struct { - }{} - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc() -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedGetInt.GetCalls()) -func (mock *GetIntMock) GetCalls() []struct { -} { - var calls []struct { - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *GetIntMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *GetIntMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// GetGenericMock is a mock implementation of test.GetGeneric. -// -// func TestSomethingThatUsesGetGeneric(t *testing.T) { -// -// // make and configure a mocked test.GetGeneric -// mockedGetGeneric := &GetGenericMock{ -// GetFunc: func() T { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedGetGeneric in code that requires test.GetGeneric -// // and then make assertions. -// -// } -type GetGenericMock[T constraints.Integer] struct { - // GetFunc mocks the Get method. - GetFunc func() T - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *GetGenericMock[T]) Get() T { - if mock.GetFunc == nil { - panic("GetGenericMock.GetFunc: method is nil but GetGeneric.Get was just called") - } - callInfo := struct { - }{} - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc() -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedGetGeneric.GetCalls()) -func (mock *GetGenericMock[T]) GetCalls() []struct { -} { - var calls []struct { - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *GetGenericMock[T]) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *GetGenericMock[T]) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// EmbeddedGetMock is a mock implementation of test.EmbeddedGet. -// -// func TestSomethingThatUsesEmbeddedGet(t *testing.T) { -// -// // make and configure a mocked test.EmbeddedGet -// mockedEmbeddedGet := &EmbeddedGetMock{ -// GetFunc: func() T { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedEmbeddedGet in code that requires test.EmbeddedGet -// // and then make assertions. -// -// } -type EmbeddedGetMock[T constraints.Signed] struct { - // GetFunc mocks the Get method. - GetFunc func() T - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *EmbeddedGetMock[T]) Get() T { - if mock.GetFunc == nil { - panic("EmbeddedGetMock.GetFunc: method is nil but EmbeddedGet.Get was just called") - } - callInfo := struct { - }{} - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc() -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedEmbeddedGet.GetCalls()) -func (mock *EmbeddedGetMock[T]) GetCalls() []struct { -} { - var calls []struct { - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *EmbeddedGetMock[T]) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *EmbeddedGetMock[T]) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ReplaceGenericMock is a mock implementation of test.ReplaceGeneric. -// -// func TestSomethingThatUsesReplaceGeneric(t *testing.T) { -// -// // make and configure a mocked test.ReplaceGeneric -// mockedReplaceGeneric := &ReplaceGenericMock{ -// AFunc: func(t1 TImport) TKeep { -// panic("mock out the A method") -// }, -// BFunc: func() TImport { -// panic("mock out the B method") -// }, -// CFunc: func() TConstraint { -// panic("mock out the C method") -// }, -// } -// -// // use mockedReplaceGeneric in code that requires test.ReplaceGeneric -// // and then make assertions. -// -// } -type ReplaceGenericMock[TImport any, TConstraint constraints.Signed, TKeep any] struct { - // AFunc mocks the A method. - AFunc func(t1 TImport) TKeep - - // BFunc mocks the B method. - BFunc func() TImport - - // CFunc mocks the C method. - CFunc func() TConstraint - - // calls tracks calls to the methods. - calls struct { - // A holds details about calls to the A method. - A []struct { - // T1 is the t1 argument value. - T1 TImport - } - // B holds details about calls to the B method. - B []struct { - } - // C holds details about calls to the C method. - C []struct { - } - } - lockA sync.RWMutex - lockB sync.RWMutex - lockC sync.RWMutex -} - -// A calls AFunc. -func (mock *ReplaceGenericMock[TImport, TConstraint, TKeep]) A(t1 TImport) TKeep { - if mock.AFunc == nil { - panic("ReplaceGenericMock.AFunc: method is nil but ReplaceGeneric.A was just called") - } - callInfo := struct { - T1 TImport - }{ - T1: t1, - } - mock.lockA.Lock() - mock.calls.A = append(mock.calls.A, callInfo) - mock.lockA.Unlock() - return mock.AFunc(t1) -} - -// ACalls gets all the calls that were made to A. -// Check the length with: -// -// len(mockedReplaceGeneric.ACalls()) -func (mock *ReplaceGenericMock[TImport, TConstraint, TKeep]) ACalls() []struct { - T1 TImport -} { - var calls []struct { - T1 TImport - } - mock.lockA.RLock() - calls = mock.calls.A - mock.lockA.RUnlock() - return calls -} - -// ResetACalls reset all the calls that were made to A. -func (mock *ReplaceGenericMock[TImport, TConstraint, TKeep]) ResetACalls() { - mock.lockA.Lock() - mock.calls.A = nil - mock.lockA.Unlock() -} - -// B calls BFunc. -func (mock *ReplaceGenericMock[TImport, TConstraint, TKeep]) B() TImport { - if mock.BFunc == nil { - panic("ReplaceGenericMock.BFunc: method is nil but ReplaceGeneric.B was just called") - } - callInfo := struct { - }{} - mock.lockB.Lock() - mock.calls.B = append(mock.calls.B, callInfo) - mock.lockB.Unlock() - return mock.BFunc() -} - -// BCalls gets all the calls that were made to B. -// Check the length with: -// -// len(mockedReplaceGeneric.BCalls()) -func (mock *ReplaceGenericMock[TImport, TConstraint, TKeep]) BCalls() []struct { -} { - var calls []struct { - } - mock.lockB.RLock() - calls = mock.calls.B - mock.lockB.RUnlock() - return calls -} - -// ResetBCalls reset all the calls that were made to B. -func (mock *ReplaceGenericMock[TImport, TConstraint, TKeep]) ResetBCalls() { - mock.lockB.Lock() - mock.calls.B = nil - mock.lockB.Unlock() -} - -// C calls CFunc. -func (mock *ReplaceGenericMock[TImport, TConstraint, TKeep]) C() TConstraint { - if mock.CFunc == nil { - panic("ReplaceGenericMock.CFunc: method is nil but ReplaceGeneric.C was just called") - } - callInfo := struct { - }{} - mock.lockC.Lock() - mock.calls.C = append(mock.calls.C, callInfo) - mock.lockC.Unlock() - return mock.CFunc() -} - -// CCalls gets all the calls that were made to C. -// Check the length with: -// -// len(mockedReplaceGeneric.CCalls()) -func (mock *ReplaceGenericMock[TImport, TConstraint, TKeep]) CCalls() []struct { -} { - var calls []struct { - } - mock.lockC.RLock() - calls = mock.calls.C - mock.lockC.RUnlock() - return calls -} - -// ResetCCalls reset all the calls that were made to C. -func (mock *ReplaceGenericMock[TImport, TConstraint, TKeep]) ResetCCalls() { - mock.lockC.Lock() - mock.calls.C = nil - mock.lockC.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *ReplaceGenericMock[TImport, TConstraint, TKeep]) ResetCalls() { - mock.lockA.Lock() - mock.calls.A = nil - mock.lockA.Unlock() - - mock.lockB.Lock() - mock.calls.B = nil - mock.lockB.Unlock() - - mock.lockC.Lock() - mock.calls.C = nil - mock.lockC.Unlock() -} - -// ReplaceGenericSelfMock is a mock implementation of test.ReplaceGenericSelf. -// -// func TestSomethingThatUsesReplaceGenericSelf(t *testing.T) { -// -// // make and configure a mocked test.ReplaceGenericSelf -// mockedReplaceGenericSelf := &ReplaceGenericSelfMock{ -// AFunc: func() T { -// panic("mock out the A method") -// }, -// } -// -// // use mockedReplaceGenericSelf in code that requires test.ReplaceGenericSelf -// // and then make assertions. -// -// } -type ReplaceGenericSelfMock[T any] struct { - // AFunc mocks the A method. - AFunc func() T - - // calls tracks calls to the methods. - calls struct { - // A holds details about calls to the A method. - A []struct { - } - } - lockA sync.RWMutex -} - -// A calls AFunc. -func (mock *ReplaceGenericSelfMock[T]) A() T { - if mock.AFunc == nil { - panic("ReplaceGenericSelfMock.AFunc: method is nil but ReplaceGenericSelf.A was just called") - } - callInfo := struct { - }{} - mock.lockA.Lock() - mock.calls.A = append(mock.calls.A, callInfo) - mock.lockA.Unlock() - return mock.AFunc() -} - -// ACalls gets all the calls that were made to A. -// Check the length with: -// -// len(mockedReplaceGenericSelf.ACalls()) -func (mock *ReplaceGenericSelfMock[T]) ACalls() []struct { -} { - var calls []struct { - } - mock.lockA.RLock() - calls = mock.calls.A - mock.lockA.RUnlock() - return calls -} - -// ResetACalls reset all the calls that were made to A. -func (mock *ReplaceGenericSelfMock[T]) ResetACalls() { - mock.lockA.Lock() - mock.calls.A = nil - mock.lockA.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *ReplaceGenericSelfMock[T]) ResetCalls() { - mock.lockA.Lock() - mock.calls.A = nil - mock.lockA.Unlock() -} - -// HasConflictingNestedImportsMock is a mock implementation of test.HasConflictingNestedImports. -// -// func TestSomethingThatUsesHasConflictingNestedImports(t *testing.T) { -// -// // make and configure a mocked test.HasConflictingNestedImports -// mockedHasConflictingNestedImports := &HasConflictingNestedImportsMock{ -// GetFunc: func(path string) (http.Response, error) { -// panic("mock out the Get method") -// }, -// ZFunc: func() http0.MyStruct { -// panic("mock out the Z method") -// }, -// } -// -// // use mockedHasConflictingNestedImports in code that requires test.HasConflictingNestedImports -// // and then make assertions. -// -// } -type HasConflictingNestedImportsMock struct { - // GetFunc mocks the Get method. - GetFunc func(path string) (http.Response, error) - - // ZFunc mocks the Z method. - ZFunc func() http0.MyStruct - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Path is the path argument value. - Path string - } - // Z holds details about calls to the Z method. - Z []struct { - } - } - lockGet sync.RWMutex - lockZ sync.RWMutex -} - -// Get calls GetFunc. -func (mock *HasConflictingNestedImportsMock) Get(path string) (http.Response, error) { - if mock.GetFunc == nil { - panic("HasConflictingNestedImportsMock.GetFunc: method is nil but HasConflictingNestedImports.Get was just called") - } - callInfo := struct { - Path string - }{ - Path: path, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(path) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedHasConflictingNestedImports.GetCalls()) -func (mock *HasConflictingNestedImportsMock) GetCalls() []struct { - Path string -} { - var calls []struct { - Path string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *HasConflictingNestedImportsMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// Z calls ZFunc. -func (mock *HasConflictingNestedImportsMock) Z() http0.MyStruct { - if mock.ZFunc == nil { - panic("HasConflictingNestedImportsMock.ZFunc: method is nil but HasConflictingNestedImports.Z was just called") - } - callInfo := struct { - }{} - mock.lockZ.Lock() - mock.calls.Z = append(mock.calls.Z, callInfo) - mock.lockZ.Unlock() - return mock.ZFunc() -} - -// ZCalls gets all the calls that were made to Z. -// Check the length with: -// -// len(mockedHasConflictingNestedImports.ZCalls()) -func (mock *HasConflictingNestedImportsMock) ZCalls() []struct { -} { - var calls []struct { - } - mock.lockZ.RLock() - calls = mock.calls.Z - mock.lockZ.RUnlock() - return calls -} - -// ResetZCalls reset all the calls that were made to Z. -func (mock *HasConflictingNestedImportsMock) ResetZCalls() { - mock.lockZ.Lock() - mock.calls.Z = nil - mock.lockZ.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *HasConflictingNestedImportsMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() - - mock.lockZ.Lock() - mock.calls.Z = nil - mock.lockZ.Unlock() -} - -// ImportsSameAsPackageMock is a mock implementation of test.ImportsSameAsPackage. -// -// func TestSomethingThatUsesImportsSameAsPackage(t *testing.T) { -// -// // make and configure a mocked test.ImportsSameAsPackage -// mockedImportsSameAsPackage := &ImportsSameAsPackageMock{ -// AFunc: func() test0.B { -// panic("mock out the A method") -// }, -// BFunc: func() test.KeyManager { -// panic("mock out the B method") -// }, -// CFunc: func(c test.C) { -// panic("mock out the C method") -// }, -// } -// -// // use mockedImportsSameAsPackage in code that requires test.ImportsSameAsPackage -// // and then make assertions. -// -// } -type ImportsSameAsPackageMock struct { - // AFunc mocks the A method. - AFunc func() test0.B - - // BFunc mocks the B method. - BFunc func() test.KeyManager - - // CFunc mocks the C method. - CFunc func(c test.C) - - // calls tracks calls to the methods. - calls struct { - // A holds details about calls to the A method. - A []struct { - } - // B holds details about calls to the B method. - B []struct { - } - // C holds details about calls to the C method. - C []struct { - // C is the c argument value. - C test.C - } - } - lockA sync.RWMutex - lockB sync.RWMutex - lockC sync.RWMutex -} - -// A calls AFunc. -func (mock *ImportsSameAsPackageMock) A() test0.B { - if mock.AFunc == nil { - panic("ImportsSameAsPackageMock.AFunc: method is nil but ImportsSameAsPackage.A was just called") - } - callInfo := struct { - }{} - mock.lockA.Lock() - mock.calls.A = append(mock.calls.A, callInfo) - mock.lockA.Unlock() - return mock.AFunc() -} - -// ACalls gets all the calls that were made to A. -// Check the length with: -// -// len(mockedImportsSameAsPackage.ACalls()) -func (mock *ImportsSameAsPackageMock) ACalls() []struct { -} { - var calls []struct { - } - mock.lockA.RLock() - calls = mock.calls.A - mock.lockA.RUnlock() - return calls -} - -// ResetACalls reset all the calls that were made to A. -func (mock *ImportsSameAsPackageMock) ResetACalls() { - mock.lockA.Lock() - mock.calls.A = nil - mock.lockA.Unlock() -} - -// B calls BFunc. -func (mock *ImportsSameAsPackageMock) B() test.KeyManager { - if mock.BFunc == nil { - panic("ImportsSameAsPackageMock.BFunc: method is nil but ImportsSameAsPackage.B was just called") - } - callInfo := struct { - }{} - mock.lockB.Lock() - mock.calls.B = append(mock.calls.B, callInfo) - mock.lockB.Unlock() - return mock.BFunc() -} - -// BCalls gets all the calls that were made to B. -// Check the length with: -// -// len(mockedImportsSameAsPackage.BCalls()) -func (mock *ImportsSameAsPackageMock) BCalls() []struct { -} { - var calls []struct { - } - mock.lockB.RLock() - calls = mock.calls.B - mock.lockB.RUnlock() - return calls -} - -// ResetBCalls reset all the calls that were made to B. -func (mock *ImportsSameAsPackageMock) ResetBCalls() { - mock.lockB.Lock() - mock.calls.B = nil - mock.lockB.Unlock() -} - -// C calls CFunc. -func (mock *ImportsSameAsPackageMock) C(c test.C) { - if mock.CFunc == nil { - panic("ImportsSameAsPackageMock.CFunc: method is nil but ImportsSameAsPackage.C was just called") - } - callInfo := struct { - C test.C - }{ - C: c, - } - mock.lockC.Lock() - mock.calls.C = append(mock.calls.C, callInfo) - mock.lockC.Unlock() - mock.CFunc(c) -} - -// CCalls gets all the calls that were made to C. -// Check the length with: -// -// len(mockedImportsSameAsPackage.CCalls()) -func (mock *ImportsSameAsPackageMock) CCalls() []struct { - C test.C -} { - var calls []struct { - C test.C - } - mock.lockC.RLock() - calls = mock.calls.C - mock.lockC.RUnlock() - return calls -} - -// ResetCCalls reset all the calls that were made to C. -func (mock *ImportsSameAsPackageMock) ResetCCalls() { - mock.lockC.Lock() - mock.calls.C = nil - mock.lockC.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *ImportsSameAsPackageMock) ResetCalls() { - mock.lockA.Lock() - mock.calls.A = nil - mock.lockA.Unlock() - - mock.lockB.Lock() - mock.calls.B = nil - mock.lockB.Unlock() - - mock.lockC.Lock() - mock.calls.C = nil - mock.lockC.Unlock() -} - -// GenericInterfaceMock is a mock implementation of test.GenericInterface. -// -// func TestSomethingThatUsesGenericInterface(t *testing.T) { -// -// // make and configure a mocked test.GenericInterface -// mockedGenericInterface := &GenericInterfaceMock{ -// FuncFunc: func(arg *M) int { -// panic("mock out the Func method") -// }, -// } -// -// // use mockedGenericInterface in code that requires test.GenericInterface -// // and then make assertions. -// -// } -type GenericInterfaceMock[M any] struct { - // FuncFunc mocks the Func method. - FuncFunc func(arg *M) int - - // calls tracks calls to the methods. - calls struct { - // Func holds details about calls to the Func method. - Func []struct { - // Arg is the arg argument value. - Arg *M - } - } - lockFunc sync.RWMutex -} - -// Func calls FuncFunc. -func (mock *GenericInterfaceMock[M]) Func(arg *M) int { - if mock.FuncFunc == nil { - panic("GenericInterfaceMock.FuncFunc: method is nil but GenericInterface.Func was just called") - } - callInfo := struct { - Arg *M - }{ - Arg: arg, - } - mock.lockFunc.Lock() - mock.calls.Func = append(mock.calls.Func, callInfo) - mock.lockFunc.Unlock() - return mock.FuncFunc(arg) -} - -// FuncCalls gets all the calls that were made to Func. -// Check the length with: -// -// len(mockedGenericInterface.FuncCalls()) -func (mock *GenericInterfaceMock[M]) FuncCalls() []struct { - Arg *M -} { - var calls []struct { - Arg *M - } - mock.lockFunc.RLock() - calls = mock.calls.Func - mock.lockFunc.RUnlock() - return calls -} - -// ResetFuncCalls reset all the calls that were made to Func. -func (mock *GenericInterfaceMock[M]) ResetFuncCalls() { - mock.lockFunc.Lock() - mock.calls.Func = nil - mock.lockFunc.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *GenericInterfaceMock[M]) ResetCalls() { - mock.lockFunc.Lock() - mock.calls.Func = nil - mock.lockFunc.Unlock() -} - -// InstantiatedGenericInterfaceMock is a mock implementation of test.InstantiatedGenericInterface. -// -// func TestSomethingThatUsesInstantiatedGenericInterface(t *testing.T) { -// -// // make and configure a mocked test.InstantiatedGenericInterface -// mockedInstantiatedGenericInterface := &InstantiatedGenericInterfaceMock{ -// FuncFunc: func(arg *float32) int { -// panic("mock out the Func method") -// }, -// } -// -// // use mockedInstantiatedGenericInterface in code that requires test.InstantiatedGenericInterface -// // and then make assertions. -// -// } -type InstantiatedGenericInterfaceMock struct { - // FuncFunc mocks the Func method. - FuncFunc func(arg *float32) int - - // calls tracks calls to the methods. - calls struct { - // Func holds details about calls to the Func method. - Func []struct { - // Arg is the arg argument value. - Arg *float32 - } - } - lockFunc sync.RWMutex -} - -// Func calls FuncFunc. -func (mock *InstantiatedGenericInterfaceMock) Func(arg *float32) int { - if mock.FuncFunc == nil { - panic("InstantiatedGenericInterfaceMock.FuncFunc: method is nil but InstantiatedGenericInterface.Func was just called") - } - callInfo := struct { - Arg *float32 - }{ - Arg: arg, - } - mock.lockFunc.Lock() - mock.calls.Func = append(mock.calls.Func, callInfo) - mock.lockFunc.Unlock() - return mock.FuncFunc(arg) -} - -// FuncCalls gets all the calls that were made to Func. -// Check the length with: -// -// len(mockedInstantiatedGenericInterface.FuncCalls()) -func (mock *InstantiatedGenericInterfaceMock) FuncCalls() []struct { - Arg *float32 -} { - var calls []struct { - Arg *float32 - } - mock.lockFunc.RLock() - calls = mock.calls.Func - mock.lockFunc.RUnlock() - return calls -} - -// ResetFuncCalls reset all the calls that were made to Func. -func (mock *InstantiatedGenericInterfaceMock) ResetFuncCalls() { - mock.lockFunc.Lock() - mock.calls.Func = nil - mock.lockFunc.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *InstantiatedGenericInterfaceMock) ResetCalls() { - mock.lockFunc.Lock() - mock.calls.Func = nil - mock.lockFunc.Unlock() -} - -// MyReaderMock is a mock implementation of test.MyReader. -// -// func TestSomethingThatUsesMyReader(t *testing.T) { -// -// // make and configure a mocked test.MyReader -// mockedMyReader := &MyReaderMock{ -// ReadFunc: func(p []byte) (int, error) { -// panic("mock out the Read method") -// }, -// } -// -// // use mockedMyReader in code that requires test.MyReader -// // and then make assertions. -// -// } -type MyReaderMock struct { - // ReadFunc mocks the Read method. - ReadFunc func(p []byte) (int, error) - - // calls tracks calls to the methods. - calls struct { - // Read holds details about calls to the Read method. - Read []struct { - // P is the p argument value. - P []byte - } - } - lockRead sync.RWMutex -} - -// Read calls ReadFunc. -func (mock *MyReaderMock) Read(p []byte) (int, error) { - if mock.ReadFunc == nil { - panic("MyReaderMock.ReadFunc: method is nil but MyReader.Read was just called") - } - callInfo := struct { - P []byte - }{ - P: p, - } - mock.lockRead.Lock() - mock.calls.Read = append(mock.calls.Read, callInfo) - mock.lockRead.Unlock() - return mock.ReadFunc(p) -} - -// ReadCalls gets all the calls that were made to Read. -// Check the length with: -// -// len(mockedMyReader.ReadCalls()) -func (mock *MyReaderMock) ReadCalls() []struct { - P []byte -} { - var calls []struct { - P []byte - } - mock.lockRead.RLock() - calls = mock.calls.Read - mock.lockRead.RUnlock() - return calls -} - -// ResetReadCalls reset all the calls that were made to Read. -func (mock *MyReaderMock) ResetReadCalls() { - mock.lockRead.Lock() - mock.calls.Read = nil - mock.lockRead.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *MyReaderMock) ResetCalls() { - mock.lockRead.Lock() - mock.calls.Read = nil - mock.lockRead.Unlock() -} - -// Issue766Mock is a mock implementation of test.Issue766. -// -// func TestSomethingThatUsesIssue766(t *testing.T) { -// -// // make and configure a mocked test.Issue766 -// mockedIssue766 := &Issue766Mock{ -// FetchDataFunc: func(fetchFunc func(x ...int) ([]int, error)) ([]int, error) { -// panic("mock out the FetchData method") -// }, -// } -// -// // use mockedIssue766 in code that requires test.Issue766 -// // and then make assertions. -// -// } -type Issue766Mock struct { - // FetchDataFunc mocks the FetchData method. - FetchDataFunc func(fetchFunc func(x ...int) ([]int, error)) ([]int, error) - - // calls tracks calls to the methods. - calls struct { - // FetchData holds details about calls to the FetchData method. - FetchData []struct { - // FetchFunc is the fetchFunc argument value. - FetchFunc func(x ...int) ([]int, error) - } - } - lockFetchData sync.RWMutex -} - -// FetchData calls FetchDataFunc. -func (mock *Issue766Mock) FetchData(fetchFunc func(x ...int) ([]int, error)) ([]int, error) { - if mock.FetchDataFunc == nil { - panic("Issue766Mock.FetchDataFunc: method is nil but Issue766.FetchData was just called") - } - callInfo := struct { - FetchFunc func(x ...int) ([]int, error) - }{ - FetchFunc: fetchFunc, - } - mock.lockFetchData.Lock() - mock.calls.FetchData = append(mock.calls.FetchData, callInfo) - mock.lockFetchData.Unlock() - return mock.FetchDataFunc(fetchFunc) -} - -// FetchDataCalls gets all the calls that were made to FetchData. -// Check the length with: -// -// len(mockedIssue766.FetchDataCalls()) -func (mock *Issue766Mock) FetchDataCalls() []struct { - FetchFunc func(x ...int) ([]int, error) -} { - var calls []struct { - FetchFunc func(x ...int) ([]int, error) - } - mock.lockFetchData.RLock() - calls = mock.calls.FetchData - mock.lockFetchData.RUnlock() - return calls -} - -// ResetFetchDataCalls reset all the calls that were made to FetchData. -func (mock *Issue766Mock) ResetFetchDataCalls() { - mock.lockFetchData.Lock() - mock.calls.FetchData = nil - mock.lockFetchData.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *Issue766Mock) ResetCalls() { - mock.lockFetchData.Lock() - mock.calls.FetchData = nil - mock.lockFetchData.Unlock() -} - -// MapToInterfaceMock is a mock implementation of test.MapToInterface. -// -// func TestSomethingThatUsesMapToInterface(t *testing.T) { -// -// // make and configure a mocked test.MapToInterface -// mockedMapToInterface := &MapToInterfaceMock{ -// FooFunc: func(arg1 ...map[string]interface{}) { -// panic("mock out the Foo method") -// }, -// } -// -// // use mockedMapToInterface in code that requires test.MapToInterface -// // and then make assertions. -// -// } -type MapToInterfaceMock struct { - // FooFunc mocks the Foo method. - FooFunc func(arg1 ...map[string]interface{}) - - // calls tracks calls to the methods. - calls struct { - // Foo holds details about calls to the Foo method. - Foo []struct { - // Arg1 is the arg1 argument value. - Arg1 []map[string]interface{} - } - } - lockFoo sync.RWMutex -} - -// Foo calls FooFunc. -func (mock *MapToInterfaceMock) Foo(arg1 ...map[string]interface{}) { - if mock.FooFunc == nil { - panic("MapToInterfaceMock.FooFunc: method is nil but MapToInterface.Foo was just called") - } - callInfo := struct { - Arg1 []map[string]interface{} - }{ - Arg1: arg1, - } - mock.lockFoo.Lock() - mock.calls.Foo = append(mock.calls.Foo, callInfo) - mock.lockFoo.Unlock() - mock.FooFunc(arg1...) -} - -// FooCalls gets all the calls that were made to Foo. -// Check the length with: -// -// len(mockedMapToInterface.FooCalls()) -func (mock *MapToInterfaceMock) FooCalls() []struct { - Arg1 []map[string]interface{} -} { - var calls []struct { - Arg1 []map[string]interface{} - } - mock.lockFoo.RLock() - calls = mock.calls.Foo - mock.lockFoo.RUnlock() - return calls -} - -// ResetFooCalls reset all the calls that were made to Foo. -func (mock *MapToInterfaceMock) ResetFooCalls() { - mock.lockFoo.Lock() - mock.calls.Foo = nil - mock.lockFoo.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *MapToInterfaceMock) ResetCalls() { - mock.lockFoo.Lock() - mock.calls.Foo = nil - mock.lockFoo.Unlock() -} - -// SiblingMock is a mock implementation of test.Sibling. -// -// func TestSomethingThatUsesSibling(t *testing.T) { -// -// // make and configure a mocked test.Sibling -// mockedSibling := &SiblingMock{ -// DoSomethingFunc: func() { -// panic("mock out the DoSomething method") -// }, -// } -// -// // use mockedSibling in code that requires test.Sibling -// // and then make assertions. -// -// } -type SiblingMock struct { - // DoSomethingFunc mocks the DoSomething method. - DoSomethingFunc func() - - // calls tracks calls to the methods. - calls struct { - // DoSomething holds details about calls to the DoSomething method. - DoSomething []struct { - } - } - lockDoSomething sync.RWMutex -} - -// DoSomething calls DoSomethingFunc. -func (mock *SiblingMock) DoSomething() { - if mock.DoSomethingFunc == nil { - panic("SiblingMock.DoSomethingFunc: method is nil but Sibling.DoSomething was just called") - } - callInfo := struct { - }{} - mock.lockDoSomething.Lock() - mock.calls.DoSomething = append(mock.calls.DoSomething, callInfo) - mock.lockDoSomething.Unlock() - mock.DoSomethingFunc() -} - -// DoSomethingCalls gets all the calls that were made to DoSomething. -// Check the length with: -// -// len(mockedSibling.DoSomethingCalls()) -func (mock *SiblingMock) DoSomethingCalls() []struct { -} { - var calls []struct { - } - mock.lockDoSomething.RLock() - calls = mock.calls.DoSomething - mock.lockDoSomething.RUnlock() - return calls -} - -// ResetDoSomethingCalls reset all the calls that were made to DoSomething. -func (mock *SiblingMock) ResetDoSomethingCalls() { - mock.lockDoSomething.Lock() - mock.calls.DoSomething = nil - mock.lockDoSomething.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *SiblingMock) ResetCalls() { - mock.lockDoSomething.Lock() - mock.calls.DoSomething = nil - mock.lockDoSomething.Unlock() -} - -// UsesOtherPkgIfaceMock is a mock implementation of test.UsesOtherPkgIface. -// -// func TestSomethingThatUsesUsesOtherPkgIface(t *testing.T) { -// -// // make and configure a mocked test.UsesOtherPkgIface -// mockedUsesOtherPkgIface := &UsesOtherPkgIfaceMock{ -// DoSomethingElseFunc: func(obj test.Sibling) { -// panic("mock out the DoSomethingElse method") -// }, -// } -// -// // use mockedUsesOtherPkgIface in code that requires test.UsesOtherPkgIface -// // and then make assertions. -// -// } -type UsesOtherPkgIfaceMock struct { - // DoSomethingElseFunc mocks the DoSomethingElse method. - DoSomethingElseFunc func(obj test.Sibling) - - // calls tracks calls to the methods. - calls struct { - // DoSomethingElse holds details about calls to the DoSomethingElse method. - DoSomethingElse []struct { - // Obj is the obj argument value. - Obj test.Sibling - } - } - lockDoSomethingElse sync.RWMutex -} - -// DoSomethingElse calls DoSomethingElseFunc. -func (mock *UsesOtherPkgIfaceMock) DoSomethingElse(obj test.Sibling) { - if mock.DoSomethingElseFunc == nil { - panic("UsesOtherPkgIfaceMock.DoSomethingElseFunc: method is nil but UsesOtherPkgIface.DoSomethingElse was just called") - } - callInfo := struct { - Obj test.Sibling - }{ - Obj: obj, - } - mock.lockDoSomethingElse.Lock() - mock.calls.DoSomethingElse = append(mock.calls.DoSomethingElse, callInfo) - mock.lockDoSomethingElse.Unlock() - mock.DoSomethingElseFunc(obj) -} - -// DoSomethingElseCalls gets all the calls that were made to DoSomethingElse. -// Check the length with: -// -// len(mockedUsesOtherPkgIface.DoSomethingElseCalls()) -func (mock *UsesOtherPkgIfaceMock) DoSomethingElseCalls() []struct { - Obj test.Sibling -} { - var calls []struct { - Obj test.Sibling - } - mock.lockDoSomethingElse.RLock() - calls = mock.calls.DoSomethingElse - mock.lockDoSomethingElse.RUnlock() - return calls -} - -// ResetDoSomethingElseCalls reset all the calls that were made to DoSomethingElse. -func (mock *UsesOtherPkgIfaceMock) ResetDoSomethingElseCalls() { - mock.lockDoSomethingElse.Lock() - mock.calls.DoSomethingElse = nil - mock.lockDoSomethingElse.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *UsesOtherPkgIfaceMock) ResetCalls() { - mock.lockDoSomethingElse.Lock() - mock.calls.DoSomethingElse = nil - mock.lockDoSomethingElse.Unlock() -} - -// PanicOnNoReturnValueMock is a mock implementation of test.PanicOnNoReturnValue. -// -// func TestSomethingThatUsesPanicOnNoReturnValue(t *testing.T) { -// -// // make and configure a mocked test.PanicOnNoReturnValue -// mockedPanicOnNoReturnValue := &PanicOnNoReturnValueMock{ -// DoSomethingFunc: func() string { -// panic("mock out the DoSomething method") -// }, -// } -// -// // use mockedPanicOnNoReturnValue in code that requires test.PanicOnNoReturnValue -// // and then make assertions. -// -// } -type PanicOnNoReturnValueMock struct { - // DoSomethingFunc mocks the DoSomething method. - DoSomethingFunc func() string - - // calls tracks calls to the methods. - calls struct { - // DoSomething holds details about calls to the DoSomething method. - DoSomething []struct { - } - } - lockDoSomething sync.RWMutex -} - -// DoSomething calls DoSomethingFunc. -func (mock *PanicOnNoReturnValueMock) DoSomething() string { - if mock.DoSomethingFunc == nil { - panic("PanicOnNoReturnValueMock.DoSomethingFunc: method is nil but PanicOnNoReturnValue.DoSomething was just called") - } - callInfo := struct { - }{} - mock.lockDoSomething.Lock() - mock.calls.DoSomething = append(mock.calls.DoSomething, callInfo) - mock.lockDoSomething.Unlock() - return mock.DoSomethingFunc() -} - -// DoSomethingCalls gets all the calls that were made to DoSomething. -// Check the length with: -// -// len(mockedPanicOnNoReturnValue.DoSomethingCalls()) -func (mock *PanicOnNoReturnValueMock) DoSomethingCalls() []struct { -} { - var calls []struct { - } - mock.lockDoSomething.RLock() - calls = mock.calls.DoSomething - mock.lockDoSomething.RUnlock() - return calls -} - -// ResetDoSomethingCalls reset all the calls that were made to DoSomething. -func (mock *PanicOnNoReturnValueMock) ResetDoSomethingCalls() { - mock.lockDoSomething.Lock() - mock.calls.DoSomething = nil - mock.lockDoSomething.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *PanicOnNoReturnValueMock) ResetCalls() { - mock.lockDoSomething.Lock() - mock.calls.DoSomething = nil - mock.lockDoSomething.Unlock() -} - -// RequesterMock is a mock implementation of test.Requester. -// -// func TestSomethingThatUsesRequester(t *testing.T) { -// -// // make and configure a mocked test.Requester -// mockedRequester := &RequesterMock{ -// GetFunc: func(path string) (string, error) { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequester in code that requires test.Requester -// // and then make assertions. -// -// } -type RequesterMock struct { - // GetFunc mocks the Get method. - GetFunc func(path string) (string, error) - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Path is the path argument value. - Path string - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *RequesterMock) Get(path string) (string, error) { - if mock.GetFunc == nil { - panic("RequesterMock.GetFunc: method is nil but Requester.Get was just called") - } - callInfo := struct { - Path string - }{ - Path: path, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(path) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequester.GetCalls()) -func (mock *RequesterMock) GetCalls() []struct { - Path string -} { - var calls []struct { - Path string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *RequesterMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *RequesterMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// Requester2Mock is a mock implementation of test.Requester2. -// -// func TestSomethingThatUsesRequester2(t *testing.T) { -// -// // make and configure a mocked test.Requester2 -// mockedRequester2 := &Requester2Mock{ -// GetFunc: func(path string) error { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequester2 in code that requires test.Requester2 -// // and then make assertions. -// -// } -type Requester2Mock struct { - // GetFunc mocks the Get method. - GetFunc func(path string) error - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Path is the path argument value. - Path string - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *Requester2Mock) Get(path string) error { - if mock.GetFunc == nil { - panic("Requester2Mock.GetFunc: method is nil but Requester2.Get was just called") - } - callInfo := struct { - Path string - }{ - Path: path, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(path) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequester2.GetCalls()) -func (mock *Requester2Mock) GetCalls() []struct { - Path string -} { - var calls []struct { - Path string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *Requester2Mock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *Requester2Mock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// Requester3Mock is a mock implementation of test.Requester3. -// -// func TestSomethingThatUsesRequester3(t *testing.T) { -// -// // make and configure a mocked test.Requester3 -// mockedRequester3 := &Requester3Mock{ -// GetFunc: func() error { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequester3 in code that requires test.Requester3 -// // and then make assertions. -// -// } -type Requester3Mock struct { - // GetFunc mocks the Get method. - GetFunc func() error - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *Requester3Mock) Get() error { - if mock.GetFunc == nil { - panic("Requester3Mock.GetFunc: method is nil but Requester3.Get was just called") - } - callInfo := struct { - }{} - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc() -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequester3.GetCalls()) -func (mock *Requester3Mock) GetCalls() []struct { -} { - var calls []struct { - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *Requester3Mock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *Requester3Mock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// Requester4Mock is a mock implementation of test.Requester4. -// -// func TestSomethingThatUsesRequester4(t *testing.T) { -// -// // make and configure a mocked test.Requester4 -// mockedRequester4 := &Requester4Mock{ -// GetFunc: func() { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequester4 in code that requires test.Requester4 -// // and then make assertions. -// -// } -type Requester4Mock struct { - // GetFunc mocks the Get method. - GetFunc func() - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *Requester4Mock) Get() { - if mock.GetFunc == nil { - panic("Requester4Mock.GetFunc: method is nil but Requester4.Get was just called") - } - callInfo := struct { - }{} - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - mock.GetFunc() -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequester4.GetCalls()) -func (mock *Requester4Mock) GetCalls() []struct { -} { - var calls []struct { - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *Requester4Mock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *Requester4Mock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// RequesterArgSameAsImportMock is a mock implementation of test.RequesterArgSameAsImport. -// -// func TestSomethingThatUsesRequesterArgSameAsImport(t *testing.T) { -// -// // make and configure a mocked test.RequesterArgSameAsImport -// mockedRequesterArgSameAsImport := &RequesterArgSameAsImportMock{ -// GetFunc: func(json1 string) *json.RawMessage { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequesterArgSameAsImport in code that requires test.RequesterArgSameAsImport -// // and then make assertions. -// -// } -type RequesterArgSameAsImportMock struct { - // GetFunc mocks the Get method. - GetFunc func(json1 string) *json.RawMessage - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Json1 is the json1 argument value. - Json1 string - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *RequesterArgSameAsImportMock) Get(json1 string) *json.RawMessage { - if mock.GetFunc == nil { - panic("RequesterArgSameAsImportMock.GetFunc: method is nil but RequesterArgSameAsImport.Get was just called") - } - callInfo := struct { - Json1 string - }{ - Json1: json1, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(json1) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequesterArgSameAsImport.GetCalls()) -func (mock *RequesterArgSameAsImportMock) GetCalls() []struct { - Json1 string -} { - var calls []struct { - Json1 string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *RequesterArgSameAsImportMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *RequesterArgSameAsImportMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// RequesterArgSameAsNamedImportMock is a mock implementation of test.RequesterArgSameAsNamedImport. -// -// func TestSomethingThatUsesRequesterArgSameAsNamedImport(t *testing.T) { -// -// // make and configure a mocked test.RequesterArgSameAsNamedImport -// mockedRequesterArgSameAsNamedImport := &RequesterArgSameAsNamedImportMock{ -// GetFunc: func(json1 string) *json.RawMessage { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequesterArgSameAsNamedImport in code that requires test.RequesterArgSameAsNamedImport -// // and then make assertions. -// -// } -type RequesterArgSameAsNamedImportMock struct { - // GetFunc mocks the Get method. - GetFunc func(json1 string) *json.RawMessage - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Json1 is the json1 argument value. - Json1 string - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *RequesterArgSameAsNamedImportMock) Get(json1 string) *json.RawMessage { - if mock.GetFunc == nil { - panic("RequesterArgSameAsNamedImportMock.GetFunc: method is nil but RequesterArgSameAsNamedImport.Get was just called") - } - callInfo := struct { - Json1 string - }{ - Json1: json1, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(json1) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequesterArgSameAsNamedImport.GetCalls()) -func (mock *RequesterArgSameAsNamedImportMock) GetCalls() []struct { - Json1 string -} { - var calls []struct { - Json1 string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *RequesterArgSameAsNamedImportMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *RequesterArgSameAsNamedImportMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// RequesterArgSameAsPkgMock is a mock implementation of test.RequesterArgSameAsPkg. -// -// func TestSomethingThatUsesRequesterArgSameAsPkg(t *testing.T) { -// -// // make and configure a mocked test.RequesterArgSameAsPkg -// mockedRequesterArgSameAsPkg := &RequesterArgSameAsPkgMock{ -// GetFunc: func(test1 string) { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequesterArgSameAsPkg in code that requires test.RequesterArgSameAsPkg -// // and then make assertions. -// -// } -type RequesterArgSameAsPkgMock struct { - // GetFunc mocks the Get method. - GetFunc func(test1 string) - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Test1 is the test1 argument value. - Test1 string - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *RequesterArgSameAsPkgMock) Get(test1 string) { - if mock.GetFunc == nil { - panic("RequesterArgSameAsPkgMock.GetFunc: method is nil but RequesterArgSameAsPkg.Get was just called") - } - callInfo := struct { - Test1 string - }{ - Test1: test1, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - mock.GetFunc(test1) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequesterArgSameAsPkg.GetCalls()) -func (mock *RequesterArgSameAsPkgMock) GetCalls() []struct { - Test1 string -} { - var calls []struct { - Test1 string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *RequesterArgSameAsPkgMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *RequesterArgSameAsPkgMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// RequesterArrayMock is a mock implementation of test.RequesterArray. -// -// func TestSomethingThatUsesRequesterArray(t *testing.T) { -// -// // make and configure a mocked test.RequesterArray -// mockedRequesterArray := &RequesterArrayMock{ -// GetFunc: func(path string) ([2]string, error) { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequesterArray in code that requires test.RequesterArray -// // and then make assertions. -// -// } -type RequesterArrayMock struct { - // GetFunc mocks the Get method. - GetFunc func(path string) ([2]string, error) - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Path is the path argument value. - Path string - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *RequesterArrayMock) Get(path string) ([2]string, error) { - if mock.GetFunc == nil { - panic("RequesterArrayMock.GetFunc: method is nil but RequesterArray.Get was just called") - } - callInfo := struct { - Path string - }{ - Path: path, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(path) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequesterArray.GetCalls()) -func (mock *RequesterArrayMock) GetCalls() []struct { - Path string -} { - var calls []struct { - Path string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *RequesterArrayMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *RequesterArrayMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// RequesterElidedMock is a mock implementation of test.RequesterElided. -// -// func TestSomethingThatUsesRequesterElided(t *testing.T) { -// -// // make and configure a mocked test.RequesterElided -// mockedRequesterElided := &RequesterElidedMock{ -// GetFunc: func(path string, url string) error { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequesterElided in code that requires test.RequesterElided -// // and then make assertions. -// -// } -type RequesterElidedMock struct { - // GetFunc mocks the Get method. - GetFunc func(path string, url string) error - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Path is the path argument value. - Path string - // URL is the url argument value. - URL string - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *RequesterElidedMock) Get(path string, url string) error { - if mock.GetFunc == nil { - panic("RequesterElidedMock.GetFunc: method is nil but RequesterElided.Get was just called") - } - callInfo := struct { - Path string - URL string - }{ - Path: path, - URL: url, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(path, url) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequesterElided.GetCalls()) -func (mock *RequesterElidedMock) GetCalls() []struct { - Path string - URL string -} { - var calls []struct { - Path string - URL string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *RequesterElidedMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *RequesterElidedMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// RequesterIfaceMock is a mock implementation of test.RequesterIface. -// -// func TestSomethingThatUsesRequesterIface(t *testing.T) { -// -// // make and configure a mocked test.RequesterIface -// mockedRequesterIface := &RequesterIfaceMock{ -// GetFunc: func() io.Reader { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequesterIface in code that requires test.RequesterIface -// // and then make assertions. -// -// } -type RequesterIfaceMock struct { - // GetFunc mocks the Get method. - GetFunc func() io.Reader - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *RequesterIfaceMock) Get() io.Reader { - if mock.GetFunc == nil { - panic("RequesterIfaceMock.GetFunc: method is nil but RequesterIface.Get was just called") - } - callInfo := struct { - }{} - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc() -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequesterIface.GetCalls()) -func (mock *RequesterIfaceMock) GetCalls() []struct { -} { - var calls []struct { - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *RequesterIfaceMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *RequesterIfaceMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// RequesterNSMock is a mock implementation of test.RequesterNS. -// -// func TestSomethingThatUsesRequesterNS(t *testing.T) { -// -// // make and configure a mocked test.RequesterNS -// mockedRequesterNS := &RequesterNSMock{ -// GetFunc: func(path string) (http.Response, error) { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequesterNS in code that requires test.RequesterNS -// // and then make assertions. -// -// } -type RequesterNSMock struct { - // GetFunc mocks the Get method. - GetFunc func(path string) (http.Response, error) - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Path is the path argument value. - Path string - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *RequesterNSMock) Get(path string) (http.Response, error) { - if mock.GetFunc == nil { - panic("RequesterNSMock.GetFunc: method is nil but RequesterNS.Get was just called") - } - callInfo := struct { - Path string - }{ - Path: path, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(path) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequesterNS.GetCalls()) -func (mock *RequesterNSMock) GetCalls() []struct { - Path string -} { - var calls []struct { - Path string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *RequesterNSMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *RequesterNSMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// RequesterPtrMock is a mock implementation of test.RequesterPtr. -// -// func TestSomethingThatUsesRequesterPtr(t *testing.T) { -// -// // make and configure a mocked test.RequesterPtr -// mockedRequesterPtr := &RequesterPtrMock{ -// GetFunc: func(path string) (*string, error) { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequesterPtr in code that requires test.RequesterPtr -// // and then make assertions. -// -// } -type RequesterPtrMock struct { - // GetFunc mocks the Get method. - GetFunc func(path string) (*string, error) - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Path is the path argument value. - Path string - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *RequesterPtrMock) Get(path string) (*string, error) { - if mock.GetFunc == nil { - panic("RequesterPtrMock.GetFunc: method is nil but RequesterPtr.Get was just called") - } - callInfo := struct { - Path string - }{ - Path: path, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(path) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequesterPtr.GetCalls()) -func (mock *RequesterPtrMock) GetCalls() []struct { - Path string -} { - var calls []struct { - Path string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *RequesterPtrMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *RequesterPtrMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// RequesterReturnElidedMock is a mock implementation of test.RequesterReturnElided. -// -// func TestSomethingThatUsesRequesterReturnElided(t *testing.T) { -// -// // make and configure a mocked test.RequesterReturnElided -// mockedRequesterReturnElided := &RequesterReturnElidedMock{ -// GetFunc: func(path string) (int, int, int, error) { -// panic("mock out the Get method") -// }, -// PutFunc: func(path string) (int, error) { -// panic("mock out the Put method") -// }, -// } -// -// // use mockedRequesterReturnElided in code that requires test.RequesterReturnElided -// // and then make assertions. -// -// } -type RequesterReturnElidedMock struct { - // GetFunc mocks the Get method. - GetFunc func(path string) (int, int, int, error) - - // PutFunc mocks the Put method. - PutFunc func(path string) (int, error) - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Path is the path argument value. - Path string - } - // Put holds details about calls to the Put method. - Put []struct { - // Path is the path argument value. - Path string - } - } - lockGet sync.RWMutex - lockPut sync.RWMutex -} - -// Get calls GetFunc. -func (mock *RequesterReturnElidedMock) Get(path string) (int, int, int, error) { - if mock.GetFunc == nil { - panic("RequesterReturnElidedMock.GetFunc: method is nil but RequesterReturnElided.Get was just called") - } - callInfo := struct { - Path string - }{ - Path: path, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(path) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequesterReturnElided.GetCalls()) -func (mock *RequesterReturnElidedMock) GetCalls() []struct { - Path string -} { - var calls []struct { - Path string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *RequesterReturnElidedMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// Put calls PutFunc. -func (mock *RequesterReturnElidedMock) Put(path string) (int, error) { - if mock.PutFunc == nil { - panic("RequesterReturnElidedMock.PutFunc: method is nil but RequesterReturnElided.Put was just called") - } - callInfo := struct { - Path string - }{ - Path: path, - } - mock.lockPut.Lock() - mock.calls.Put = append(mock.calls.Put, callInfo) - mock.lockPut.Unlock() - return mock.PutFunc(path) -} - -// PutCalls gets all the calls that were made to Put. -// Check the length with: -// -// len(mockedRequesterReturnElided.PutCalls()) -func (mock *RequesterReturnElidedMock) PutCalls() []struct { - Path string -} { - var calls []struct { - Path string - } - mock.lockPut.RLock() - calls = mock.calls.Put - mock.lockPut.RUnlock() - return calls -} - -// ResetPutCalls reset all the calls that were made to Put. -func (mock *RequesterReturnElidedMock) ResetPutCalls() { - mock.lockPut.Lock() - mock.calls.Put = nil - mock.lockPut.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *RequesterReturnElidedMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() - - mock.lockPut.Lock() - mock.calls.Put = nil - mock.lockPut.Unlock() -} - -// RequesterSliceMock is a mock implementation of test.RequesterSlice. -// -// func TestSomethingThatUsesRequesterSlice(t *testing.T) { -// -// // make and configure a mocked test.RequesterSlice -// mockedRequesterSlice := &RequesterSliceMock{ -// GetFunc: func(path string) ([]string, error) { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedRequesterSlice in code that requires test.RequesterSlice -// // and then make assertions. -// -// } -type RequesterSliceMock struct { - // GetFunc mocks the Get method. - GetFunc func(path string) ([]string, error) - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Path is the path argument value. - Path string - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *RequesterSliceMock) Get(path string) ([]string, error) { - if mock.GetFunc == nil { - panic("RequesterSliceMock.GetFunc: method is nil but RequesterSlice.Get was just called") - } - callInfo := struct { - Path string - }{ - Path: path, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(path) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequesterSlice.GetCalls()) -func (mock *RequesterSliceMock) GetCalls() []struct { - Path string -} { - var calls []struct { - Path string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *RequesterSliceMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *RequesterSliceMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// requesterUnexportedMock is a mock implementation of test.requesterUnexported. -// -// func TestSomethingThatUsesrequesterUnexported(t *testing.T) { -// -// // make and configure a mocked test.requesterUnexported -// mockedrequesterUnexported := &requesterUnexportedMock{ -// GetFunc: func() { -// panic("mock out the Get method") -// }, -// } -// -// // use mockedrequesterUnexported in code that requires test.requesterUnexported -// // and then make assertions. -// -// } -type requesterUnexportedMock struct { - // GetFunc mocks the Get method. - GetFunc func() - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - } - } - lockGet sync.RWMutex -} - -// Get calls GetFunc. -func (mock *requesterUnexportedMock) Get() { - if mock.GetFunc == nil { - panic("requesterUnexportedMock.GetFunc: method is nil but requesterUnexported.Get was just called") - } - callInfo := struct { - }{} - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - mock.GetFunc() -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedrequesterUnexported.GetCalls()) -func (mock *requesterUnexportedMock) GetCalls() []struct { -} { - var calls []struct { - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *requesterUnexportedMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *requesterUnexportedMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// RequesterVariadicMock is a mock implementation of test.RequesterVariadic. -// -// func TestSomethingThatUsesRequesterVariadic(t *testing.T) { -// -// // make and configure a mocked test.RequesterVariadic -// mockedRequesterVariadic := &RequesterVariadicMock{ -// GetFunc: func(values ...string) bool { -// panic("mock out the Get method") -// }, -// MultiWriteToFileFunc: func(filename string, w ...io.Writer) string { -// panic("mock out the MultiWriteToFile method") -// }, -// OneInterfaceFunc: func(a ...interface{}) bool { -// panic("mock out the OneInterface method") -// }, -// SprintfFunc: func(format string, a ...interface{}) string { -// panic("mock out the Sprintf method") -// }, -// } -// -// // use mockedRequesterVariadic in code that requires test.RequesterVariadic -// // and then make assertions. -// -// } -type RequesterVariadicMock struct { - // GetFunc mocks the Get method. - GetFunc func(values ...string) bool - - // MultiWriteToFileFunc mocks the MultiWriteToFile method. - MultiWriteToFileFunc func(filename string, w ...io.Writer) string - - // OneInterfaceFunc mocks the OneInterface method. - OneInterfaceFunc func(a ...interface{}) bool - - // SprintfFunc mocks the Sprintf method. - SprintfFunc func(format string, a ...interface{}) string - - // calls tracks calls to the methods. - calls struct { - // Get holds details about calls to the Get method. - Get []struct { - // Values is the values argument value. - Values []string - } - // MultiWriteToFile holds details about calls to the MultiWriteToFile method. - MultiWriteToFile []struct { - // Filename is the filename argument value. - Filename string - // W is the w argument value. - W []io.Writer - } - // OneInterface holds details about calls to the OneInterface method. - OneInterface []struct { - // A is the a argument value. - A []interface{} - } - // Sprintf holds details about calls to the Sprintf method. - Sprintf []struct { - // Format is the format argument value. - Format string - // A is the a argument value. - A []interface{} - } - } - lockGet sync.RWMutex - lockMultiWriteToFile sync.RWMutex - lockOneInterface sync.RWMutex - lockSprintf sync.RWMutex -} - -// Get calls GetFunc. -func (mock *RequesterVariadicMock) Get(values ...string) bool { - if mock.GetFunc == nil { - panic("RequesterVariadicMock.GetFunc: method is nil but RequesterVariadic.Get was just called") - } - callInfo := struct { - Values []string - }{ - Values: values, - } - mock.lockGet.Lock() - mock.calls.Get = append(mock.calls.Get, callInfo) - mock.lockGet.Unlock() - return mock.GetFunc(values...) -} - -// GetCalls gets all the calls that were made to Get. -// Check the length with: -// -// len(mockedRequesterVariadic.GetCalls()) -func (mock *RequesterVariadicMock) GetCalls() []struct { - Values []string -} { - var calls []struct { - Values []string - } - mock.lockGet.RLock() - calls = mock.calls.Get - mock.lockGet.RUnlock() - return calls -} - -// ResetGetCalls reset all the calls that were made to Get. -func (mock *RequesterVariadicMock) ResetGetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() -} - -// MultiWriteToFile calls MultiWriteToFileFunc. -func (mock *RequesterVariadicMock) MultiWriteToFile(filename string, w ...io.Writer) string { - if mock.MultiWriteToFileFunc == nil { - panic("RequesterVariadicMock.MultiWriteToFileFunc: method is nil but RequesterVariadic.MultiWriteToFile was just called") - } - callInfo := struct { - Filename string - W []io.Writer - }{ - Filename: filename, - W: w, - } - mock.lockMultiWriteToFile.Lock() - mock.calls.MultiWriteToFile = append(mock.calls.MultiWriteToFile, callInfo) - mock.lockMultiWriteToFile.Unlock() - return mock.MultiWriteToFileFunc(filename, w...) -} - -// MultiWriteToFileCalls gets all the calls that were made to MultiWriteToFile. -// Check the length with: -// -// len(mockedRequesterVariadic.MultiWriteToFileCalls()) -func (mock *RequesterVariadicMock) MultiWriteToFileCalls() []struct { - Filename string - W []io.Writer -} { - var calls []struct { - Filename string - W []io.Writer - } - mock.lockMultiWriteToFile.RLock() - calls = mock.calls.MultiWriteToFile - mock.lockMultiWriteToFile.RUnlock() - return calls -} - -// ResetMultiWriteToFileCalls reset all the calls that were made to MultiWriteToFile. -func (mock *RequesterVariadicMock) ResetMultiWriteToFileCalls() { - mock.lockMultiWriteToFile.Lock() - mock.calls.MultiWriteToFile = nil - mock.lockMultiWriteToFile.Unlock() -} - -// OneInterface calls OneInterfaceFunc. -func (mock *RequesterVariadicMock) OneInterface(a ...interface{}) bool { - if mock.OneInterfaceFunc == nil { - panic("RequesterVariadicMock.OneInterfaceFunc: method is nil but RequesterVariadic.OneInterface was just called") - } - callInfo := struct { - A []interface{} - }{ - A: a, - } - mock.lockOneInterface.Lock() - mock.calls.OneInterface = append(mock.calls.OneInterface, callInfo) - mock.lockOneInterface.Unlock() - return mock.OneInterfaceFunc(a...) -} - -// OneInterfaceCalls gets all the calls that were made to OneInterface. -// Check the length with: -// -// len(mockedRequesterVariadic.OneInterfaceCalls()) -func (mock *RequesterVariadicMock) OneInterfaceCalls() []struct { - A []interface{} -} { - var calls []struct { - A []interface{} - } - mock.lockOneInterface.RLock() - calls = mock.calls.OneInterface - mock.lockOneInterface.RUnlock() - return calls -} - -// ResetOneInterfaceCalls reset all the calls that were made to OneInterface. -func (mock *RequesterVariadicMock) ResetOneInterfaceCalls() { - mock.lockOneInterface.Lock() - mock.calls.OneInterface = nil - mock.lockOneInterface.Unlock() -} - -// Sprintf calls SprintfFunc. -func (mock *RequesterVariadicMock) Sprintf(format string, a ...interface{}) string { - if mock.SprintfFunc == nil { - panic("RequesterVariadicMock.SprintfFunc: method is nil but RequesterVariadic.Sprintf was just called") - } - callInfo := struct { - Format string - A []interface{} - }{ - Format: format, - A: a, - } - mock.lockSprintf.Lock() - mock.calls.Sprintf = append(mock.calls.Sprintf, callInfo) - mock.lockSprintf.Unlock() - return mock.SprintfFunc(format, a...) -} - -// SprintfCalls gets all the calls that were made to Sprintf. -// Check the length with: -// -// len(mockedRequesterVariadic.SprintfCalls()) -func (mock *RequesterVariadicMock) SprintfCalls() []struct { - Format string - A []interface{} -} { - var calls []struct { - Format string - A []interface{} - } - mock.lockSprintf.RLock() - calls = mock.calls.Sprintf - mock.lockSprintf.RUnlock() - return calls -} - -// ResetSprintfCalls reset all the calls that were made to Sprintf. -func (mock *RequesterVariadicMock) ResetSprintfCalls() { - mock.lockSprintf.Lock() - mock.calls.Sprintf = nil - mock.lockSprintf.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *RequesterVariadicMock) ResetCalls() { - mock.lockGet.Lock() - mock.calls.Get = nil - mock.lockGet.Unlock() - - mock.lockMultiWriteToFile.Lock() - mock.calls.MultiWriteToFile = nil - mock.lockMultiWriteToFile.Unlock() - - mock.lockOneInterface.Lock() - mock.calls.OneInterface = nil - mock.lockOneInterface.Unlock() - - mock.lockSprintf.Lock() - mock.calls.Sprintf = nil - mock.lockSprintf.Unlock() -} - -// ExampleMock is a mock implementation of test.Example. -// -// func TestSomethingThatUsesExample(t *testing.T) { -// -// // make and configure a mocked test.Example -// mockedExample := &ExampleMock{ -// AFunc: func() http.Flusher { -// panic("mock out the A method") -// }, -// BFunc: func(fixtureshttp string) http0.MyStruct { -// panic("mock out the B method") -// }, -// CFunc: func(fixtureshttp string) http1.MyStruct { -// panic("mock out the C method") -// }, -// } -// -// // use mockedExample in code that requires test.Example -// // and then make assertions. -// -// } -type ExampleMock struct { - // AFunc mocks the A method. - AFunc func() http.Flusher - - // BFunc mocks the B method. - BFunc func(fixtureshttp string) http0.MyStruct - - // CFunc mocks the C method. - CFunc func(fixtureshttp string) http1.MyStruct - - // calls tracks calls to the methods. - calls struct { - // A holds details about calls to the A method. - A []struct { - } - // B holds details about calls to the B method. - B []struct { - // Fixtureshttp is the fixtureshttp argument value. - Fixtureshttp string - } - // C holds details about calls to the C method. - C []struct { - // Fixtureshttp is the fixtureshttp argument value. - Fixtureshttp string - } - } - lockA sync.RWMutex - lockB sync.RWMutex - lockC sync.RWMutex -} - -// A calls AFunc. -func (mock *ExampleMock) A() http.Flusher { - if mock.AFunc == nil { - panic("ExampleMock.AFunc: method is nil but Example.A was just called") - } - callInfo := struct { - }{} - mock.lockA.Lock() - mock.calls.A = append(mock.calls.A, callInfo) - mock.lockA.Unlock() - return mock.AFunc() -} - -// ACalls gets all the calls that were made to A. -// Check the length with: -// -// len(mockedExample.ACalls()) -func (mock *ExampleMock) ACalls() []struct { -} { - var calls []struct { - } - mock.lockA.RLock() - calls = mock.calls.A - mock.lockA.RUnlock() - return calls -} - -// ResetACalls reset all the calls that were made to A. -func (mock *ExampleMock) ResetACalls() { - mock.lockA.Lock() - mock.calls.A = nil - mock.lockA.Unlock() -} - -// B calls BFunc. -func (mock *ExampleMock) B(fixtureshttp string) http0.MyStruct { - if mock.BFunc == nil { - panic("ExampleMock.BFunc: method is nil but Example.B was just called") - } - callInfo := struct { - Fixtureshttp string - }{ - Fixtureshttp: fixtureshttp, - } - mock.lockB.Lock() - mock.calls.B = append(mock.calls.B, callInfo) - mock.lockB.Unlock() - return mock.BFunc(fixtureshttp) -} - -// BCalls gets all the calls that were made to B. -// Check the length with: -// -// len(mockedExample.BCalls()) -func (mock *ExampleMock) BCalls() []struct { - Fixtureshttp string -} { - var calls []struct { - Fixtureshttp string - } - mock.lockB.RLock() - calls = mock.calls.B - mock.lockB.RUnlock() - return calls -} - -// ResetBCalls reset all the calls that were made to B. -func (mock *ExampleMock) ResetBCalls() { - mock.lockB.Lock() - mock.calls.B = nil - mock.lockB.Unlock() -} - -// C calls CFunc. -func (mock *ExampleMock) C(fixtureshttp string) http1.MyStruct { - if mock.CFunc == nil { - panic("ExampleMock.CFunc: method is nil but Example.C was just called") - } - callInfo := struct { - Fixtureshttp string - }{ - Fixtureshttp: fixtureshttp, - } - mock.lockC.Lock() - mock.calls.C = append(mock.calls.C, callInfo) - mock.lockC.Unlock() - return mock.CFunc(fixtureshttp) -} - -// CCalls gets all the calls that were made to C. -// Check the length with: -// -// len(mockedExample.CCalls()) -func (mock *ExampleMock) CCalls() []struct { - Fixtureshttp string -} { - var calls []struct { - Fixtureshttp string - } - mock.lockC.RLock() - calls = mock.calls.C - mock.lockC.RUnlock() - return calls -} - -// ResetCCalls reset all the calls that were made to C. -func (mock *ExampleMock) ResetCCalls() { - mock.lockC.Lock() - mock.calls.C = nil - mock.lockC.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *ExampleMock) ResetCalls() { - mock.lockA.Lock() - mock.calls.A = nil - mock.lockA.Unlock() - - mock.lockB.Lock() - mock.calls.B = nil - mock.lockB.Unlock() - - mock.lockC.Lock() - mock.calls.C = nil - mock.lockC.Unlock() -} - -// AMock is a mock implementation of test.A. -// -// func TestSomethingThatUsesA(t *testing.T) { -// -// // make and configure a mocked test.A -// mockedA := &AMock{ -// CallFunc: func() (test.B, error) { -// panic("mock out the Call method") -// }, -// } -// -// // use mockedA in code that requires test.A -// // and then make assertions. -// -// } -type AMock struct { - // CallFunc mocks the Call method. - CallFunc func() (test.B, error) - - // calls tracks calls to the methods. - calls struct { - // Call holds details about calls to the Call method. - Call []struct { - } - } - lockCall sync.RWMutex -} - -// Call calls CallFunc. -func (mock *AMock) Call() (test.B, error) { - if mock.CallFunc == nil { - panic("AMock.CallFunc: method is nil but A.Call was just called") - } - callInfo := struct { - }{} - mock.lockCall.Lock() - mock.calls.Call = append(mock.calls.Call, callInfo) - mock.lockCall.Unlock() - return mock.CallFunc() -} - -// CallCalls gets all the calls that were made to Call. -// Check the length with: -// -// len(mockedA.CallCalls()) -func (mock *AMock) CallCalls() []struct { -} { - var calls []struct { - } - mock.lockCall.RLock() - calls = mock.calls.Call - mock.lockCall.RUnlock() - return calls -} - -// ResetCallCalls reset all the calls that were made to Call. -func (mock *AMock) ResetCallCalls() { - mock.lockCall.Lock() - mock.calls.Call = nil - mock.lockCall.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *AMock) ResetCalls() { - mock.lockCall.Lock() - mock.calls.Call = nil - mock.lockCall.Unlock() -} - -// StructWithTagMock is a mock implementation of test.StructWithTag. -// -// func TestSomethingThatUsesStructWithTag(t *testing.T) { -// -// // make and configure a mocked test.StructWithTag -// mockedStructWithTag := &StructWithTagMock{ -// MethodAFunc: func(v *struct{FieldA int "json:\"field_a\""; FieldB int "json:\"field_b\" xml:\"field_b\""}) *struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""} { -// panic("mock out the MethodA method") -// }, -// } -// -// // use mockedStructWithTag in code that requires test.StructWithTag -// // and then make assertions. -// -// } -type StructWithTagMock struct { - // MethodAFunc mocks the MethodA method. - MethodAFunc func(v *struct { - FieldA int "json:\"field_a\"" - FieldB int "json:\"field_b\" xml:\"field_b\"" - }) *struct { - FieldC int "json:\"field_c\"" - FieldD int "json:\"field_d\" xml:\"field_d\"" - } - - // calls tracks calls to the methods. - calls struct { - // MethodA holds details about calls to the MethodA method. - MethodA []struct { - // V is the v argument value. - V *struct { - FieldA int "json:\"field_a\"" - FieldB int "json:\"field_b\" xml:\"field_b\"" - } - } - } - lockMethodA sync.RWMutex -} - -// MethodA calls MethodAFunc. -func (mock *StructWithTagMock) MethodA(v *struct { - FieldA int "json:\"field_a\"" - FieldB int "json:\"field_b\" xml:\"field_b\"" -}) *struct { - FieldC int "json:\"field_c\"" - FieldD int "json:\"field_d\" xml:\"field_d\"" -} { - if mock.MethodAFunc == nil { - panic("StructWithTagMock.MethodAFunc: method is nil but StructWithTag.MethodA was just called") - } - callInfo := struct { - V *struct { - FieldA int "json:\"field_a\"" - FieldB int "json:\"field_b\" xml:\"field_b\"" - } - }{ - V: v, - } - mock.lockMethodA.Lock() - mock.calls.MethodA = append(mock.calls.MethodA, callInfo) - mock.lockMethodA.Unlock() - return mock.MethodAFunc(v) -} - -// MethodACalls gets all the calls that were made to MethodA. -// Check the length with: -// -// len(mockedStructWithTag.MethodACalls()) -func (mock *StructWithTagMock) MethodACalls() []struct { - V *struct { - FieldA int "json:\"field_a\"" - FieldB int "json:\"field_b\" xml:\"field_b\"" - } -} { - var calls []struct { - V *struct { - FieldA int "json:\"field_a\"" - FieldB int "json:\"field_b\" xml:\"field_b\"" - } - } - mock.lockMethodA.RLock() - calls = mock.calls.MethodA - mock.lockMethodA.RUnlock() - return calls -} - -// ResetMethodACalls reset all the calls that were made to MethodA. -func (mock *StructWithTagMock) ResetMethodACalls() { - mock.lockMethodA.Lock() - mock.calls.MethodA = nil - mock.lockMethodA.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *StructWithTagMock) ResetCalls() { - mock.lockMethodA.Lock() - mock.calls.MethodA = nil - mock.lockMethodA.Unlock() -} - -// VariadicMock is a mock implementation of test.Variadic. -// -// func TestSomethingThatUsesVariadic(t *testing.T) { -// -// // make and configure a mocked test.Variadic -// mockedVariadic := &VariadicMock{ -// VariadicFunctionFunc: func(str string, vFunc test.VariadicFunction) error { -// panic("mock out the VariadicFunction method") -// }, -// } -// -// // use mockedVariadic in code that requires test.Variadic -// // and then make assertions. -// -// } -type VariadicMock struct { - // VariadicFunctionFunc mocks the VariadicFunction method. - VariadicFunctionFunc func(str string, vFunc test.VariadicFunction) error - - // calls tracks calls to the methods. - calls struct { - // VariadicFunction holds details about calls to the VariadicFunction method. - VariadicFunction []struct { - // Str is the str argument value. - Str string - // VFunc is the vFunc argument value. - VFunc test.VariadicFunction - } - } - lockVariadicFunction sync.RWMutex -} - -// VariadicFunction calls VariadicFunctionFunc. -func (mock *VariadicMock) VariadicFunction(str string, vFunc test.VariadicFunction) error { - if mock.VariadicFunctionFunc == nil { - panic("VariadicMock.VariadicFunctionFunc: method is nil but Variadic.VariadicFunction was just called") - } - callInfo := struct { - Str string - VFunc test.VariadicFunction - }{ - Str: str, - VFunc: vFunc, - } - mock.lockVariadicFunction.Lock() - mock.calls.VariadicFunction = append(mock.calls.VariadicFunction, callInfo) - mock.lockVariadicFunction.Unlock() - return mock.VariadicFunctionFunc(str, vFunc) -} - -// VariadicFunctionCalls gets all the calls that were made to VariadicFunction. -// Check the length with: -// -// len(mockedVariadic.VariadicFunctionCalls()) -func (mock *VariadicMock) VariadicFunctionCalls() []struct { - Str string - VFunc test.VariadicFunction -} { - var calls []struct { - Str string - VFunc test.VariadicFunction - } - mock.lockVariadicFunction.RLock() - calls = mock.calls.VariadicFunction - mock.lockVariadicFunction.RUnlock() - return calls -} - -// ResetVariadicFunctionCalls reset all the calls that were made to VariadicFunction. -func (mock *VariadicMock) ResetVariadicFunctionCalls() { - mock.lockVariadicFunction.Lock() - mock.calls.VariadicFunction = nil - mock.lockVariadicFunction.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *VariadicMock) ResetCalls() { - mock.lockVariadicFunction.Lock() - mock.calls.VariadicFunction = nil - mock.lockVariadicFunction.Unlock() -} - -// VariadicReturnFuncMock is a mock implementation of test.VariadicReturnFunc. -// -// func TestSomethingThatUsesVariadicReturnFunc(t *testing.T) { -// -// // make and configure a mocked test.VariadicReturnFunc -// mockedVariadicReturnFunc := &VariadicReturnFuncMock{ -// SampleMethodFunc: func(str string) func(str string, arr []int, a ...interface{}) { -// panic("mock out the SampleMethod method") -// }, -// } -// -// // use mockedVariadicReturnFunc in code that requires test.VariadicReturnFunc -// // and then make assertions. -// -// } -type VariadicReturnFuncMock struct { - // SampleMethodFunc mocks the SampleMethod method. - SampleMethodFunc func(str string) func(str string, arr []int, a ...interface{}) - - // calls tracks calls to the methods. - calls struct { - // SampleMethod holds details about calls to the SampleMethod method. - SampleMethod []struct { - // Str is the str argument value. - Str string - } - } - lockSampleMethod sync.RWMutex -} - -// SampleMethod calls SampleMethodFunc. -func (mock *VariadicReturnFuncMock) SampleMethod(str string) func(str string, arr []int, a ...interface{}) { - if mock.SampleMethodFunc == nil { - panic("VariadicReturnFuncMock.SampleMethodFunc: method is nil but VariadicReturnFunc.SampleMethod was just called") - } - callInfo := struct { - Str string - }{ - Str: str, - } - mock.lockSampleMethod.Lock() - mock.calls.SampleMethod = append(mock.calls.SampleMethod, callInfo) - mock.lockSampleMethod.Unlock() - return mock.SampleMethodFunc(str) -} - -// SampleMethodCalls gets all the calls that were made to SampleMethod. -// Check the length with: -// -// len(mockedVariadicReturnFunc.SampleMethodCalls()) -func (mock *VariadicReturnFuncMock) SampleMethodCalls() []struct { - Str string -} { - var calls []struct { - Str string - } - mock.lockSampleMethod.RLock() - calls = mock.calls.SampleMethod - mock.lockSampleMethod.RUnlock() - return calls -} - -// ResetSampleMethodCalls reset all the calls that were made to SampleMethod. -func (mock *VariadicReturnFuncMock) ResetSampleMethodCalls() { - mock.lockSampleMethod.Lock() - mock.calls.SampleMethod = nil - mock.lockSampleMethod.Unlock() -} - -// ResetCalls reset all the calls that were made to all mocked methods. -func (mock *VariadicReturnFuncMock) ResetCalls() { - mock.lockSampleMethod.Lock() - mock.calls.SampleMethod = nil - mock.lockSampleMethod.Unlock() -} diff --git a/pkg/fixtures/mocks.go b/pkg/fixtures/mocks.go new file mode 100644 index 00000000..5c4c5919 --- /dev/null +++ b/pkg/fixtures/mocks.go @@ -0,0 +1,5706 @@ + +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery + +package test + +import ( + "encoding/json" + http1 "github.com/vektra/mockery/v3/pkg/fixtures/12345678/http" + "github.com/vektra/mockery/v3/pkg/fixtures/constraints" + http0 "github.com/vektra/mockery/v3/pkg/fixtures/http" + "github.com/vektra/mockery/v3/pkg/fixtures/redefined_type_b" + "io" + "net/http" + "unsafe" + mock "github.com/stretchr/testify/mock" +) + + +// NewMockUsesAny creates a new instance of MockUsesAny. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockUsesAny (t interface { + mock.TestingT + Cleanup(func()) +}) *MockUsesAny { + mock := &MockUsesAny{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockUsesAny is an autogenerated mock type for the UsesAny type +type MockUsesAny struct { + mock.Mock +} + +type MockUsesAny_Expecter struct { + mock *mock.Mock +} + +func (_m *MockUsesAny) EXPECT() *MockUsesAny_Expecter { + return &MockUsesAny_Expecter{mock: &_m.Mock} +} + + + +// GetReader provides a mock function for the type MockUsesAny +func (_mock *MockUsesAny) GetReader() any { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for GetReader") + } + + + var r0 any + if returnFunc, ok := ret.Get(0).(func() any); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(any) + } + } + return r0 +} + + + +// MockUsesAny_GetReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReader' +type MockUsesAny_GetReader_Call struct { + *mock.Call +} + + + +// GetReader is a helper method to define mock.On call +func (_e *MockUsesAny_Expecter) GetReader() *MockUsesAny_GetReader_Call { + return &MockUsesAny_GetReader_Call{Call: _e.mock.On("GetReader", )} +} + +func (_c *MockUsesAny_GetReader_Call) Run(run func()) *MockUsesAny_GetReader_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockUsesAny_GetReader_Call) Return(v any) *MockUsesAny_GetReader_Call { + _c.Call.Return(v) + return _c +} + +func (_c *MockUsesAny_GetReader_Call) RunAndReturn(run func()any) *MockUsesAny_GetReader_Call { + _c.Call.Return(run) + return _c +} + +// NewMockFooer creates a new instance of MockFooer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockFooer (t interface { + mock.TestingT + Cleanup(func()) +}) *MockFooer { + mock := &MockFooer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockFooer is an autogenerated mock type for the Fooer type +type MockFooer struct { + mock.Mock +} + +type MockFooer_Expecter struct { + mock *mock.Mock +} + +func (_m *MockFooer) EXPECT() *MockFooer_Expecter { + return &MockFooer_Expecter{mock: &_m.Mock} +} + + + +// Bar provides a mock function for the type MockFooer +func (_mock *MockFooer) Bar(f func([]int)) { _mock.Called(f) + return +} + + + +// MockFooer_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar' +type MockFooer_Bar_Call struct { + *mock.Call +} + + + +// Bar is a helper method to define mock.On call +// - f +func (_e *MockFooer_Expecter) Bar(f interface{}, ) *MockFooer_Bar_Call { + return &MockFooer_Bar_Call{Call: _e.mock.On("Bar",f, )} +} + +func (_c *MockFooer_Bar_Call) Run(run func(f func([]int))) *MockFooer_Bar_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func([]int)),) + }) + return _c +} + +func (_c *MockFooer_Bar_Call) Return() *MockFooer_Bar_Call { + _c.Call.Return() + return _c +} + +func (_c *MockFooer_Bar_Call) RunAndReturn(run func(f func([]int))) *MockFooer_Bar_Call { + _c.Run(run) + return _c +} + + +// Baz provides a mock function for the type MockFooer +func (_mock *MockFooer) Baz(path string) func(x string) string { + ret := _mock.Called(path) + + if len(ret) == 0 { + panic("no return value specified for Baz") + } + + + var r0 func(x string) string + if returnFunc, ok := ret.Get(0).(func(string) func(x string) string); ok { + r0 = returnFunc(path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(func(x string) string) + } + } + return r0 +} + + + +// MockFooer_Baz_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Baz' +type MockFooer_Baz_Call struct { + *mock.Call +} + + + +// Baz is a helper method to define mock.On call +// - path +func (_e *MockFooer_Expecter) Baz(path interface{}, ) *MockFooer_Baz_Call { + return &MockFooer_Baz_Call{Call: _e.mock.On("Baz",path, )} +} + +func (_c *MockFooer_Baz_Call) Run(run func(path string)) *MockFooer_Baz_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockFooer_Baz_Call) Return(fn func(x string) string) *MockFooer_Baz_Call { + _c.Call.Return(fn) + return _c +} + +func (_c *MockFooer_Baz_Call) RunAndReturn(run func(path string)func(x string) string) *MockFooer_Baz_Call { + _c.Call.Return(run) + return _c +} + + +// Foo provides a mock function for the type MockFooer +func (_mock *MockFooer) Foo(f func(x string) string) error { + ret := _mock.Called(f) + + if len(ret) == 0 { + panic("no return value specified for Foo") + } + + + var r0 error + if returnFunc, ok := ret.Get(0).(func(func(x string) string) error); ok { + r0 = returnFunc(f) + } else { + r0 = ret.Error(0) + } + return r0 +} + + + +// MockFooer_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo' +type MockFooer_Foo_Call struct { + *mock.Call +} + + + +// Foo is a helper method to define mock.On call +// - f +func (_e *MockFooer_Expecter) Foo(f interface{}, ) *MockFooer_Foo_Call { + return &MockFooer_Foo_Call{Call: _e.mock.On("Foo",f, )} +} + +func (_c *MockFooer_Foo_Call) Run(run func(f func(x string) string)) *MockFooer_Foo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(x string) string),) + }) + return _c +} + +func (_c *MockFooer_Foo_Call) Return(err error) *MockFooer_Foo_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockFooer_Foo_Call) RunAndReturn(run func(f func(x string) string)error) *MockFooer_Foo_Call { + _c.Call.Return(run) + return _c +} + +// NewMockMapFunc creates a new instance of MockMapFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockMapFunc (t interface { + mock.TestingT + Cleanup(func()) +}) *MockMapFunc { + mock := &MockMapFunc{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockMapFunc is an autogenerated mock type for the MapFunc type +type MockMapFunc struct { + mock.Mock +} + +type MockMapFunc_Expecter struct { + mock *mock.Mock +} + +func (_m *MockMapFunc) EXPECT() *MockMapFunc_Expecter { + return &MockMapFunc_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockMapFunc +func (_mock *MockMapFunc) Get(m map[string]func(string) string) error { + ret := _mock.Called(m) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 error + if returnFunc, ok := ret.Get(0).(func(map[string]func(string) string) error); ok { + r0 = returnFunc(m) + } else { + r0 = ret.Error(0) + } + return r0 +} + + + +// MockMapFunc_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockMapFunc_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - m +func (_e *MockMapFunc_Expecter) Get(m interface{}, ) *MockMapFunc_Get_Call { + return &MockMapFunc_Get_Call{Call: _e.mock.On("Get",m, )} +} + +func (_c *MockMapFunc_Get_Call) Run(run func(m map[string]func(string) string)) *MockMapFunc_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(map[string]func(string) string),) + }) + return _c +} + +func (_c *MockMapFunc_Get_Call) Return(err error) *MockMapFunc_Get_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockMapFunc_Get_Call) RunAndReturn(run func(m map[string]func(string) string)error) *MockMapFunc_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockAsyncProducer creates a new instance of MockAsyncProducer. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockAsyncProducer (t interface { + mock.TestingT + Cleanup(func()) +}) *MockAsyncProducer { + mock := &MockAsyncProducer{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockAsyncProducer is an autogenerated mock type for the AsyncProducer type +type MockAsyncProducer struct { + mock.Mock +} + +type MockAsyncProducer_Expecter struct { + mock *mock.Mock +} + +func (_m *MockAsyncProducer) EXPECT() *MockAsyncProducer_Expecter { + return &MockAsyncProducer_Expecter{mock: &_m.Mock} +} + + + +// Input provides a mock function for the type MockAsyncProducer +func (_mock *MockAsyncProducer) Input() chan<- bool { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Input") + } + + + var r0 chan<- bool + if returnFunc, ok := ret.Get(0).(func() chan<- bool); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(chan<- bool) + } + } + return r0 +} + + + +// MockAsyncProducer_Input_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Input' +type MockAsyncProducer_Input_Call struct { + *mock.Call +} + + + +// Input is a helper method to define mock.On call +func (_e *MockAsyncProducer_Expecter) Input() *MockAsyncProducer_Input_Call { + return &MockAsyncProducer_Input_Call{Call: _e.mock.On("Input", )} +} + +func (_c *MockAsyncProducer_Input_Call) Run(run func()) *MockAsyncProducer_Input_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAsyncProducer_Input_Call) Return(boolCh chan<- bool) *MockAsyncProducer_Input_Call { + _c.Call.Return(boolCh) + return _c +} + +func (_c *MockAsyncProducer_Input_Call) RunAndReturn(run func()chan<- bool) *MockAsyncProducer_Input_Call { + _c.Call.Return(run) + return _c +} + + +// Output provides a mock function for the type MockAsyncProducer +func (_mock *MockAsyncProducer) Output() <-chan bool { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Output") + } + + + var r0 <-chan bool + if returnFunc, ok := ret.Get(0).(func() <-chan bool); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(<-chan bool) + } + } + return r0 +} + + + +// MockAsyncProducer_Output_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Output' +type MockAsyncProducer_Output_Call struct { + *mock.Call +} + + + +// Output is a helper method to define mock.On call +func (_e *MockAsyncProducer_Expecter) Output() *MockAsyncProducer_Output_Call { + return &MockAsyncProducer_Output_Call{Call: _e.mock.On("Output", )} +} + +func (_c *MockAsyncProducer_Output_Call) Run(run func()) *MockAsyncProducer_Output_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAsyncProducer_Output_Call) Return(boolCh <-chan bool) *MockAsyncProducer_Output_Call { + _c.Call.Return(boolCh) + return _c +} + +func (_c *MockAsyncProducer_Output_Call) RunAndReturn(run func()<-chan bool) *MockAsyncProducer_Output_Call { + _c.Call.Return(run) + return _c +} + + +// Whatever provides a mock function for the type MockAsyncProducer +func (_mock *MockAsyncProducer) Whatever() chan bool { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Whatever") + } + + + var r0 chan bool + if returnFunc, ok := ret.Get(0).(func() chan bool); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(chan bool) + } + } + return r0 +} + + + +// MockAsyncProducer_Whatever_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Whatever' +type MockAsyncProducer_Whatever_Call struct { + *mock.Call +} + + + +// Whatever is a helper method to define mock.On call +func (_e *MockAsyncProducer_Expecter) Whatever() *MockAsyncProducer_Whatever_Call { + return &MockAsyncProducer_Whatever_Call{Call: _e.mock.On("Whatever", )} +} + +func (_c *MockAsyncProducer_Whatever_Call) Run(run func()) *MockAsyncProducer_Whatever_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockAsyncProducer_Whatever_Call) Return(boolCh chan bool) *MockAsyncProducer_Whatever_Call { + _c.Call.Return(boolCh) + return _c +} + +func (_c *MockAsyncProducer_Whatever_Call) RunAndReturn(run func()chan bool) *MockAsyncProducer_Whatever_Call { + _c.Call.Return(run) + return _c +} + +// NewMockConsulLock creates a new instance of MockConsulLock. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockConsulLock (t interface { + mock.TestingT + Cleanup(func()) +}) *MockConsulLock { + mock := &MockConsulLock{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockConsulLock is an autogenerated mock type for the ConsulLock type +type MockConsulLock struct { + mock.Mock +} + +type MockConsulLock_Expecter struct { + mock *mock.Mock +} + +func (_m *MockConsulLock) EXPECT() *MockConsulLock_Expecter { + return &MockConsulLock_Expecter{mock: &_m.Mock} +} + + + +// Lock provides a mock function for the type MockConsulLock +func (_mock *MockConsulLock) Lock(valCh <-chan struct{}) (<-chan struct{}, error) { + ret := _mock.Called(valCh) + + if len(ret) == 0 { + panic("no return value specified for Lock") + } + + + var r0 <-chan struct{} + var r1 error + if returnFunc, ok := ret.Get(0).(func(<-chan struct{}) (<-chan struct{}, error)); ok { + return returnFunc(valCh) + } + if returnFunc, ok := ret.Get(0).(func(<-chan struct{}) <-chan struct{}); ok { + r0 = returnFunc(valCh) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(<-chan struct{}) + } + } + if returnFunc, ok := ret.Get(1).(func(<-chan struct{}) error); ok { + r1 = returnFunc(valCh) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockConsulLock_Lock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Lock' +type MockConsulLock_Lock_Call struct { + *mock.Call +} + + + +// Lock is a helper method to define mock.On call +// - valCh +func (_e *MockConsulLock_Expecter) Lock(valCh interface{}, ) *MockConsulLock_Lock_Call { + return &MockConsulLock_Lock_Call{Call: _e.mock.On("Lock",valCh, )} +} + +func (_c *MockConsulLock_Lock_Call) Run(run func(valCh <-chan struct{})) *MockConsulLock_Lock_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(<-chan struct{}),) + }) + return _c +} + +func (_c *MockConsulLock_Lock_Call) Return(valCh1 <-chan struct{}, err error) *MockConsulLock_Lock_Call { + _c.Call.Return(valCh1, err) + return _c +} + +func (_c *MockConsulLock_Lock_Call) RunAndReturn(run func(valCh <-chan struct{})(<-chan struct{}, error)) *MockConsulLock_Lock_Call { + _c.Call.Return(run) + return _c +} + + +// Unlock provides a mock function for the type MockConsulLock +func (_mock *MockConsulLock) Unlock() error { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Unlock") + } + + + var r0 error + if returnFunc, ok := ret.Get(0).(func() error); ok { + r0 = returnFunc() + } else { + r0 = ret.Error(0) + } + return r0 +} + + + +// MockConsulLock_Unlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unlock' +type MockConsulLock_Unlock_Call struct { + *mock.Call +} + + + +// Unlock is a helper method to define mock.On call +func (_e *MockConsulLock_Expecter) Unlock() *MockConsulLock_Unlock_Call { + return &MockConsulLock_Unlock_Call{Call: _e.mock.On("Unlock", )} +} + +func (_c *MockConsulLock_Unlock_Call) Run(run func()) *MockConsulLock_Unlock_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockConsulLock_Unlock_Call) Return(err error) *MockConsulLock_Unlock_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockConsulLock_Unlock_Call) RunAndReturn(run func()error) *MockConsulLock_Unlock_Call { + _c.Call.Return(run) + return _c +} + +// NewMockKeyManager creates a new instance of MockKeyManager. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockKeyManager (t interface { + mock.TestingT + Cleanup(func()) +}) *MockKeyManager { + mock := &MockKeyManager{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockKeyManager is an autogenerated mock type for the KeyManager type +type MockKeyManager struct { + mock.Mock +} + +type MockKeyManager_Expecter struct { + mock *mock.Mock +} + +func (_m *MockKeyManager) EXPECT() *MockKeyManager_Expecter { + return &MockKeyManager_Expecter{mock: &_m.Mock} +} + + + +// GetKey provides a mock function for the type MockKeyManager +func (_mock *MockKeyManager) GetKey(s string, v uint16) ([]byte, *Err) { + ret := _mock.Called(s, v) + + if len(ret) == 0 { + panic("no return value specified for GetKey") + } + + + var r0 []byte + var r1 *Err + if returnFunc, ok := ret.Get(0).(func(string, uint16) ([]byte, *Err)); ok { + return returnFunc(s, v) + } + if returnFunc, ok := ret.Get(0).(func(string, uint16) []byte); ok { + r0 = returnFunc(s, v) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]byte) + } + } + if returnFunc, ok := ret.Get(1).(func(string, uint16) *Err); ok { + r1 = returnFunc(s, v) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(*Err) + } + } + return r0, r1 +} + + + +// MockKeyManager_GetKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKey' +type MockKeyManager_GetKey_Call struct { + *mock.Call +} + + + +// GetKey is a helper method to define mock.On call +// - s +// - v +func (_e *MockKeyManager_Expecter) GetKey(s interface{}, v interface{}, ) *MockKeyManager_GetKey_Call { + return &MockKeyManager_GetKey_Call{Call: _e.mock.On("GetKey",s,v, )} +} + +func (_c *MockKeyManager_GetKey_Call) Run(run func(s string, v uint16)) *MockKeyManager_GetKey_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),args[1].(uint16),) + }) + return _c +} + +func (_c *MockKeyManager_GetKey_Call) Return(bytes []byte, err *Err) *MockKeyManager_GetKey_Call { + _c.Call.Return(bytes, err) + return _c +} + +func (_c *MockKeyManager_GetKey_Call) RunAndReturn(run func(s string, v uint16)([]byte, *Err)) *MockKeyManager_GetKey_Call { + _c.Call.Return(run) + return _c +} + +// NewMockBlank creates a new instance of MockBlank. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockBlank (t interface { + mock.TestingT + Cleanup(func()) +}) *MockBlank { + mock := &MockBlank{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockBlank is an autogenerated mock type for the Blank type +type MockBlank struct { + mock.Mock +} + +type MockBlank_Expecter struct { + mock *mock.Mock +} + +func (_m *MockBlank) EXPECT() *MockBlank_Expecter { + return &MockBlank_Expecter{mock: &_m.Mock} +} + + + +// Create provides a mock function for the type MockBlank +func (_mock *MockBlank) Create(x interface{}) error { + ret := _mock.Called(x) + + if len(ret) == 0 { + panic("no return value specified for Create") + } + + + var r0 error + if returnFunc, ok := ret.Get(0).(func(interface{}) error); ok { + r0 = returnFunc(x) + } else { + r0 = ret.Error(0) + } + return r0 +} + + + +// MockBlank_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create' +type MockBlank_Create_Call struct { + *mock.Call +} + + + +// Create is a helper method to define mock.On call +// - x +func (_e *MockBlank_Expecter) Create(x interface{}, ) *MockBlank_Create_Call { + return &MockBlank_Create_Call{Call: _e.mock.On("Create",x, )} +} + +func (_c *MockBlank_Create_Call) Run(run func(x interface{})) *MockBlank_Create_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{}),) + }) + return _c +} + +func (_c *MockBlank_Create_Call) Return(err error) *MockBlank_Create_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockBlank_Create_Call) RunAndReturn(run func(x interface{})error) *MockBlank_Create_Call { + _c.Call.Return(run) + return _c +} + +// NewMockExpecterAndRolledVariadic creates a new instance of MockExpecterAndRolledVariadic. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockExpecterAndRolledVariadic (t interface { + mock.TestingT + Cleanup(func()) +}) *MockExpecterAndRolledVariadic { + mock := &MockExpecterAndRolledVariadic{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockExpecterAndRolledVariadic is an autogenerated mock type for the Expecter type +type MockExpecterAndRolledVariadic struct { + mock.Mock +} + +type MockExpecterAndRolledVariadic_Expecter struct { + mock *mock.Mock +} + +func (_m *MockExpecterAndRolledVariadic) EXPECT() *MockExpecterAndRolledVariadic_Expecter { + return &MockExpecterAndRolledVariadic_Expecter{mock: &_m.Mock} +} + + + +// ManyArgsReturns provides a mock function for the type MockExpecterAndRolledVariadic +func (_mock *MockExpecterAndRolledVariadic) ManyArgsReturns(str string, i int) ([]string, error) { + ret := _mock.Called(str, i) + + if len(ret) == 0 { + panic("no return value specified for ManyArgsReturns") + } + + + var r0 []string + var r1 error + if returnFunc, ok := ret.Get(0).(func(string, int) ([]string, error)); ok { + return returnFunc(str, i) + } + if returnFunc, ok := ret.Get(0).(func(string, int) []string); ok { + r0 = returnFunc(str, i) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + if returnFunc, ok := ret.Get(1).(func(string, int) error); ok { + r1 = returnFunc(str, i) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockExpecterAndRolledVariadic_ManyArgsReturns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManyArgsReturns' +type MockExpecterAndRolledVariadic_ManyArgsReturns_Call struct { + *mock.Call +} + + + +// ManyArgsReturns is a helper method to define mock.On call +// - str +// - i +func (_e *MockExpecterAndRolledVariadic_Expecter) ManyArgsReturns(str interface{}, i interface{}, ) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call { + return &MockExpecterAndRolledVariadic_ManyArgsReturns_Call{Call: _e.mock.On("ManyArgsReturns",str,i, )} +} + +func (_c *MockExpecterAndRolledVariadic_ManyArgsReturns_Call) Run(run func(str string, i int)) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),args[1].(int),) + }) + return _c +} + +func (_c *MockExpecterAndRolledVariadic_ManyArgsReturns_Call) Return(strs []string, err error) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call { + _c.Call.Return(strs, err) + return _c +} + +func (_c *MockExpecterAndRolledVariadic_ManyArgsReturns_Call) RunAndReturn(run func(str string, i int)([]string, error)) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call { + _c.Call.Return(run) + return _c +} + + +// NoArg provides a mock function for the type MockExpecterAndRolledVariadic +func (_mock *MockExpecterAndRolledVariadic) NoArg() string { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for NoArg") + } + + + var r0 string + if returnFunc, ok := ret.Get(0).(func() string); ok { + r0 = returnFunc() + } else { + r0 = ret.Get(0).(string) + } + return r0 +} + + + +// MockExpecterAndRolledVariadic_NoArg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoArg' +type MockExpecterAndRolledVariadic_NoArg_Call struct { + *mock.Call +} + + + +// NoArg is a helper method to define mock.On call +func (_e *MockExpecterAndRolledVariadic_Expecter) NoArg() *MockExpecterAndRolledVariadic_NoArg_Call { + return &MockExpecterAndRolledVariadic_NoArg_Call{Call: _e.mock.On("NoArg", )} +} + +func (_c *MockExpecterAndRolledVariadic_NoArg_Call) Run(run func()) *MockExpecterAndRolledVariadic_NoArg_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockExpecterAndRolledVariadic_NoArg_Call) Return(s string) *MockExpecterAndRolledVariadic_NoArg_Call { + _c.Call.Return(s) + return _c +} + +func (_c *MockExpecterAndRolledVariadic_NoArg_Call) RunAndReturn(run func()string) *MockExpecterAndRolledVariadic_NoArg_Call { + _c.Call.Return(run) + return _c +} + + +// NoReturn provides a mock function for the type MockExpecterAndRolledVariadic +func (_mock *MockExpecterAndRolledVariadic) NoReturn(str string) { _mock.Called(str) + return +} + + + +// MockExpecterAndRolledVariadic_NoReturn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoReturn' +type MockExpecterAndRolledVariadic_NoReturn_Call struct { + *mock.Call +} + + + +// NoReturn is a helper method to define mock.On call +// - str +func (_e *MockExpecterAndRolledVariadic_Expecter) NoReturn(str interface{}, ) *MockExpecterAndRolledVariadic_NoReturn_Call { + return &MockExpecterAndRolledVariadic_NoReturn_Call{Call: _e.mock.On("NoReturn",str, )} +} + +func (_c *MockExpecterAndRolledVariadic_NoReturn_Call) Run(run func(str string)) *MockExpecterAndRolledVariadic_NoReturn_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockExpecterAndRolledVariadic_NoReturn_Call) Return() *MockExpecterAndRolledVariadic_NoReturn_Call { + _c.Call.Return() + return _c +} + +func (_c *MockExpecterAndRolledVariadic_NoReturn_Call) RunAndReturn(run func(str string)) *MockExpecterAndRolledVariadic_NoReturn_Call { + _c.Run(run) + return _c +} + + +// Variadic provides a mock function for the type MockExpecterAndRolledVariadic +func (_mock *MockExpecterAndRolledVariadic) Variadic(ints ...int) error { + var tmpRet mock.Arguments + if len(ints) > 0 {tmpRet = _mock.Called(ints) + } else {tmpRet = _mock.Called() + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for Variadic") + } + + + var r0 error + if returnFunc, ok := ret.Get(0).(func(...int) error); ok { + r0 = returnFunc(ints...) + } else { + r0 = ret.Error(0) + } + return r0 +} + + + +// MockExpecterAndRolledVariadic_Variadic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Variadic' +type MockExpecterAndRolledVariadic_Variadic_Call struct { + *mock.Call +} + + + +// Variadic is a helper method to define mock.On call +// - ints +func (_e *MockExpecterAndRolledVariadic_Expecter) Variadic(ints ...interface{}, ) *MockExpecterAndRolledVariadic_Variadic_Call { + return &MockExpecterAndRolledVariadic_Variadic_Call{Call: _e.mock.On("Variadic", + append([]interface{}{ }, ints... )... )} +} + +func (_c *MockExpecterAndRolledVariadic_Variadic_Call) Run(run func(ints ...int)) *MockExpecterAndRolledVariadic_Variadic_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]int, len(args) - 0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(int) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *MockExpecterAndRolledVariadic_Variadic_Call) Return(err error) *MockExpecterAndRolledVariadic_Variadic_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockExpecterAndRolledVariadic_Variadic_Call) RunAndReturn(run func(ints ...int)error) *MockExpecterAndRolledVariadic_Variadic_Call { + _c.Call.Return(run) + return _c +} + + +// VariadicMany provides a mock function for the type MockExpecterAndRolledVariadic +func (_mock *MockExpecterAndRolledVariadic) VariadicMany(i int, a string, intfs ...interface{}) error { + var tmpRet mock.Arguments + if len(intfs) > 0 {tmpRet = _mock.Called(i, a, intfs) + } else {tmpRet = _mock.Called(i, a) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for VariadicMany") + } + + + var r0 error + if returnFunc, ok := ret.Get(0).(func(int, string, ...interface{}) error); ok { + r0 = returnFunc(i, a, intfs...) + } else { + r0 = ret.Error(0) + } + return r0 +} + + + +// MockExpecterAndRolledVariadic_VariadicMany_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicMany' +type MockExpecterAndRolledVariadic_VariadicMany_Call struct { + *mock.Call +} + + + +// VariadicMany is a helper method to define mock.On call +// - i +// - a +// - intfs +func (_e *MockExpecterAndRolledVariadic_Expecter) VariadicMany(i interface{}, a interface{}, intfs ...interface{}, ) *MockExpecterAndRolledVariadic_VariadicMany_Call { + return &MockExpecterAndRolledVariadic_VariadicMany_Call{Call: _e.mock.On("VariadicMany", + append([]interface{}{ i, a, }, intfs... )... )} +} + +func (_c *MockExpecterAndRolledVariadic_VariadicMany_Call) Run(run func(i int, a string, intfs ...interface{})) *MockExpecterAndRolledVariadic_VariadicMany_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args) - 2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(int),args[1].(string),variadicArgs...) + }) + return _c +} + +func (_c *MockExpecterAndRolledVariadic_VariadicMany_Call) Return(err error) *MockExpecterAndRolledVariadic_VariadicMany_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockExpecterAndRolledVariadic_VariadicMany_Call) RunAndReturn(run func(i int, a string, intfs ...interface{})error) *MockExpecterAndRolledVariadic_VariadicMany_Call { + _c.Call.Return(run) + return _c +} + +// NewMockExpecter creates a new instance of MockExpecter. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockExpecter (t interface { + mock.TestingT + Cleanup(func()) +}) *MockExpecter { + mock := &MockExpecter{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockExpecter is an autogenerated mock type for the Expecter type +type MockExpecter struct { + mock.Mock +} + +type MockExpecter_Expecter struct { + mock *mock.Mock +} + +func (_m *MockExpecter) EXPECT() *MockExpecter_Expecter { + return &MockExpecter_Expecter{mock: &_m.Mock} +} + + + +// ManyArgsReturns provides a mock function for the type MockExpecter +func (_mock *MockExpecter) ManyArgsReturns(str string, i int) ([]string, error) { + ret := _mock.Called(str, i) + + if len(ret) == 0 { + panic("no return value specified for ManyArgsReturns") + } + + + var r0 []string + var r1 error + if returnFunc, ok := ret.Get(0).(func(string, int) ([]string, error)); ok { + return returnFunc(str, i) + } + if returnFunc, ok := ret.Get(0).(func(string, int) []string); ok { + r0 = returnFunc(str, i) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + if returnFunc, ok := ret.Get(1).(func(string, int) error); ok { + r1 = returnFunc(str, i) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockExpecter_ManyArgsReturns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManyArgsReturns' +type MockExpecter_ManyArgsReturns_Call struct { + *mock.Call +} + + + +// ManyArgsReturns is a helper method to define mock.On call +// - str +// - i +func (_e *MockExpecter_Expecter) ManyArgsReturns(str interface{}, i interface{}, ) *MockExpecter_ManyArgsReturns_Call { + return &MockExpecter_ManyArgsReturns_Call{Call: _e.mock.On("ManyArgsReturns",str,i, )} +} + +func (_c *MockExpecter_ManyArgsReturns_Call) Run(run func(str string, i int)) *MockExpecter_ManyArgsReturns_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),args[1].(int),) + }) + return _c +} + +func (_c *MockExpecter_ManyArgsReturns_Call) Return(strs []string, err error) *MockExpecter_ManyArgsReturns_Call { + _c.Call.Return(strs, err) + return _c +} + +func (_c *MockExpecter_ManyArgsReturns_Call) RunAndReturn(run func(str string, i int)([]string, error)) *MockExpecter_ManyArgsReturns_Call { + _c.Call.Return(run) + return _c +} + + +// NoArg provides a mock function for the type MockExpecter +func (_mock *MockExpecter) NoArg() string { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for NoArg") + } + + + var r0 string + if returnFunc, ok := ret.Get(0).(func() string); ok { + r0 = returnFunc() + } else { + r0 = ret.Get(0).(string) + } + return r0 +} + + + +// MockExpecter_NoArg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoArg' +type MockExpecter_NoArg_Call struct { + *mock.Call +} + + + +// NoArg is a helper method to define mock.On call +func (_e *MockExpecter_Expecter) NoArg() *MockExpecter_NoArg_Call { + return &MockExpecter_NoArg_Call{Call: _e.mock.On("NoArg", )} +} + +func (_c *MockExpecter_NoArg_Call) Run(run func()) *MockExpecter_NoArg_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockExpecter_NoArg_Call) Return(s string) *MockExpecter_NoArg_Call { + _c.Call.Return(s) + return _c +} + +func (_c *MockExpecter_NoArg_Call) RunAndReturn(run func()string) *MockExpecter_NoArg_Call { + _c.Call.Return(run) + return _c +} + + +// NoReturn provides a mock function for the type MockExpecter +func (_mock *MockExpecter) NoReturn(str string) { _mock.Called(str) + return +} + + + +// MockExpecter_NoReturn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoReturn' +type MockExpecter_NoReturn_Call struct { + *mock.Call +} + + + +// NoReturn is a helper method to define mock.On call +// - str +func (_e *MockExpecter_Expecter) NoReturn(str interface{}, ) *MockExpecter_NoReturn_Call { + return &MockExpecter_NoReturn_Call{Call: _e.mock.On("NoReturn",str, )} +} + +func (_c *MockExpecter_NoReturn_Call) Run(run func(str string)) *MockExpecter_NoReturn_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockExpecter_NoReturn_Call) Return() *MockExpecter_NoReturn_Call { + _c.Call.Return() + return _c +} + +func (_c *MockExpecter_NoReturn_Call) RunAndReturn(run func(str string)) *MockExpecter_NoReturn_Call { + _c.Run(run) + return _c +} + + +// Variadic provides a mock function for the type MockExpecter +func (_mock *MockExpecter) Variadic(ints ...int) error { + // int + _va := make([]interface{}, len(ints)) + for _i := range ints { + _va[_i] = ints[_i] + } + var _ca []interface{} + _ca = append(_ca, _va...) + ret := _mock.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Variadic") + } + + + var r0 error + if returnFunc, ok := ret.Get(0).(func(...int) error); ok { + r0 = returnFunc(ints...) + } else { + r0 = ret.Error(0) + } + return r0 +} + + + +// MockExpecter_Variadic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Variadic' +type MockExpecter_Variadic_Call struct { + *mock.Call +} + + + +// Variadic is a helper method to define mock.On call +// - ints +func (_e *MockExpecter_Expecter) Variadic(ints ...interface{}, ) *MockExpecter_Variadic_Call { + return &MockExpecter_Variadic_Call{Call: _e.mock.On("Variadic", + append([]interface{}{ }, ints... )... )} +} + +func (_c *MockExpecter_Variadic_Call) Run(run func(ints ...int)) *MockExpecter_Variadic_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]int, len(args) - 0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(int) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *MockExpecter_Variadic_Call) Return(err error) *MockExpecter_Variadic_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockExpecter_Variadic_Call) RunAndReturn(run func(ints ...int)error) *MockExpecter_Variadic_Call { + _c.Call.Return(run) + return _c +} + + +// VariadicMany provides a mock function for the type MockExpecter +func (_mock *MockExpecter) VariadicMany(i int, a string, intfs ...interface{}) error { + var _ca []interface{} + _ca = append(_ca, i, a) + _ca = append(_ca, intfs...) + ret := _mock.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for VariadicMany") + } + + + var r0 error + if returnFunc, ok := ret.Get(0).(func(int, string, ...interface{}) error); ok { + r0 = returnFunc(i, a, intfs...) + } else { + r0 = ret.Error(0) + } + return r0 +} + + + +// MockExpecter_VariadicMany_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicMany' +type MockExpecter_VariadicMany_Call struct { + *mock.Call +} + + + +// VariadicMany is a helper method to define mock.On call +// - i +// - a +// - intfs +func (_e *MockExpecter_Expecter) VariadicMany(i interface{}, a interface{}, intfs ...interface{}, ) *MockExpecter_VariadicMany_Call { + return &MockExpecter_VariadicMany_Call{Call: _e.mock.On("VariadicMany", + append([]interface{}{ i, a, }, intfs... )... )} +} + +func (_c *MockExpecter_VariadicMany_Call) Run(run func(i int, a string, intfs ...interface{})) *MockExpecter_VariadicMany_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args) - 2) + for i, a := range args[2:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(int),args[1].(string),variadicArgs...) + }) + return _c +} + +func (_c *MockExpecter_VariadicMany_Call) Return(err error) *MockExpecter_VariadicMany_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockExpecter_VariadicMany_Call) RunAndReturn(run func(i int, a string, intfs ...interface{})error) *MockExpecter_VariadicMany_Call { + _c.Call.Return(run) + return _c +} + +// NewMockVariadicNoReturnInterface creates a new instance of MockVariadicNoReturnInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockVariadicNoReturnInterface (t interface { + mock.TestingT + Cleanup(func()) +}) *MockVariadicNoReturnInterface { + mock := &MockVariadicNoReturnInterface{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockVariadicNoReturnInterface is an autogenerated mock type for the VariadicNoReturnInterface type +type MockVariadicNoReturnInterface struct { + mock.Mock +} + +type MockVariadicNoReturnInterface_Expecter struct { + mock *mock.Mock +} + +func (_m *MockVariadicNoReturnInterface) EXPECT() *MockVariadicNoReturnInterface_Expecter { + return &MockVariadicNoReturnInterface_Expecter{mock: &_m.Mock} +} + + + +// VariadicNoReturn provides a mock function for the type MockVariadicNoReturnInterface +func (_mock *MockVariadicNoReturnInterface) VariadicNoReturn(j int, is ...interface{}) { + if len(is) > 0 {_mock.Called(j, is) + } else {_mock.Called(j) + } + return +} + + + +// MockVariadicNoReturnInterface_VariadicNoReturn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicNoReturn' +type MockVariadicNoReturnInterface_VariadicNoReturn_Call struct { + *mock.Call +} + + + +// VariadicNoReturn is a helper method to define mock.On call +// - j +// - is +func (_e *MockVariadicNoReturnInterface_Expecter) VariadicNoReturn(j interface{}, is ...interface{}, ) *MockVariadicNoReturnInterface_VariadicNoReturn_Call { + return &MockVariadicNoReturnInterface_VariadicNoReturn_Call{Call: _e.mock.On("VariadicNoReturn", + append([]interface{}{ j, }, is... )... )} +} + +func (_c *MockVariadicNoReturnInterface_VariadicNoReturn_Call) Run(run func(j int, is ...interface{})) *MockVariadicNoReturnInterface_VariadicNoReturn_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args) - 1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(int),variadicArgs...) + }) + return _c +} + +func (_c *MockVariadicNoReturnInterface_VariadicNoReturn_Call) Return() *MockVariadicNoReturnInterface_VariadicNoReturn_Call { + _c.Call.Return() + return _c +} + +func (_c *MockVariadicNoReturnInterface_VariadicNoReturn_Call) RunAndReturn(run func(j int, is ...interface{})) *MockVariadicNoReturnInterface_VariadicNoReturn_Call { + _c.Run(run) + return _c +} + +// NewMockFuncArgsCollision creates a new instance of MockFuncArgsCollision. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockFuncArgsCollision (t interface { + mock.TestingT + Cleanup(func()) +}) *MockFuncArgsCollision { + mock := &MockFuncArgsCollision{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockFuncArgsCollision is an autogenerated mock type for the FuncArgsCollision type +type MockFuncArgsCollision struct { + mock.Mock +} + +type MockFuncArgsCollision_Expecter struct { + mock *mock.Mock +} + +func (_m *MockFuncArgsCollision) EXPECT() *MockFuncArgsCollision_Expecter { + return &MockFuncArgsCollision_Expecter{mock: &_m.Mock} +} + + + +// Foo provides a mock function for the type MockFuncArgsCollision +func (_mock *MockFuncArgsCollision) Foo(ret interface{}) error { + ret1 := _mock.Called(ret) + + if len(ret1) == 0 { + panic("no return value specified for Foo") + } + + + var r0 error + if returnFunc, ok := ret1.Get(0).(func(interface{}) error); ok { + r0 = returnFunc(ret) + } else { + r0 = ret1.Error(0) + } + return r0 +} + + + +// MockFuncArgsCollision_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo' +type MockFuncArgsCollision_Foo_Call struct { + *mock.Call +} + + + +// Foo is a helper method to define mock.On call +// - ret +func (_e *MockFuncArgsCollision_Expecter) Foo(ret interface{}, ) *MockFuncArgsCollision_Foo_Call { + return &MockFuncArgsCollision_Foo_Call{Call: _e.mock.On("Foo",ret, )} +} + +func (_c *MockFuncArgsCollision_Foo_Call) Run(run func(ret interface{})) *MockFuncArgsCollision_Foo_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(interface{}),) + }) + return _c +} + +func (_c *MockFuncArgsCollision_Foo_Call) Return(err error) *MockFuncArgsCollision_Foo_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockFuncArgsCollision_Foo_Call) RunAndReturn(run func(ret interface{})error) *MockFuncArgsCollision_Foo_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequesterGenerics creates a new instance of MockRequesterGenerics. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterGenerics[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{~int | ~uint}, TInlineTypeGeneric interface{~int | GenericType[int, GetInt]; comparable}] (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + mock := &MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterGenerics is an autogenerated mock type for the RequesterGenerics type +type MockRequesterGenerics[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{~int | ~uint}, TInlineTypeGeneric interface{~int | GenericType[int, GetInt]; comparable}] struct { + mock.Mock +} + +type MockRequesterGenerics_Expecter[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{~int | ~uint}, TInlineTypeGeneric interface{~int | GenericType[int, GetInt]; comparable}] struct { + mock *mock.Mock +} + +func (_m *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) EXPECT() *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + return &MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{mock: &_m.Mock} +} + + + +// GenericAnonymousStructs provides a mock function for the type MockRequesterGenerics +func (_mock *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericAnonymousStructs(val struct{Type1 TExternalIntf}) struct{Type2 GenericType[string, EmbeddedGet[int]]} { + ret := _mock.Called(val) + + if len(ret) == 0 { + panic("no return value specified for GenericAnonymousStructs") + } + + + var r0 struct{Type2 GenericType[string, EmbeddedGet[int]]} + if returnFunc, ok := ret.Get(0).(func(struct{Type1 TExternalIntf}) struct{Type2 GenericType[string, EmbeddedGet[int]]}); ok { + r0 = returnFunc(val) + } else { + r0 = ret.Get(0).(struct{Type2 GenericType[string, EmbeddedGet[int]]}) + } + return r0 +} + + + +// MockRequesterGenerics_GenericAnonymousStructs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericAnonymousStructs' +type MockRequesterGenerics_GenericAnonymousStructs_Call[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{~int | ~uint}, TInlineTypeGeneric interface{~int | GenericType[int, GetInt]; comparable}] struct { + *mock.Call +} + + + +// GenericAnonymousStructs is a helper method to define mock.On call +// - val +func (_e *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericAnonymousStructs(val interface{}, ) *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + return &MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{Call: _e.mock.On("GenericAnonymousStructs",val, )} +} + +func (_c *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run(run func(val struct{Type1 TExternalIntf})) *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(struct{Type1 TExternalIntf}),) + }) + return _c +} + +func (_c *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return(val1 struct{Type2 GenericType[string, EmbeddedGet[int]]}) *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + _c.Call.Return(val1) + return _c +} + +func (_c *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn(run func(val struct{Type1 TExternalIntf})struct{Type2 GenericType[string, EmbeddedGet[int]]}) *MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + _c.Call.Return(run) + return _c +} + + +// GenericArguments provides a mock function for the type MockRequesterGenerics +func (_mock *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericArguments(v TAny, v1 TComparable) (TSigned, TIntf) { + ret := _mock.Called(v, v1) + + if len(ret) == 0 { + panic("no return value specified for GenericArguments") + } + + + var r0 TSigned + var r1 TIntf + if returnFunc, ok := ret.Get(0).(func(TAny, TComparable) (TSigned, TIntf)); ok { + return returnFunc(v, v1) + } + if returnFunc, ok := ret.Get(0).(func(TAny, TComparable) TSigned); ok { + r0 = returnFunc(v, v1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(TSigned) + } + } + if returnFunc, ok := ret.Get(1).(func(TAny, TComparable) TIntf); ok { + r1 = returnFunc(v, v1) + } else { + if ret.Get(1) != nil { + r1 = ret.Get(1).(TIntf) + } + } + return r0, r1 +} + + + +// MockRequesterGenerics_GenericArguments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericArguments' +type MockRequesterGenerics_GenericArguments_Call[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{~int | ~uint}, TInlineTypeGeneric interface{~int | GenericType[int, GetInt]; comparable}] struct { + *mock.Call +} + + + +// GenericArguments is a helper method to define mock.On call +// - v +// - v1 +func (_e *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericArguments(v interface{}, v1 interface{}, ) *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + return &MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{Call: _e.mock.On("GenericArguments",v,v1, )} +} + +func (_c *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run(run func(v TAny, v1 TComparable)) *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(TAny),args[1].(TComparable),) + }) + return _c +} + +func (_c *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return(v2 TSigned, v3 TIntf) *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + _c.Call.Return(v2, v3) + return _c +} + +func (_c *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn(run func(v TAny, v1 TComparable)(TSigned, TIntf)) *MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + _c.Call.Return(run) + return _c +} + + +// GenericStructs provides a mock function for the type MockRequesterGenerics +func (_mock *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericStructs(genericType GenericType[TAny, TIntf]) GenericType[TSigned, TIntf] { + ret := _mock.Called(genericType) + + if len(ret) == 0 { + panic("no return value specified for GenericStructs") + } + + + var r0 GenericType[TSigned, TIntf] + if returnFunc, ok := ret.Get(0).(func(GenericType[TAny, TIntf]) GenericType[TSigned, TIntf]); ok { + r0 = returnFunc(genericType) + } else { + r0 = ret.Get(0).(GenericType[TSigned, TIntf]) + } + return r0 +} + + + +// MockRequesterGenerics_GenericStructs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericStructs' +type MockRequesterGenerics_GenericStructs_Call[TAny any, TComparable comparable, TSigned constraints.Signed, TIntf GetInt, TExternalIntf io.Writer, TGenIntf GetGeneric[TSigned], TInlineType interface{~int | ~uint}, TInlineTypeGeneric interface{~int | GenericType[int, GetInt]; comparable}] struct { + *mock.Call +} + + + +// GenericStructs is a helper method to define mock.On call +// - genericType +func (_e *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericStructs(genericType interface{}, ) *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + return &MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]{Call: _e.mock.On("GenericStructs",genericType, )} +} + +func (_c *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run(run func(genericType GenericType[TAny, TIntf])) *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(GenericType[TAny, TIntf]),) + }) + return _c +} + +func (_c *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return(genericType1 GenericType[TSigned, TIntf]) *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + _c.Call.Return(genericType1) + return _c +} + +func (_c *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn(run func(genericType GenericType[TAny, TIntf])GenericType[TSigned, TIntf]) *MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric] { + _c.Call.Return(run) + return _c +} + +// NewMockGetInt creates a new instance of MockGetInt. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockGetInt (t interface { + mock.TestingT + Cleanup(func()) +}) *MockGetInt { + mock := &MockGetInt{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockGetInt is an autogenerated mock type for the GetInt type +type MockGetInt struct { + mock.Mock +} + +type MockGetInt_Expecter struct { + mock *mock.Mock +} + +func (_m *MockGetInt) EXPECT() *MockGetInt_Expecter { + return &MockGetInt_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockGetInt +func (_mock *MockGetInt) Get() int { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 int + if returnFunc, ok := ret.Get(0).(func() int); ok { + r0 = returnFunc() + } else { + r0 = ret.Get(0).(int) + } + return r0 +} + + + +// MockGetInt_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockGetInt_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +func (_e *MockGetInt_Expecter) Get() *MockGetInt_Get_Call { + return &MockGetInt_Get_Call{Call: _e.mock.On("Get", )} +} + +func (_c *MockGetInt_Get_Call) Run(run func()) *MockGetInt_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockGetInt_Get_Call) Return(n int) *MockGetInt_Get_Call { + _c.Call.Return(n) + return _c +} + +func (_c *MockGetInt_Get_Call) RunAndReturn(run func()int) *MockGetInt_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockGetGeneric creates a new instance of MockGetGeneric. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockGetGeneric[T constraints.Integer] (t interface { + mock.TestingT + Cleanup(func()) +}) *MockGetGeneric[T] { + mock := &MockGetGeneric[T]{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockGetGeneric is an autogenerated mock type for the GetGeneric type +type MockGetGeneric[T constraints.Integer] struct { + mock.Mock +} + +type MockGetGeneric_Expecter[T constraints.Integer] struct { + mock *mock.Mock +} + +func (_m *MockGetGeneric[T]) EXPECT() *MockGetGeneric_Expecter[T] { + return &MockGetGeneric_Expecter[T]{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockGetGeneric +func (_mock *MockGetGeneric[T]) Get() T { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 T + if returnFunc, ok := ret.Get(0).(func() T); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(T) + } + } + return r0 +} + + + +// MockGetGeneric_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockGetGeneric_Get_Call[T constraints.Integer] struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +func (_e *MockGetGeneric_Expecter[T]) Get() *MockGetGeneric_Get_Call[T] { + return &MockGetGeneric_Get_Call[T]{Call: _e.mock.On("Get", )} +} + +func (_c *MockGetGeneric_Get_Call[T]) Run(run func()) *MockGetGeneric_Get_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockGetGeneric_Get_Call[T]) Return(v T) *MockGetGeneric_Get_Call[T] { + _c.Call.Return(v) + return _c +} + +func (_c *MockGetGeneric_Get_Call[T]) RunAndReturn(run func()T) *MockGetGeneric_Get_Call[T] { + _c.Call.Return(run) + return _c +} + +// NewMockEmbeddedGet creates a new instance of MockEmbeddedGet. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockEmbeddedGet[T constraints.Signed] (t interface { + mock.TestingT + Cleanup(func()) +}) *MockEmbeddedGet[T] { + mock := &MockEmbeddedGet[T]{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockEmbeddedGet is an autogenerated mock type for the EmbeddedGet type +type MockEmbeddedGet[T constraints.Signed] struct { + mock.Mock +} + +type MockEmbeddedGet_Expecter[T constraints.Signed] struct { + mock *mock.Mock +} + +func (_m *MockEmbeddedGet[T]) EXPECT() *MockEmbeddedGet_Expecter[T] { + return &MockEmbeddedGet_Expecter[T]{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockEmbeddedGet +func (_mock *MockEmbeddedGet[T]) Get() T { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 T + if returnFunc, ok := ret.Get(0).(func() T); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(T) + } + } + return r0 +} + + + +// MockEmbeddedGet_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockEmbeddedGet_Get_Call[T constraints.Signed] struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +func (_e *MockEmbeddedGet_Expecter[T]) Get() *MockEmbeddedGet_Get_Call[T] { + return &MockEmbeddedGet_Get_Call[T]{Call: _e.mock.On("Get", )} +} + +func (_c *MockEmbeddedGet_Get_Call[T]) Run(run func()) *MockEmbeddedGet_Get_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockEmbeddedGet_Get_Call[T]) Return(v T) *MockEmbeddedGet_Get_Call[T] { + _c.Call.Return(v) + return _c +} + +func (_c *MockEmbeddedGet_Get_Call[T]) RunAndReturn(run func()T) *MockEmbeddedGet_Get_Call[T] { + _c.Call.Return(run) + return _c +} + +// NewMockReplaceGeneric creates a new instance of MockReplaceGeneric. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockReplaceGeneric[TImport any, TConstraint constraints.Signed, TKeep any] (t interface { + mock.TestingT + Cleanup(func()) +}) *MockReplaceGeneric[TImport, TConstraint, TKeep] { + mock := &MockReplaceGeneric[TImport, TConstraint, TKeep]{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockReplaceGeneric is an autogenerated mock type for the ReplaceGeneric type +type MockReplaceGeneric[TImport any, TConstraint constraints.Signed, TKeep any] struct { + mock.Mock +} + +type MockReplaceGeneric_Expecter[TImport any, TConstraint constraints.Signed, TKeep any] struct { + mock *mock.Mock +} + +func (_m *MockReplaceGeneric[TImport, TConstraint, TKeep]) EXPECT() *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep] { + return &MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]{mock: &_m.Mock} +} + + + +// A provides a mock function for the type MockReplaceGeneric +func (_mock *MockReplaceGeneric[TImport, TConstraint, TKeep]) A(t1 TImport) TKeep { + ret := _mock.Called(t1) + + if len(ret) == 0 { + panic("no return value specified for A") + } + + + var r0 TKeep + if returnFunc, ok := ret.Get(0).(func(TImport) TKeep); ok { + r0 = returnFunc(t1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(TKeep) + } + } + return r0 +} + + + +// MockReplaceGeneric_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A' +type MockReplaceGeneric_A_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct { + *mock.Call +} + + + +// A is a helper method to define mock.On call +// - t1 +func (_e *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) A(t1 interface{}, ) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep] { + return &MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]{Call: _e.mock.On("A",t1, )} +} + +func (_c *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) Run(run func(t1 TImport)) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(TImport),) + }) + return _c +} + +func (_c *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) Return(v TKeep) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep] { + _c.Call.Return(v) + return _c +} + +func (_c *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func(t1 TImport)TKeep) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep] { + _c.Call.Return(run) + return _c +} + + +// B provides a mock function for the type MockReplaceGeneric +func (_mock *MockReplaceGeneric[TImport, TConstraint, TKeep]) B() TImport { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for B") + } + + + var r0 TImport + if returnFunc, ok := ret.Get(0).(func() TImport); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(TImport) + } + } + return r0 +} + + + +// MockReplaceGeneric_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B' +type MockReplaceGeneric_B_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct { + *mock.Call +} + + + +// B is a helper method to define mock.On call +func (_e *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) B() *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep] { + return &MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]{Call: _e.mock.On("B", )} +} + +func (_c *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) Run(run func()) *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) Return(v TImport) *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep] { + _c.Call.Return(v) + return _c +} + +func (_c *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func()TImport) *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep] { + _c.Call.Return(run) + return _c +} + + +// C provides a mock function for the type MockReplaceGeneric +func (_mock *MockReplaceGeneric[TImport, TConstraint, TKeep]) C() TConstraint { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for C") + } + + + var r0 TConstraint + if returnFunc, ok := ret.Get(0).(func() TConstraint); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(TConstraint) + } + } + return r0 +} + + + +// MockReplaceGeneric_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C' +type MockReplaceGeneric_C_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct { + *mock.Call +} + + + +// C is a helper method to define mock.On call +func (_e *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) C() *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep] { + return &MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]{Call: _e.mock.On("C", )} +} + +func (_c *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) Run(run func()) *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) Return(v TConstraint) *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep] { + _c.Call.Return(v) + return _c +} + +func (_c *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func()TConstraint) *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep] { + _c.Call.Return(run) + return _c +} + +// NewMockReplaceGenericSelf creates a new instance of MockReplaceGenericSelf. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockReplaceGenericSelf[T any] (t interface { + mock.TestingT + Cleanup(func()) +}) *MockReplaceGenericSelf[T] { + mock := &MockReplaceGenericSelf[T]{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockReplaceGenericSelf is an autogenerated mock type for the ReplaceGenericSelf type +type MockReplaceGenericSelf[T any] struct { + mock.Mock +} + +type MockReplaceGenericSelf_Expecter[T any] struct { + mock *mock.Mock +} + +func (_m *MockReplaceGenericSelf[T]) EXPECT() *MockReplaceGenericSelf_Expecter[T] { + return &MockReplaceGenericSelf_Expecter[T]{mock: &_m.Mock} +} + + + +// A provides a mock function for the type MockReplaceGenericSelf +func (_mock *MockReplaceGenericSelf[T]) A() T { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for A") + } + + + var r0 T + if returnFunc, ok := ret.Get(0).(func() T); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(T) + } + } + return r0 +} + + + +// MockReplaceGenericSelf_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A' +type MockReplaceGenericSelf_A_Call[T any] struct { + *mock.Call +} + + + +// A is a helper method to define mock.On call +func (_e *MockReplaceGenericSelf_Expecter[T]) A() *MockReplaceGenericSelf_A_Call[T] { + return &MockReplaceGenericSelf_A_Call[T]{Call: _e.mock.On("A", )} +} + +func (_c *MockReplaceGenericSelf_A_Call[T]) Run(run func()) *MockReplaceGenericSelf_A_Call[T] { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockReplaceGenericSelf_A_Call[T]) Return(v T) *MockReplaceGenericSelf_A_Call[T] { + _c.Call.Return(v) + return _c +} + +func (_c *MockReplaceGenericSelf_A_Call[T]) RunAndReturn(run func()T) *MockReplaceGenericSelf_A_Call[T] { + _c.Call.Return(run) + return _c +} + +// NewMockHasConflictingNestedImports creates a new instance of MockHasConflictingNestedImports. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockHasConflictingNestedImports (t interface { + mock.TestingT + Cleanup(func()) +}) *MockHasConflictingNestedImports { + mock := &MockHasConflictingNestedImports{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockHasConflictingNestedImports is an autogenerated mock type for the HasConflictingNestedImports type +type MockHasConflictingNestedImports struct { + mock.Mock +} + +type MockHasConflictingNestedImports_Expecter struct { + mock *mock.Mock +} + +func (_m *MockHasConflictingNestedImports) EXPECT() *MockHasConflictingNestedImports_Expecter { + return &MockHasConflictingNestedImports_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockHasConflictingNestedImports +func (_mock *MockHasConflictingNestedImports) Get(path string) (http.Response, error) { + ret := _mock.Called(path) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 http.Response + var r1 error + if returnFunc, ok := ret.Get(0).(func(string) (http.Response, error)); ok { + return returnFunc(path) + } + if returnFunc, ok := ret.Get(0).(func(string) http.Response); ok { + r0 = returnFunc(path) + } else { + r0 = ret.Get(0).(http.Response) + } + if returnFunc, ok := ret.Get(1).(func(string) error); ok { + r1 = returnFunc(path) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockHasConflictingNestedImports_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockHasConflictingNestedImports_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - path +func (_e *MockHasConflictingNestedImports_Expecter) Get(path interface{}, ) *MockHasConflictingNestedImports_Get_Call { + return &MockHasConflictingNestedImports_Get_Call{Call: _e.mock.On("Get",path, )} +} + +func (_c *MockHasConflictingNestedImports_Get_Call) Run(run func(path string)) *MockHasConflictingNestedImports_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockHasConflictingNestedImports_Get_Call) Return(response http.Response, err error) *MockHasConflictingNestedImports_Get_Call { + _c.Call.Return(response, err) + return _c +} + +func (_c *MockHasConflictingNestedImports_Get_Call) RunAndReturn(run func(path string)(http.Response, error)) *MockHasConflictingNestedImports_Get_Call { + _c.Call.Return(run) + return _c +} + + +// Z provides a mock function for the type MockHasConflictingNestedImports +func (_mock *MockHasConflictingNestedImports) Z() http0.MyStruct { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Z") + } + + + var r0 http0.MyStruct + if returnFunc, ok := ret.Get(0).(func() http0.MyStruct); ok { + r0 = returnFunc() + } else { + r0 = ret.Get(0).(http0.MyStruct) + } + return r0 +} + + + +// MockHasConflictingNestedImports_Z_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Z' +type MockHasConflictingNestedImports_Z_Call struct { + *mock.Call +} + + + +// Z is a helper method to define mock.On call +func (_e *MockHasConflictingNestedImports_Expecter) Z() *MockHasConflictingNestedImports_Z_Call { + return &MockHasConflictingNestedImports_Z_Call{Call: _e.mock.On("Z", )} +} + +func (_c *MockHasConflictingNestedImports_Z_Call) Run(run func()) *MockHasConflictingNestedImports_Z_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockHasConflictingNestedImports_Z_Call) Return(myStruct http0.MyStruct) *MockHasConflictingNestedImports_Z_Call { + _c.Call.Return(myStruct) + return _c +} + +func (_c *MockHasConflictingNestedImports_Z_Call) RunAndReturn(run func()http0.MyStruct) *MockHasConflictingNestedImports_Z_Call { + _c.Call.Return(run) + return _c +} + +// NewMockImportsSameAsPackage creates a new instance of MockImportsSameAsPackage. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockImportsSameAsPackage (t interface { + mock.TestingT + Cleanup(func()) +}) *MockImportsSameAsPackage { + mock := &MockImportsSameAsPackage{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockImportsSameAsPackage is an autogenerated mock type for the ImportsSameAsPackage type +type MockImportsSameAsPackage struct { + mock.Mock +} + +type MockImportsSameAsPackage_Expecter struct { + mock *mock.Mock +} + +func (_m *MockImportsSameAsPackage) EXPECT() *MockImportsSameAsPackage_Expecter { + return &MockImportsSameAsPackage_Expecter{mock: &_m.Mock} +} + + + +// A provides a mock function for the type MockImportsSameAsPackage +func (_mock *MockImportsSameAsPackage) A() test.B { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for A") + } + + + var r0 test.B + if returnFunc, ok := ret.Get(0).(func() test.B); ok { + r0 = returnFunc() + } else { + r0 = ret.Get(0).(test.B) + } + return r0 +} + + + +// MockImportsSameAsPackage_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A' +type MockImportsSameAsPackage_A_Call struct { + *mock.Call +} + + + +// A is a helper method to define mock.On call +func (_e *MockImportsSameAsPackage_Expecter) A() *MockImportsSameAsPackage_A_Call { + return &MockImportsSameAsPackage_A_Call{Call: _e.mock.On("A", )} +} + +func (_c *MockImportsSameAsPackage_A_Call) Run(run func()) *MockImportsSameAsPackage_A_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockImportsSameAsPackage_A_Call) Return(b test.B) *MockImportsSameAsPackage_A_Call { + _c.Call.Return(b) + return _c +} + +func (_c *MockImportsSameAsPackage_A_Call) RunAndReturn(run func()test.B) *MockImportsSameAsPackage_A_Call { + _c.Call.Return(run) + return _c +} + + +// B provides a mock function for the type MockImportsSameAsPackage +func (_mock *MockImportsSameAsPackage) B() KeyManager { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for B") + } + + + var r0 KeyManager + if returnFunc, ok := ret.Get(0).(func() KeyManager); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(KeyManager) + } + } + return r0 +} + + + +// MockImportsSameAsPackage_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B' +type MockImportsSameAsPackage_B_Call struct { + *mock.Call +} + + + +// B is a helper method to define mock.On call +func (_e *MockImportsSameAsPackage_Expecter) B() *MockImportsSameAsPackage_B_Call { + return &MockImportsSameAsPackage_B_Call{Call: _e.mock.On("B", )} +} + +func (_c *MockImportsSameAsPackage_B_Call) Run(run func()) *MockImportsSameAsPackage_B_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockImportsSameAsPackage_B_Call) Return(keyManager KeyManager) *MockImportsSameAsPackage_B_Call { + _c.Call.Return(keyManager) + return _c +} + +func (_c *MockImportsSameAsPackage_B_Call) RunAndReturn(run func()KeyManager) *MockImportsSameAsPackage_B_Call { + _c.Call.Return(run) + return _c +} + + +// C provides a mock function for the type MockImportsSameAsPackage +func (_mock *MockImportsSameAsPackage) C(c C) { _mock.Called(c) + return +} + + + +// MockImportsSameAsPackage_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C' +type MockImportsSameAsPackage_C_Call struct { + *mock.Call +} + + + +// C is a helper method to define mock.On call +// - c +func (_e *MockImportsSameAsPackage_Expecter) C(c interface{}, ) *MockImportsSameAsPackage_C_Call { + return &MockImportsSameAsPackage_C_Call{Call: _e.mock.On("C",c, )} +} + +func (_c *MockImportsSameAsPackage_C_Call) Run(run func(c C)) *MockImportsSameAsPackage_C_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(C),) + }) + return _c +} + +func (_c *MockImportsSameAsPackage_C_Call) Return() *MockImportsSameAsPackage_C_Call { + _c.Call.Return() + return _c +} + +func (_c *MockImportsSameAsPackage_C_Call) RunAndReturn(run func(c C)) *MockImportsSameAsPackage_C_Call { + _c.Run(run) + return _c +} + +// NewMockGenericInterface creates a new instance of MockGenericInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockGenericInterface[M any] (t interface { + mock.TestingT + Cleanup(func()) +}) *MockGenericInterface[M] { + mock := &MockGenericInterface[M]{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockGenericInterface is an autogenerated mock type for the GenericInterface type +type MockGenericInterface[M any] struct { + mock.Mock +} + +type MockGenericInterface_Expecter[M any] struct { + mock *mock.Mock +} + +func (_m *MockGenericInterface[M]) EXPECT() *MockGenericInterface_Expecter[M] { + return &MockGenericInterface_Expecter[M]{mock: &_m.Mock} +} + + + +// Func provides a mock function for the type MockGenericInterface +func (_mock *MockGenericInterface[M]) Func(arg *M) int { + ret := _mock.Called(arg) + + if len(ret) == 0 { + panic("no return value specified for Func") + } + + + var r0 int + if returnFunc, ok := ret.Get(0).(func(*M) int); ok { + r0 = returnFunc(arg) + } else { + r0 = ret.Get(0).(int) + } + return r0 +} + + + +// MockGenericInterface_Func_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Func' +type MockGenericInterface_Func_Call[M any] struct { + *mock.Call +} + + + +// Func is a helper method to define mock.On call +// - arg +func (_e *MockGenericInterface_Expecter[M]) Func(arg interface{}, ) *MockGenericInterface_Func_Call[M] { + return &MockGenericInterface_Func_Call[M]{Call: _e.mock.On("Func",arg, )} +} + +func (_c *MockGenericInterface_Func_Call[M]) Run(run func(arg *M)) *MockGenericInterface_Func_Call[M] { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*M),) + }) + return _c +} + +func (_c *MockGenericInterface_Func_Call[M]) Return(n int) *MockGenericInterface_Func_Call[M] { + _c.Call.Return(n) + return _c +} + +func (_c *MockGenericInterface_Func_Call[M]) RunAndReturn(run func(arg *M)int) *MockGenericInterface_Func_Call[M] { + _c.Call.Return(run) + return _c +} + +// NewMockInstantiatedGenericInterface creates a new instance of MockInstantiatedGenericInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockInstantiatedGenericInterface (t interface { + mock.TestingT + Cleanup(func()) +}) *MockInstantiatedGenericInterface { + mock := &MockInstantiatedGenericInterface{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockInstantiatedGenericInterface is an autogenerated mock type for the InstantiatedGenericInterface type +type MockInstantiatedGenericInterface struct { + mock.Mock +} + +type MockInstantiatedGenericInterface_Expecter struct { + mock *mock.Mock +} + +func (_m *MockInstantiatedGenericInterface) EXPECT() *MockInstantiatedGenericInterface_Expecter { + return &MockInstantiatedGenericInterface_Expecter{mock: &_m.Mock} +} + + + +// Func provides a mock function for the type MockInstantiatedGenericInterface +func (_mock *MockInstantiatedGenericInterface) Func(arg *float32) int { + ret := _mock.Called(arg) + + if len(ret) == 0 { + panic("no return value specified for Func") + } + + + var r0 int + if returnFunc, ok := ret.Get(0).(func(*float32) int); ok { + r0 = returnFunc(arg) + } else { + r0 = ret.Get(0).(int) + } + return r0 +} + + + +// MockInstantiatedGenericInterface_Func_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Func' +type MockInstantiatedGenericInterface_Func_Call struct { + *mock.Call +} + + + +// Func is a helper method to define mock.On call +// - arg +func (_e *MockInstantiatedGenericInterface_Expecter) Func(arg interface{}, ) *MockInstantiatedGenericInterface_Func_Call { + return &MockInstantiatedGenericInterface_Func_Call{Call: _e.mock.On("Func",arg, )} +} + +func (_c *MockInstantiatedGenericInterface_Func_Call) Run(run func(arg *float32)) *MockInstantiatedGenericInterface_Func_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*float32),) + }) + return _c +} + +func (_c *MockInstantiatedGenericInterface_Func_Call) Return(n int) *MockInstantiatedGenericInterface_Func_Call { + _c.Call.Return(n) + return _c +} + +func (_c *MockInstantiatedGenericInterface_Func_Call) RunAndReturn(run func(arg *float32)int) *MockInstantiatedGenericInterface_Func_Call { + _c.Call.Return(run) + return _c +} + +// NewMockMyReader creates a new instance of MockMyReader. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockMyReader (t interface { + mock.TestingT + Cleanup(func()) +}) *MockMyReader { + mock := &MockMyReader{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockMyReader is an autogenerated mock type for the MyReader type +type MockMyReader struct { + mock.Mock +} + +type MockMyReader_Expecter struct { + mock *mock.Mock +} + +func (_m *MockMyReader) EXPECT() *MockMyReader_Expecter { + return &MockMyReader_Expecter{mock: &_m.Mock} +} + + + +// Read provides a mock function for the type MockMyReader +func (_mock *MockMyReader) Read(p []byte) (int, error) { + ret := _mock.Called(p) + + if len(ret) == 0 { + panic("no return value specified for Read") + } + + + var r0 int + var r1 error + if returnFunc, ok := ret.Get(0).(func([]byte) (int, error)); ok { + return returnFunc(p) + } + if returnFunc, ok := ret.Get(0).(func([]byte) int); ok { + r0 = returnFunc(p) + } else { + r0 = ret.Get(0).(int) + } + if returnFunc, ok := ret.Get(1).(func([]byte) error); ok { + r1 = returnFunc(p) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockMyReader_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read' +type MockMyReader_Read_Call struct { + *mock.Call +} + + + +// Read is a helper method to define mock.On call +// - p +func (_e *MockMyReader_Expecter) Read(p interface{}, ) *MockMyReader_Read_Call { + return &MockMyReader_Read_Call{Call: _e.mock.On("Read",p, )} +} + +func (_c *MockMyReader_Read_Call) Run(run func(p []byte)) *MockMyReader_Read_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].([]byte),) + }) + return _c +} + +func (_c *MockMyReader_Read_Call) Return(n int, err error) *MockMyReader_Read_Call { + _c.Call.Return(n, err) + return _c +} + +func (_c *MockMyReader_Read_Call) RunAndReturn(run func(p []byte)(int, error)) *MockMyReader_Read_Call { + _c.Call.Return(run) + return _c +} + +// NewMockIssue766 creates a new instance of MockIssue766. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockIssue766 (t interface { + mock.TestingT + Cleanup(func()) +}) *MockIssue766 { + mock := &MockIssue766{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockIssue766 is an autogenerated mock type for the Issue766 type +type MockIssue766 struct { + mock.Mock +} + +type MockIssue766_Expecter struct { + mock *mock.Mock +} + +func (_m *MockIssue766) EXPECT() *MockIssue766_Expecter { + return &MockIssue766_Expecter{mock: &_m.Mock} +} + + + +// FetchData provides a mock function for the type MockIssue766 +func (_mock *MockIssue766) FetchData(fetchFunc func(x ...int) ([]int, error)) ([]int, error) { + ret := _mock.Called(fetchFunc) + + if len(ret) == 0 { + panic("no return value specified for FetchData") + } + + + var r0 []int + var r1 error + if returnFunc, ok := ret.Get(0).(func(func(x ...int) ([]int, error)) ([]int, error)); ok { + return returnFunc(fetchFunc) + } + if returnFunc, ok := ret.Get(0).(func(func(x ...int) ([]int, error)) []int); ok { + r0 = returnFunc(fetchFunc) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]int) + } + } + if returnFunc, ok := ret.Get(1).(func(func(x ...int) ([]int, error)) error); ok { + r1 = returnFunc(fetchFunc) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockIssue766_FetchData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FetchData' +type MockIssue766_FetchData_Call struct { + *mock.Call +} + + + +// FetchData is a helper method to define mock.On call +// - fetchFunc +func (_e *MockIssue766_Expecter) FetchData(fetchFunc interface{}, ) *MockIssue766_FetchData_Call { + return &MockIssue766_FetchData_Call{Call: _e.mock.On("FetchData",fetchFunc, )} +} + +func (_c *MockIssue766_FetchData_Call) Run(run func(fetchFunc func(x ...int) ([]int, error))) *MockIssue766_FetchData_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(func(x ...int) ([]int, error)),) + }) + return _c +} + +func (_c *MockIssue766_FetchData_Call) Return(ints []int, err error) *MockIssue766_FetchData_Call { + _c.Call.Return(ints, err) + return _c +} + +func (_c *MockIssue766_FetchData_Call) RunAndReturn(run func(fetchFunc func(x ...int) ([]int, error))([]int, error)) *MockIssue766_FetchData_Call { + _c.Call.Return(run) + return _c +} + +// NewMockMapToInterface creates a new instance of MockMapToInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockMapToInterface (t interface { + mock.TestingT + Cleanup(func()) +}) *MockMapToInterface { + mock := &MockMapToInterface{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockMapToInterface is an autogenerated mock type for the MapToInterface type +type MockMapToInterface struct { + mock.Mock +} + +type MockMapToInterface_Expecter struct { + mock *mock.Mock +} + +func (_m *MockMapToInterface) EXPECT() *MockMapToInterface_Expecter { + return &MockMapToInterface_Expecter{mock: &_m.Mock} +} + + + +// Foo provides a mock function for the type MockMapToInterface +func (_mock *MockMapToInterface) Foo(arg1 ...map[string]interface{}) { + if len(arg1) > 0 {_mock.Called(arg1) + } else {_mock.Called() + } + return +} + + + +// MockMapToInterface_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo' +type MockMapToInterface_Foo_Call struct { + *mock.Call +} + + + +// Foo is a helper method to define mock.On call +// - arg1 +func (_e *MockMapToInterface_Expecter) Foo(arg1 ...interface{}, ) *MockMapToInterface_Foo_Call { + return &MockMapToInterface_Foo_Call{Call: _e.mock.On("Foo", + append([]interface{}{ }, arg1... )... )} +} + +func (_c *MockMapToInterface_Foo_Call) Run(run func(arg1 ...map[string]interface{})) *MockMapToInterface_Foo_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]map[string]interface{}, len(args) - 0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(map[string]interface{}) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *MockMapToInterface_Foo_Call) Return() *MockMapToInterface_Foo_Call { + _c.Call.Return() + return _c +} + +func (_c *MockMapToInterface_Foo_Call) RunAndReturn(run func(arg1 ...map[string]interface{})) *MockMapToInterface_Foo_Call { + _c.Run(run) + return _c +} + +// NewMockSibling creates a new instance of MockSibling. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockSibling (t interface { + mock.TestingT + Cleanup(func()) +}) *MockSibling { + mock := &MockSibling{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockSibling is an autogenerated mock type for the Sibling type +type MockSibling struct { + mock.Mock +} + +type MockSibling_Expecter struct { + mock *mock.Mock +} + +func (_m *MockSibling) EXPECT() *MockSibling_Expecter { + return &MockSibling_Expecter{mock: &_m.Mock} +} + + + +// DoSomething provides a mock function for the type MockSibling +func (_mock *MockSibling) DoSomething() { _mock.Called() + return +} + + + +// MockSibling_DoSomething_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoSomething' +type MockSibling_DoSomething_Call struct { + *mock.Call +} + + + +// DoSomething is a helper method to define mock.On call +func (_e *MockSibling_Expecter) DoSomething() *MockSibling_DoSomething_Call { + return &MockSibling_DoSomething_Call{Call: _e.mock.On("DoSomething", )} +} + +func (_c *MockSibling_DoSomething_Call) Run(run func()) *MockSibling_DoSomething_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSibling_DoSomething_Call) Return() *MockSibling_DoSomething_Call { + _c.Call.Return() + return _c +} + +func (_c *MockSibling_DoSomething_Call) RunAndReturn(run func()) *MockSibling_DoSomething_Call { + _c.Run(run) + return _c +} + +// NewMockUsesOtherPkgIface creates a new instance of MockUsesOtherPkgIface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockUsesOtherPkgIface (t interface { + mock.TestingT + Cleanup(func()) +}) *MockUsesOtherPkgIface { + mock := &MockUsesOtherPkgIface{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockUsesOtherPkgIface is an autogenerated mock type for the UsesOtherPkgIface type +type MockUsesOtherPkgIface struct { + mock.Mock +} + +type MockUsesOtherPkgIface_Expecter struct { + mock *mock.Mock +} + +func (_m *MockUsesOtherPkgIface) EXPECT() *MockUsesOtherPkgIface_Expecter { + return &MockUsesOtherPkgIface_Expecter{mock: &_m.Mock} +} + + + +// DoSomethingElse provides a mock function for the type MockUsesOtherPkgIface +func (_mock *MockUsesOtherPkgIface) DoSomethingElse(obj Sibling) { _mock.Called(obj) + return +} + + + +// MockUsesOtherPkgIface_DoSomethingElse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoSomethingElse' +type MockUsesOtherPkgIface_DoSomethingElse_Call struct { + *mock.Call +} + + + +// DoSomethingElse is a helper method to define mock.On call +// - obj +func (_e *MockUsesOtherPkgIface_Expecter) DoSomethingElse(obj interface{}, ) *MockUsesOtherPkgIface_DoSomethingElse_Call { + return &MockUsesOtherPkgIface_DoSomethingElse_Call{Call: _e.mock.On("DoSomethingElse",obj, )} +} + +func (_c *MockUsesOtherPkgIface_DoSomethingElse_Call) Run(run func(obj Sibling)) *MockUsesOtherPkgIface_DoSomethingElse_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(Sibling),) + }) + return _c +} + +func (_c *MockUsesOtherPkgIface_DoSomethingElse_Call) Return() *MockUsesOtherPkgIface_DoSomethingElse_Call { + _c.Call.Return() + return _c +} + +func (_c *MockUsesOtherPkgIface_DoSomethingElse_Call) RunAndReturn(run func(obj Sibling)) *MockUsesOtherPkgIface_DoSomethingElse_Call { + _c.Run(run) + return _c +} + +// NewMockPanicOnNoReturnValue creates a new instance of MockPanicOnNoReturnValue. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockPanicOnNoReturnValue (t interface { + mock.TestingT + Cleanup(func()) +}) *MockPanicOnNoReturnValue { + mock := &MockPanicOnNoReturnValue{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockPanicOnNoReturnValue is an autogenerated mock type for the PanicOnNoReturnValue type +type MockPanicOnNoReturnValue struct { + mock.Mock +} + +type MockPanicOnNoReturnValue_Expecter struct { + mock *mock.Mock +} + +func (_m *MockPanicOnNoReturnValue) EXPECT() *MockPanicOnNoReturnValue_Expecter { + return &MockPanicOnNoReturnValue_Expecter{mock: &_m.Mock} +} + + + +// DoSomething provides a mock function for the type MockPanicOnNoReturnValue +func (_mock *MockPanicOnNoReturnValue) DoSomething() string { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for DoSomething") + } + + + var r0 string + if returnFunc, ok := ret.Get(0).(func() string); ok { + r0 = returnFunc() + } else { + r0 = ret.Get(0).(string) + } + return r0 +} + + + +// MockPanicOnNoReturnValue_DoSomething_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoSomething' +type MockPanicOnNoReturnValue_DoSomething_Call struct { + *mock.Call +} + + + +// DoSomething is a helper method to define mock.On call +func (_e *MockPanicOnNoReturnValue_Expecter) DoSomething() *MockPanicOnNoReturnValue_DoSomething_Call { + return &MockPanicOnNoReturnValue_DoSomething_Call{Call: _e.mock.On("DoSomething", )} +} + +func (_c *MockPanicOnNoReturnValue_DoSomething_Call) Run(run func()) *MockPanicOnNoReturnValue_DoSomething_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPanicOnNoReturnValue_DoSomething_Call) Return(s string) *MockPanicOnNoReturnValue_DoSomething_Call { + _c.Call.Return(s) + return _c +} + +func (_c *MockPanicOnNoReturnValue_DoSomething_Call) RunAndReturn(run func()string) *MockPanicOnNoReturnValue_DoSomething_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequester creates a new instance of MockRequester. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequester (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequester { + mock := &MockRequester{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequester is an autogenerated mock type for the Requester type +type MockRequester struct { + mock.Mock +} + +type MockRequester_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequester) EXPECT() *MockRequester_Expecter { + return &MockRequester_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequester +func (_mock *MockRequester) Get(path string) (string, error) { + ret := _mock.Called(path) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 string + var r1 error + if returnFunc, ok := ret.Get(0).(func(string) (string, error)); ok { + return returnFunc(path) + } + if returnFunc, ok := ret.Get(0).(func(string) string); ok { + r0 = returnFunc(path) + } else { + r0 = ret.Get(0).(string) + } + if returnFunc, ok := ret.Get(1).(func(string) error); ok { + r1 = returnFunc(path) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockRequester_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequester_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - path +func (_e *MockRequester_Expecter) Get(path interface{}, ) *MockRequester_Get_Call { + return &MockRequester_Get_Call{Call: _e.mock.On("Get",path, )} +} + +func (_c *MockRequester_Get_Call) Run(run func(path string)) *MockRequester_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockRequester_Get_Call) Return(s string, err error) *MockRequester_Get_Call { + _c.Call.Return(s, err) + return _c +} + +func (_c *MockRequester_Get_Call) RunAndReturn(run func(path string)(string, error)) *MockRequester_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequester2 creates a new instance of MockRequester2. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequester2 (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequester2 { + mock := &MockRequester2{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequester2 is an autogenerated mock type for the Requester2 type +type MockRequester2 struct { + mock.Mock +} + +type MockRequester2_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequester2) EXPECT() *MockRequester2_Expecter { + return &MockRequester2_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequester2 +func (_mock *MockRequester2) Get(path string) error { + ret := _mock.Called(path) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 error + if returnFunc, ok := ret.Get(0).(func(string) error); ok { + r0 = returnFunc(path) + } else { + r0 = ret.Error(0) + } + return r0 +} + + + +// MockRequester2_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequester2_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - path +func (_e *MockRequester2_Expecter) Get(path interface{}, ) *MockRequester2_Get_Call { + return &MockRequester2_Get_Call{Call: _e.mock.On("Get",path, )} +} + +func (_c *MockRequester2_Get_Call) Run(run func(path string)) *MockRequester2_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockRequester2_Get_Call) Return(err error) *MockRequester2_Get_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockRequester2_Get_Call) RunAndReturn(run func(path string)error) *MockRequester2_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequester3 creates a new instance of MockRequester3. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequester3 (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequester3 { + mock := &MockRequester3{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequester3 is an autogenerated mock type for the Requester3 type +type MockRequester3 struct { + mock.Mock +} + +type MockRequester3_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequester3) EXPECT() *MockRequester3_Expecter { + return &MockRequester3_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequester3 +func (_mock *MockRequester3) Get() error { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 error + if returnFunc, ok := ret.Get(0).(func() error); ok { + r0 = returnFunc() + } else { + r0 = ret.Error(0) + } + return r0 +} + + + +// MockRequester3_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequester3_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +func (_e *MockRequester3_Expecter) Get() *MockRequester3_Get_Call { + return &MockRequester3_Get_Call{Call: _e.mock.On("Get", )} +} + +func (_c *MockRequester3_Get_Call) Run(run func()) *MockRequester3_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockRequester3_Get_Call) Return(err error) *MockRequester3_Get_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockRequester3_Get_Call) RunAndReturn(run func()error) *MockRequester3_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequester4 creates a new instance of MockRequester4. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequester4 (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequester4 { + mock := &MockRequester4{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequester4 is an autogenerated mock type for the Requester4 type +type MockRequester4 struct { + mock.Mock +} + +type MockRequester4_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequester4) EXPECT() *MockRequester4_Expecter { + return &MockRequester4_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequester4 +func (_mock *MockRequester4) Get() { _mock.Called() + return +} + + + +// MockRequester4_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequester4_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +func (_e *MockRequester4_Expecter) Get() *MockRequester4_Get_Call { + return &MockRequester4_Get_Call{Call: _e.mock.On("Get", )} +} + +func (_c *MockRequester4_Get_Call) Run(run func()) *MockRequester4_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockRequester4_Get_Call) Return() *MockRequester4_Get_Call { + _c.Call.Return() + return _c +} + +func (_c *MockRequester4_Get_Call) RunAndReturn(run func()) *MockRequester4_Get_Call { + _c.Run(run) + return _c +} + +// NewMockRequesterArgSameAsImport creates a new instance of MockRequesterArgSameAsImport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterArgSameAsImport (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterArgSameAsImport { + mock := &MockRequesterArgSameAsImport{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterArgSameAsImport is an autogenerated mock type for the RequesterArgSameAsImport type +type MockRequesterArgSameAsImport struct { + mock.Mock +} + +type MockRequesterArgSameAsImport_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequesterArgSameAsImport) EXPECT() *MockRequesterArgSameAsImport_Expecter { + return &MockRequesterArgSameAsImport_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequesterArgSameAsImport +func (_mock *MockRequesterArgSameAsImport) Get(json1 string) *json.RawMessage { + ret := _mock.Called(json1) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 *json.RawMessage + if returnFunc, ok := ret.Get(0).(func(string) *json.RawMessage); ok { + r0 = returnFunc(json1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*json.RawMessage) + } + } + return r0 +} + + + +// MockRequesterArgSameAsImport_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequesterArgSameAsImport_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - json1 +func (_e *MockRequesterArgSameAsImport_Expecter) Get(json1 interface{}, ) *MockRequesterArgSameAsImport_Get_Call { + return &MockRequesterArgSameAsImport_Get_Call{Call: _e.mock.On("Get",json1, )} +} + +func (_c *MockRequesterArgSameAsImport_Get_Call) Run(run func(json1 string)) *MockRequesterArgSameAsImport_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockRequesterArgSameAsImport_Get_Call) Return(rawMessage *json.RawMessage) *MockRequesterArgSameAsImport_Get_Call { + _c.Call.Return(rawMessage) + return _c +} + +func (_c *MockRequesterArgSameAsImport_Get_Call) RunAndReturn(run func(json1 string)*json.RawMessage) *MockRequesterArgSameAsImport_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequesterArgSameAsNamedImport creates a new instance of MockRequesterArgSameAsNamedImport. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterArgSameAsNamedImport (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterArgSameAsNamedImport { + mock := &MockRequesterArgSameAsNamedImport{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterArgSameAsNamedImport is an autogenerated mock type for the RequesterArgSameAsNamedImport type +type MockRequesterArgSameAsNamedImport struct { + mock.Mock +} + +type MockRequesterArgSameAsNamedImport_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequesterArgSameAsNamedImport) EXPECT() *MockRequesterArgSameAsNamedImport_Expecter { + return &MockRequesterArgSameAsNamedImport_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequesterArgSameAsNamedImport +func (_mock *MockRequesterArgSameAsNamedImport) Get(json1 string) *json.RawMessage { + ret := _mock.Called(json1) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 *json.RawMessage + if returnFunc, ok := ret.Get(0).(func(string) *json.RawMessage); ok { + r0 = returnFunc(json1) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*json.RawMessage) + } + } + return r0 +} + + + +// MockRequesterArgSameAsNamedImport_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequesterArgSameAsNamedImport_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - json1 +func (_e *MockRequesterArgSameAsNamedImport_Expecter) Get(json1 interface{}, ) *MockRequesterArgSameAsNamedImport_Get_Call { + return &MockRequesterArgSameAsNamedImport_Get_Call{Call: _e.mock.On("Get",json1, )} +} + +func (_c *MockRequesterArgSameAsNamedImport_Get_Call) Run(run func(json1 string)) *MockRequesterArgSameAsNamedImport_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockRequesterArgSameAsNamedImport_Get_Call) Return(rawMessage *json.RawMessage) *MockRequesterArgSameAsNamedImport_Get_Call { + _c.Call.Return(rawMessage) + return _c +} + +func (_c *MockRequesterArgSameAsNamedImport_Get_Call) RunAndReturn(run func(json1 string)*json.RawMessage) *MockRequesterArgSameAsNamedImport_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequesterArgSameAsPkg creates a new instance of MockRequesterArgSameAsPkg. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterArgSameAsPkg (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterArgSameAsPkg { + mock := &MockRequesterArgSameAsPkg{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterArgSameAsPkg is an autogenerated mock type for the RequesterArgSameAsPkg type +type MockRequesterArgSameAsPkg struct { + mock.Mock +} + +type MockRequesterArgSameAsPkg_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequesterArgSameAsPkg) EXPECT() *MockRequesterArgSameAsPkg_Expecter { + return &MockRequesterArgSameAsPkg_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequesterArgSameAsPkg +func (_mock *MockRequesterArgSameAsPkg) Get(test1 string) { _mock.Called(test1) + return +} + + + +// MockRequesterArgSameAsPkg_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequesterArgSameAsPkg_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - test1 +func (_e *MockRequesterArgSameAsPkg_Expecter) Get(test1 interface{}, ) *MockRequesterArgSameAsPkg_Get_Call { + return &MockRequesterArgSameAsPkg_Get_Call{Call: _e.mock.On("Get",test1, )} +} + +func (_c *MockRequesterArgSameAsPkg_Get_Call) Run(run func(test1 string)) *MockRequesterArgSameAsPkg_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockRequesterArgSameAsPkg_Get_Call) Return() *MockRequesterArgSameAsPkg_Get_Call { + _c.Call.Return() + return _c +} + +func (_c *MockRequesterArgSameAsPkg_Get_Call) RunAndReturn(run func(test1 string)) *MockRequesterArgSameAsPkg_Get_Call { + _c.Run(run) + return _c +} + +// NewMockRequesterArray creates a new instance of MockRequesterArray. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterArray (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterArray { + mock := &MockRequesterArray{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterArray is an autogenerated mock type for the RequesterArray type +type MockRequesterArray struct { + mock.Mock +} + +type MockRequesterArray_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequesterArray) EXPECT() *MockRequesterArray_Expecter { + return &MockRequesterArray_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequesterArray +func (_mock *MockRequesterArray) Get(path string) ([2]string, error) { + ret := _mock.Called(path) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 [2]string + var r1 error + if returnFunc, ok := ret.Get(0).(func(string) ([2]string, error)); ok { + return returnFunc(path) + } + if returnFunc, ok := ret.Get(0).(func(string) [2]string); ok { + r0 = returnFunc(path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([2]string) + } + } + if returnFunc, ok := ret.Get(1).(func(string) error); ok { + r1 = returnFunc(path) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockRequesterArray_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequesterArray_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - path +func (_e *MockRequesterArray_Expecter) Get(path interface{}, ) *MockRequesterArray_Get_Call { + return &MockRequesterArray_Get_Call{Call: _e.mock.On("Get",path, )} +} + +func (_c *MockRequesterArray_Get_Call) Run(run func(path string)) *MockRequesterArray_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockRequesterArray_Get_Call) Return(strings [2]string, err error) *MockRequesterArray_Get_Call { + _c.Call.Return(strings, err) + return _c +} + +func (_c *MockRequesterArray_Get_Call) RunAndReturn(run func(path string)([2]string, error)) *MockRequesterArray_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequesterElided creates a new instance of MockRequesterElided. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterElided (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterElided { + mock := &MockRequesterElided{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterElided is an autogenerated mock type for the RequesterElided type +type MockRequesterElided struct { + mock.Mock +} + +type MockRequesterElided_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequesterElided) EXPECT() *MockRequesterElided_Expecter { + return &MockRequesterElided_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequesterElided +func (_mock *MockRequesterElided) Get(path string, url string) error { + ret := _mock.Called(path, url) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 error + if returnFunc, ok := ret.Get(0).(func(string, string) error); ok { + r0 = returnFunc(path, url) + } else { + r0 = ret.Error(0) + } + return r0 +} + + + +// MockRequesterElided_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequesterElided_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - path +// - url +func (_e *MockRequesterElided_Expecter) Get(path interface{}, url interface{}, ) *MockRequesterElided_Get_Call { + return &MockRequesterElided_Get_Call{Call: _e.mock.On("Get",path,url, )} +} + +func (_c *MockRequesterElided_Get_Call) Run(run func(path string, url string)) *MockRequesterElided_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),args[1].(string),) + }) + return _c +} + +func (_c *MockRequesterElided_Get_Call) Return(err error) *MockRequesterElided_Get_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockRequesterElided_Get_Call) RunAndReturn(run func(path string, url string)error) *MockRequesterElided_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequesterIface creates a new instance of MockRequesterIface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterIface (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterIface { + mock := &MockRequesterIface{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterIface is an autogenerated mock type for the RequesterIface type +type MockRequesterIface struct { + mock.Mock +} + +type MockRequesterIface_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequesterIface) EXPECT() *MockRequesterIface_Expecter { + return &MockRequesterIface_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequesterIface +func (_mock *MockRequesterIface) Get() io.Reader { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 io.Reader + if returnFunc, ok := ret.Get(0).(func() io.Reader); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(io.Reader) + } + } + return r0 +} + + + +// MockRequesterIface_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequesterIface_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +func (_e *MockRequesterIface_Expecter) Get() *MockRequesterIface_Get_Call { + return &MockRequesterIface_Get_Call{Call: _e.mock.On("Get", )} +} + +func (_c *MockRequesterIface_Get_Call) Run(run func()) *MockRequesterIface_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockRequesterIface_Get_Call) Return(reader io.Reader) *MockRequesterIface_Get_Call { + _c.Call.Return(reader) + return _c +} + +func (_c *MockRequesterIface_Get_Call) RunAndReturn(run func()io.Reader) *MockRequesterIface_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequesterNS creates a new instance of MockRequesterNS. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterNS (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterNS { + mock := &MockRequesterNS{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterNS is an autogenerated mock type for the RequesterNS type +type MockRequesterNS struct { + mock.Mock +} + +type MockRequesterNS_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequesterNS) EXPECT() *MockRequesterNS_Expecter { + return &MockRequesterNS_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequesterNS +func (_mock *MockRequesterNS) Get(path string) (http.Response, error) { + ret := _mock.Called(path) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 http.Response + var r1 error + if returnFunc, ok := ret.Get(0).(func(string) (http.Response, error)); ok { + return returnFunc(path) + } + if returnFunc, ok := ret.Get(0).(func(string) http.Response); ok { + r0 = returnFunc(path) + } else { + r0 = ret.Get(0).(http.Response) + } + if returnFunc, ok := ret.Get(1).(func(string) error); ok { + r1 = returnFunc(path) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockRequesterNS_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequesterNS_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - path +func (_e *MockRequesterNS_Expecter) Get(path interface{}, ) *MockRequesterNS_Get_Call { + return &MockRequesterNS_Get_Call{Call: _e.mock.On("Get",path, )} +} + +func (_c *MockRequesterNS_Get_Call) Run(run func(path string)) *MockRequesterNS_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockRequesterNS_Get_Call) Return(response http.Response, err error) *MockRequesterNS_Get_Call { + _c.Call.Return(response, err) + return _c +} + +func (_c *MockRequesterNS_Get_Call) RunAndReturn(run func(path string)(http.Response, error)) *MockRequesterNS_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequesterPtr creates a new instance of MockRequesterPtr. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterPtr (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterPtr { + mock := &MockRequesterPtr{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterPtr is an autogenerated mock type for the RequesterPtr type +type MockRequesterPtr struct { + mock.Mock +} + +type MockRequesterPtr_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequesterPtr) EXPECT() *MockRequesterPtr_Expecter { + return &MockRequesterPtr_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequesterPtr +func (_mock *MockRequesterPtr) Get(path string) (*string, error) { + ret := _mock.Called(path) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 *string + var r1 error + if returnFunc, ok := ret.Get(0).(func(string) (*string, error)); ok { + return returnFunc(path) + } + if returnFunc, ok := ret.Get(0).(func(string) *string); ok { + r0 = returnFunc(path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*string) + } + } + if returnFunc, ok := ret.Get(1).(func(string) error); ok { + r1 = returnFunc(path) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockRequesterPtr_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequesterPtr_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - path +func (_e *MockRequesterPtr_Expecter) Get(path interface{}, ) *MockRequesterPtr_Get_Call { + return &MockRequesterPtr_Get_Call{Call: _e.mock.On("Get",path, )} +} + +func (_c *MockRequesterPtr_Get_Call) Run(run func(path string)) *MockRequesterPtr_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockRequesterPtr_Get_Call) Return(s *string, err error) *MockRequesterPtr_Get_Call { + _c.Call.Return(s, err) + return _c +} + +func (_c *MockRequesterPtr_Get_Call) RunAndReturn(run func(path string)(*string, error)) *MockRequesterPtr_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequesterReturnElided creates a new instance of MockRequesterReturnElided. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterReturnElided (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterReturnElided { + mock := &MockRequesterReturnElided{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterReturnElided is an autogenerated mock type for the RequesterReturnElided type +type MockRequesterReturnElided struct { + mock.Mock +} + +type MockRequesterReturnElided_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequesterReturnElided) EXPECT() *MockRequesterReturnElided_Expecter { + return &MockRequesterReturnElided_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequesterReturnElided +func (_mock *MockRequesterReturnElided) Get(path string) (int, int, int, error) { + ret := _mock.Called(path) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 int + var r1 int + var r2 int + var r3 error + if returnFunc, ok := ret.Get(0).(func(string) (int, int, int, error)); ok { + return returnFunc(path) + } + if returnFunc, ok := ret.Get(0).(func(string) int); ok { + r0 = returnFunc(path) + } else { + r0 = ret.Get(0).(int) + } + if returnFunc, ok := ret.Get(1).(func(string) int); ok { + r1 = returnFunc(path) + } else { + r1 = ret.Get(1).(int) + } + if returnFunc, ok := ret.Get(2).(func(string) int); ok { + r2 = returnFunc(path) + } else { + r2 = ret.Get(2).(int) + } + if returnFunc, ok := ret.Get(3).(func(string) error); ok { + r3 = returnFunc(path) + } else { + r3 = ret.Error(3) + } + return r0, r1, r2, r3 +} + + + +// MockRequesterReturnElided_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequesterReturnElided_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - path +func (_e *MockRequesterReturnElided_Expecter) Get(path interface{}, ) *MockRequesterReturnElided_Get_Call { + return &MockRequesterReturnElided_Get_Call{Call: _e.mock.On("Get",path, )} +} + +func (_c *MockRequesterReturnElided_Get_Call) Run(run func(path string)) *MockRequesterReturnElided_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockRequesterReturnElided_Get_Call) Return(a int, b int, c int, err error) *MockRequesterReturnElided_Get_Call { + _c.Call.Return(a, b, c, err) + return _c +} + +func (_c *MockRequesterReturnElided_Get_Call) RunAndReturn(run func(path string)(int, int, int, error)) *MockRequesterReturnElided_Get_Call { + _c.Call.Return(run) + return _c +} + + +// Put provides a mock function for the type MockRequesterReturnElided +func (_mock *MockRequesterReturnElided) Put(path string) (int, error) { + ret := _mock.Called(path) + + if len(ret) == 0 { + panic("no return value specified for Put") + } + + + var r0 int + var r1 error + if returnFunc, ok := ret.Get(0).(func(string) (int, error)); ok { + return returnFunc(path) + } + if returnFunc, ok := ret.Get(0).(func(string) int); ok { + r0 = returnFunc(path) + } else { + r0 = ret.Get(0).(int) + } + if returnFunc, ok := ret.Get(1).(func(string) error); ok { + r1 = returnFunc(path) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockRequesterReturnElided_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put' +type MockRequesterReturnElided_Put_Call struct { + *mock.Call +} + + + +// Put is a helper method to define mock.On call +// - path +func (_e *MockRequesterReturnElided_Expecter) Put(path interface{}, ) *MockRequesterReturnElided_Put_Call { + return &MockRequesterReturnElided_Put_Call{Call: _e.mock.On("Put",path, )} +} + +func (_c *MockRequesterReturnElided_Put_Call) Run(run func(path string)) *MockRequesterReturnElided_Put_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockRequesterReturnElided_Put_Call) Return(n int, err error) *MockRequesterReturnElided_Put_Call { + _c.Call.Return(n, err) + return _c +} + +func (_c *MockRequesterReturnElided_Put_Call) RunAndReturn(run func(path string)(int, error)) *MockRequesterReturnElided_Put_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequesterSlice creates a new instance of MockRequesterSlice. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterSlice (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterSlice { + mock := &MockRequesterSlice{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterSlice is an autogenerated mock type for the RequesterSlice type +type MockRequesterSlice struct { + mock.Mock +} + +type MockRequesterSlice_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequesterSlice) EXPECT() *MockRequesterSlice_Expecter { + return &MockRequesterSlice_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequesterSlice +func (_mock *MockRequesterSlice) Get(path string) ([]string, error) { + ret := _mock.Called(path) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 []string + var r1 error + if returnFunc, ok := ret.Get(0).(func(string) ([]string, error)); ok { + return returnFunc(path) + } + if returnFunc, ok := ret.Get(0).(func(string) []string); ok { + r0 = returnFunc(path) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).([]string) + } + } + if returnFunc, ok := ret.Get(1).(func(string) error); ok { + r1 = returnFunc(path) + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockRequesterSlice_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequesterSlice_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - path +func (_e *MockRequesterSlice_Expecter) Get(path interface{}, ) *MockRequesterSlice_Get_Call { + return &MockRequesterSlice_Get_Call{Call: _e.mock.On("Get",path, )} +} + +func (_c *MockRequesterSlice_Get_Call) Run(run func(path string)) *MockRequesterSlice_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockRequesterSlice_Get_Call) Return(strings []string, err error) *MockRequesterSlice_Get_Call { + _c.Call.Return(strings, err) + return _c +} + +func (_c *MockRequesterSlice_Get_Call) RunAndReturn(run func(path string)([]string, error)) *MockRequesterSlice_Get_Call { + _c.Call.Return(run) + return _c +} + +// NewMockrequesterUnexported creates a new instance of MockrequesterUnexported. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockrequesterUnexported (t interface { + mock.TestingT + Cleanup(func()) +}) *MockrequesterUnexported { + mock := &MockrequesterUnexported{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockrequesterUnexported is an autogenerated mock type for the requesterUnexported type +type MockrequesterUnexported struct { + mock.Mock +} + +type MockrequesterUnexported_Expecter struct { + mock *mock.Mock +} + +func (_m *MockrequesterUnexported) EXPECT() *MockrequesterUnexported_Expecter { + return &MockrequesterUnexported_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockrequesterUnexported +func (_mock *MockrequesterUnexported) Get() { _mock.Called() + return +} + + + +// MockrequesterUnexported_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockrequesterUnexported_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +func (_e *MockrequesterUnexported_Expecter) Get() *MockrequesterUnexported_Get_Call { + return &MockrequesterUnexported_Get_Call{Call: _e.mock.On("Get", )} +} + +func (_c *MockrequesterUnexported_Get_Call) Run(run func()) *MockrequesterUnexported_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockrequesterUnexported_Get_Call) Return() *MockrequesterUnexported_Get_Call { + _c.Call.Return() + return _c +} + +func (_c *MockrequesterUnexported_Get_Call) RunAndReturn(run func()) *MockrequesterUnexported_Get_Call { + _c.Run(run) + return _c +} + +// NewMockRequesterVariadicOneArgument creates a new instance of MockRequesterVariadicOneArgument. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterVariadicOneArgument (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterVariadicOneArgument { + mock := &MockRequesterVariadicOneArgument{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterVariadicOneArgument is an autogenerated mock type for the RequesterVariadic type +type MockRequesterVariadicOneArgument struct { + mock.Mock +} + +type MockRequesterVariadicOneArgument_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequesterVariadicOneArgument) EXPECT() *MockRequesterVariadicOneArgument_Expecter { + return &MockRequesterVariadicOneArgument_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequesterVariadicOneArgument +func (_mock *MockRequesterVariadicOneArgument) Get(values ...string) bool { + var tmpRet mock.Arguments + if len(values) > 0 {tmpRet = _mock.Called(values) + } else {tmpRet = _mock.Called() + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 bool + if returnFunc, ok := ret.Get(0).(func(...string) bool); ok { + r0 = returnFunc(values...) + } else { + r0 = ret.Get(0).(bool) + } + return r0 +} + + + +// MockRequesterVariadicOneArgument_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequesterVariadicOneArgument_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - values +func (_e *MockRequesterVariadicOneArgument_Expecter) Get(values ...interface{}, ) *MockRequesterVariadicOneArgument_Get_Call { + return &MockRequesterVariadicOneArgument_Get_Call{Call: _e.mock.On("Get", + append([]interface{}{ }, values... )... )} +} + +func (_c *MockRequesterVariadicOneArgument_Get_Call) Run(run func(values ...string)) *MockRequesterVariadicOneArgument_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args) - 0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *MockRequesterVariadicOneArgument_Get_Call) Return(b bool) *MockRequesterVariadicOneArgument_Get_Call { + _c.Call.Return(b) + return _c +} + +func (_c *MockRequesterVariadicOneArgument_Get_Call) RunAndReturn(run func(values ...string)bool) *MockRequesterVariadicOneArgument_Get_Call { + _c.Call.Return(run) + return _c +} + + +// MultiWriteToFile provides a mock function for the type MockRequesterVariadicOneArgument +func (_mock *MockRequesterVariadicOneArgument) MultiWriteToFile(filename string, w ...io.Writer) string { + var tmpRet mock.Arguments + if len(w) > 0 {tmpRet = _mock.Called(filename, w) + } else {tmpRet = _mock.Called(filename) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for MultiWriteToFile") + } + + + var r0 string + if returnFunc, ok := ret.Get(0).(func(string, ...io.Writer) string); ok { + r0 = returnFunc(filename, w...) + } else { + r0 = ret.Get(0).(string) + } + return r0 +} + + + +// MockRequesterVariadicOneArgument_MultiWriteToFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiWriteToFile' +type MockRequesterVariadicOneArgument_MultiWriteToFile_Call struct { + *mock.Call +} + + + +// MultiWriteToFile is a helper method to define mock.On call +// - filename +// - w +func (_e *MockRequesterVariadicOneArgument_Expecter) MultiWriteToFile(filename interface{}, w ...interface{}, ) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call { + return &MockRequesterVariadicOneArgument_MultiWriteToFile_Call{Call: _e.mock.On("MultiWriteToFile", + append([]interface{}{ filename, }, w... )... )} +} + +func (_c *MockRequesterVariadicOneArgument_MultiWriteToFile_Call) Run(run func(filename string, w ...io.Writer)) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]io.Writer, len(args) - 1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(io.Writer) + } + } + run(args[0].(string),variadicArgs...) + }) + return _c +} + +func (_c *MockRequesterVariadicOneArgument_MultiWriteToFile_Call) Return(s string) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call { + _c.Call.Return(s) + return _c +} + +func (_c *MockRequesterVariadicOneArgument_MultiWriteToFile_Call) RunAndReturn(run func(filename string, w ...io.Writer)string) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call { + _c.Call.Return(run) + return _c +} + + +// OneInterface provides a mock function for the type MockRequesterVariadicOneArgument +func (_mock *MockRequesterVariadicOneArgument) OneInterface(a ...interface{}) bool { + var tmpRet mock.Arguments + if len(a) > 0 {tmpRet = _mock.Called(a) + } else {tmpRet = _mock.Called() + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for OneInterface") + } + + + var r0 bool + if returnFunc, ok := ret.Get(0).(func(...interface{}) bool); ok { + r0 = returnFunc(a...) + } else { + r0 = ret.Get(0).(bool) + } + return r0 +} + + + +// MockRequesterVariadicOneArgument_OneInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OneInterface' +type MockRequesterVariadicOneArgument_OneInterface_Call struct { + *mock.Call +} + + + +// OneInterface is a helper method to define mock.On call +// - a +func (_e *MockRequesterVariadicOneArgument_Expecter) OneInterface(a ...interface{}, ) *MockRequesterVariadicOneArgument_OneInterface_Call { + return &MockRequesterVariadicOneArgument_OneInterface_Call{Call: _e.mock.On("OneInterface", + append([]interface{}{ }, a... )... )} +} + +func (_c *MockRequesterVariadicOneArgument_OneInterface_Call) Run(run func(a ...interface{})) *MockRequesterVariadicOneArgument_OneInterface_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args) - 0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *MockRequesterVariadicOneArgument_OneInterface_Call) Return(b bool) *MockRequesterVariadicOneArgument_OneInterface_Call { + _c.Call.Return(b) + return _c +} + +func (_c *MockRequesterVariadicOneArgument_OneInterface_Call) RunAndReturn(run func(a ...interface{})bool) *MockRequesterVariadicOneArgument_OneInterface_Call { + _c.Call.Return(run) + return _c +} + + +// Sprintf provides a mock function for the type MockRequesterVariadicOneArgument +func (_mock *MockRequesterVariadicOneArgument) Sprintf(format string, a ...interface{}) string { + var tmpRet mock.Arguments + if len(a) > 0 {tmpRet = _mock.Called(format, a) + } else {tmpRet = _mock.Called(format) + } + ret := tmpRet + + if len(ret) == 0 { + panic("no return value specified for Sprintf") + } + + + var r0 string + if returnFunc, ok := ret.Get(0).(func(string, ...interface{}) string); ok { + r0 = returnFunc(format, a...) + } else { + r0 = ret.Get(0).(string) + } + return r0 +} + + + +// MockRequesterVariadicOneArgument_Sprintf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sprintf' +type MockRequesterVariadicOneArgument_Sprintf_Call struct { + *mock.Call +} + + + +// Sprintf is a helper method to define mock.On call +// - format +// - a +func (_e *MockRequesterVariadicOneArgument_Expecter) Sprintf(format interface{}, a ...interface{}, ) *MockRequesterVariadicOneArgument_Sprintf_Call { + return &MockRequesterVariadicOneArgument_Sprintf_Call{Call: _e.mock.On("Sprintf", + append([]interface{}{ format, }, a... )... )} +} + +func (_c *MockRequesterVariadicOneArgument_Sprintf_Call) Run(run func(format string, a ...interface{})) *MockRequesterVariadicOneArgument_Sprintf_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args) - 1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(string),variadicArgs...) + }) + return _c +} + +func (_c *MockRequesterVariadicOneArgument_Sprintf_Call) Return(s string) *MockRequesterVariadicOneArgument_Sprintf_Call { + _c.Call.Return(s) + return _c +} + +func (_c *MockRequesterVariadicOneArgument_Sprintf_Call) RunAndReturn(run func(format string, a ...interface{})string) *MockRequesterVariadicOneArgument_Sprintf_Call { + _c.Call.Return(run) + return _c +} + +// NewMockRequesterVariadic creates a new instance of MockRequesterVariadic. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockRequesterVariadic (t interface { + mock.TestingT + Cleanup(func()) +}) *MockRequesterVariadic { + mock := &MockRequesterVariadic{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockRequesterVariadic is an autogenerated mock type for the RequesterVariadic type +type MockRequesterVariadic struct { + mock.Mock +} + +type MockRequesterVariadic_Expecter struct { + mock *mock.Mock +} + +func (_m *MockRequesterVariadic) EXPECT() *MockRequesterVariadic_Expecter { + return &MockRequesterVariadic_Expecter{mock: &_m.Mock} +} + + + +// Get provides a mock function for the type MockRequesterVariadic +func (_mock *MockRequesterVariadic) Get(values ...string) bool { + // string + _va := make([]interface{}, len(values)) + for _i := range values { + _va[_i] = values[_i] + } + var _ca []interface{} + _ca = append(_ca, _va...) + ret := _mock.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Get") + } + + + var r0 bool + if returnFunc, ok := ret.Get(0).(func(...string) bool); ok { + r0 = returnFunc(values...) + } else { + r0 = ret.Get(0).(bool) + } + return r0 +} + + + +// MockRequesterVariadic_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get' +type MockRequesterVariadic_Get_Call struct { + *mock.Call +} + + + +// Get is a helper method to define mock.On call +// - values +func (_e *MockRequesterVariadic_Expecter) Get(values ...interface{}, ) *MockRequesterVariadic_Get_Call { + return &MockRequesterVariadic_Get_Call{Call: _e.mock.On("Get", + append([]interface{}{ }, values... )... )} +} + +func (_c *MockRequesterVariadic_Get_Call) Run(run func(values ...string)) *MockRequesterVariadic_Get_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]string, len(args) - 0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(string) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *MockRequesterVariadic_Get_Call) Return(b bool) *MockRequesterVariadic_Get_Call { + _c.Call.Return(b) + return _c +} + +func (_c *MockRequesterVariadic_Get_Call) RunAndReturn(run func(values ...string)bool) *MockRequesterVariadic_Get_Call { + _c.Call.Return(run) + return _c +} + + +// MultiWriteToFile provides a mock function for the type MockRequesterVariadic +func (_mock *MockRequesterVariadic) MultiWriteToFile(filename string, w ...io.Writer) string { + // io.Writer + _va := make([]interface{}, len(w)) + for _i := range w { + _va[_i] = w[_i] + } + var _ca []interface{} + _ca = append(_ca, filename) + _ca = append(_ca, _va...) + ret := _mock.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for MultiWriteToFile") + } + + + var r0 string + if returnFunc, ok := ret.Get(0).(func(string, ...io.Writer) string); ok { + r0 = returnFunc(filename, w...) + } else { + r0 = ret.Get(0).(string) + } + return r0 +} + + + +// MockRequesterVariadic_MultiWriteToFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiWriteToFile' +type MockRequesterVariadic_MultiWriteToFile_Call struct { + *mock.Call +} + + + +// MultiWriteToFile is a helper method to define mock.On call +// - filename +// - w +func (_e *MockRequesterVariadic_Expecter) MultiWriteToFile(filename interface{}, w ...interface{}, ) *MockRequesterVariadic_MultiWriteToFile_Call { + return &MockRequesterVariadic_MultiWriteToFile_Call{Call: _e.mock.On("MultiWriteToFile", + append([]interface{}{ filename, }, w... )... )} +} + +func (_c *MockRequesterVariadic_MultiWriteToFile_Call) Run(run func(filename string, w ...io.Writer)) *MockRequesterVariadic_MultiWriteToFile_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]io.Writer, len(args) - 1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(io.Writer) + } + } + run(args[0].(string),variadicArgs...) + }) + return _c +} + +func (_c *MockRequesterVariadic_MultiWriteToFile_Call) Return(s string) *MockRequesterVariadic_MultiWriteToFile_Call { + _c.Call.Return(s) + return _c +} + +func (_c *MockRequesterVariadic_MultiWriteToFile_Call) RunAndReturn(run func(filename string, w ...io.Writer)string) *MockRequesterVariadic_MultiWriteToFile_Call { + _c.Call.Return(run) + return _c +} + + +// OneInterface provides a mock function for the type MockRequesterVariadic +func (_mock *MockRequesterVariadic) OneInterface(a ...interface{}) bool { + var _ca []interface{} + _ca = append(_ca, a...) + ret := _mock.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for OneInterface") + } + + + var r0 bool + if returnFunc, ok := ret.Get(0).(func(...interface{}) bool); ok { + r0 = returnFunc(a...) + } else { + r0 = ret.Get(0).(bool) + } + return r0 +} + + + +// MockRequesterVariadic_OneInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OneInterface' +type MockRequesterVariadic_OneInterface_Call struct { + *mock.Call +} + + + +// OneInterface is a helper method to define mock.On call +// - a +func (_e *MockRequesterVariadic_Expecter) OneInterface(a ...interface{}, ) *MockRequesterVariadic_OneInterface_Call { + return &MockRequesterVariadic_OneInterface_Call{Call: _e.mock.On("OneInterface", + append([]interface{}{ }, a... )... )} +} + +func (_c *MockRequesterVariadic_OneInterface_Call) Run(run func(a ...interface{})) *MockRequesterVariadic_OneInterface_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args) - 0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *MockRequesterVariadic_OneInterface_Call) Return(b bool) *MockRequesterVariadic_OneInterface_Call { + _c.Call.Return(b) + return _c +} + +func (_c *MockRequesterVariadic_OneInterface_Call) RunAndReturn(run func(a ...interface{})bool) *MockRequesterVariadic_OneInterface_Call { + _c.Call.Return(run) + return _c +} + + +// Sprintf provides a mock function for the type MockRequesterVariadic +func (_mock *MockRequesterVariadic) Sprintf(format string, a ...interface{}) string { + var _ca []interface{} + _ca = append(_ca, format) + _ca = append(_ca, a...) + ret := _mock.Called(_ca...) + + if len(ret) == 0 { + panic("no return value specified for Sprintf") + } + + + var r0 string + if returnFunc, ok := ret.Get(0).(func(string, ...interface{}) string); ok { + r0 = returnFunc(format, a...) + } else { + r0 = ret.Get(0).(string) + } + return r0 +} + + + +// MockRequesterVariadic_Sprintf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sprintf' +type MockRequesterVariadic_Sprintf_Call struct { + *mock.Call +} + + + +// Sprintf is a helper method to define mock.On call +// - format +// - a +func (_e *MockRequesterVariadic_Expecter) Sprintf(format interface{}, a ...interface{}, ) *MockRequesterVariadic_Sprintf_Call { + return &MockRequesterVariadic_Sprintf_Call{Call: _e.mock.On("Sprintf", + append([]interface{}{ format, }, a... )... )} +} + +func (_c *MockRequesterVariadic_Sprintf_Call) Run(run func(format string, a ...interface{})) *MockRequesterVariadic_Sprintf_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]interface{}, len(args) - 1) + for i, a := range args[1:] { + if a != nil { + variadicArgs[i] = a.(interface{}) + } + } + run(args[0].(string),variadicArgs...) + }) + return _c +} + +func (_c *MockRequesterVariadic_Sprintf_Call) Return(s string) *MockRequesterVariadic_Sprintf_Call { + _c.Call.Return(s) + return _c +} + +func (_c *MockRequesterVariadic_Sprintf_Call) RunAndReturn(run func(format string, a ...interface{})string) *MockRequesterVariadic_Sprintf_Call { + _c.Call.Return(run) + return _c +} + +// NewMockExample creates a new instance of MockExample. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockExample (t interface { + mock.TestingT + Cleanup(func()) +}) *MockExample { + mock := &MockExample{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockExample is an autogenerated mock type for the Example type +type MockExample struct { + mock.Mock +} + +type MockExample_Expecter struct { + mock *mock.Mock +} + +func (_m *MockExample) EXPECT() *MockExample_Expecter { + return &MockExample_Expecter{mock: &_m.Mock} +} + + + +// A provides a mock function for the type MockExample +func (_mock *MockExample) A() http.Flusher { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for A") + } + + + var r0 http.Flusher + if returnFunc, ok := ret.Get(0).(func() http.Flusher); ok { + r0 = returnFunc() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(http.Flusher) + } + } + return r0 +} + + + +// MockExample_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A' +type MockExample_A_Call struct { + *mock.Call +} + + + +// A is a helper method to define mock.On call +func (_e *MockExample_Expecter) A() *MockExample_A_Call { + return &MockExample_A_Call{Call: _e.mock.On("A", )} +} + +func (_c *MockExample_A_Call) Run(run func()) *MockExample_A_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockExample_A_Call) Return(flusher http.Flusher) *MockExample_A_Call { + _c.Call.Return(flusher) + return _c +} + +func (_c *MockExample_A_Call) RunAndReturn(run func()http.Flusher) *MockExample_A_Call { + _c.Call.Return(run) + return _c +} + + +// B provides a mock function for the type MockExample +func (_mock *MockExample) B(fixtureshttp string) http0.MyStruct { + ret := _mock.Called(fixtureshttp) + + if len(ret) == 0 { + panic("no return value specified for B") + } + + + var r0 http0.MyStruct + if returnFunc, ok := ret.Get(0).(func(string) http0.MyStruct); ok { + r0 = returnFunc(fixtureshttp) + } else { + r0 = ret.Get(0).(http0.MyStruct) + } + return r0 +} + + + +// MockExample_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B' +type MockExample_B_Call struct { + *mock.Call +} + + + +// B is a helper method to define mock.On call +// - fixtureshttp +func (_e *MockExample_Expecter) B(fixtureshttp interface{}, ) *MockExample_B_Call { + return &MockExample_B_Call{Call: _e.mock.On("B",fixtureshttp, )} +} + +func (_c *MockExample_B_Call) Run(run func(fixtureshttp string)) *MockExample_B_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockExample_B_Call) Return(myStruct http0.MyStruct) *MockExample_B_Call { + _c.Call.Return(myStruct) + return _c +} + +func (_c *MockExample_B_Call) RunAndReturn(run func(fixtureshttp string)http0.MyStruct) *MockExample_B_Call { + _c.Call.Return(run) + return _c +} + + +// C provides a mock function for the type MockExample +func (_mock *MockExample) C(fixtureshttp string) http1.MyStruct { + ret := _mock.Called(fixtureshttp) + + if len(ret) == 0 { + panic("no return value specified for C") + } + + + var r0 http1.MyStruct + if returnFunc, ok := ret.Get(0).(func(string) http1.MyStruct); ok { + r0 = returnFunc(fixtureshttp) + } else { + r0 = ret.Get(0).(http1.MyStruct) + } + return r0 +} + + + +// MockExample_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C' +type MockExample_C_Call struct { + *mock.Call +} + + + +// C is a helper method to define mock.On call +// - fixtureshttp +func (_e *MockExample_Expecter) C(fixtureshttp interface{}, ) *MockExample_C_Call { + return &MockExample_C_Call{Call: _e.mock.On("C",fixtureshttp, )} +} + +func (_c *MockExample_C_Call) Run(run func(fixtureshttp string)) *MockExample_C_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockExample_C_Call) Return(myStruct http1.MyStruct) *MockExample_C_Call { + _c.Call.Return(myStruct) + return _c +} + +func (_c *MockExample_C_Call) RunAndReturn(run func(fixtureshttp string)http1.MyStruct) *MockExample_C_Call { + _c.Call.Return(run) + return _c +} + +// NewMockA creates a new instance of MockA. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockA (t interface { + mock.TestingT + Cleanup(func()) +}) *MockA { + mock := &MockA{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockA is an autogenerated mock type for the A type +type MockA struct { + mock.Mock +} + +type MockA_Expecter struct { + mock *mock.Mock +} + +func (_m *MockA) EXPECT() *MockA_Expecter { + return &MockA_Expecter{mock: &_m.Mock} +} + + + +// Call provides a mock function for the type MockA +func (_mock *MockA) Call() (B, error) { + ret := _mock.Called() + + if len(ret) == 0 { + panic("no return value specified for Call") + } + + + var r0 B + var r1 error + if returnFunc, ok := ret.Get(0).(func() (B, error)); ok { + return returnFunc() + } + if returnFunc, ok := ret.Get(0).(func() B); ok { + r0 = returnFunc() + } else { + r0 = ret.Get(0).(B) + } + if returnFunc, ok := ret.Get(1).(func() error); ok { + r1 = returnFunc() + } else { + r1 = ret.Error(1) + } + return r0, r1 +} + + + +// MockA_Call_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Call' +type MockA_Call_Call struct { + *mock.Call +} + + + +// Call is a helper method to define mock.On call +func (_e *MockA_Expecter) Call() *MockA_Call_Call { + return &MockA_Call_Call{Call: _e.mock.On("Call", )} +} + +func (_c *MockA_Call_Call) Run(run func()) *MockA_Call_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockA_Call_Call) Return(b B, err error) *MockA_Call_Call { + _c.Call.Return(b, err) + return _c +} + +func (_c *MockA_Call_Call) RunAndReturn(run func()(B, error)) *MockA_Call_Call { + _c.Call.Return(run) + return _c +} + +// NewMockStructWithTag creates a new instance of MockStructWithTag. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockStructWithTag (t interface { + mock.TestingT + Cleanup(func()) +}) *MockStructWithTag { + mock := &MockStructWithTag{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockStructWithTag is an autogenerated mock type for the StructWithTag type +type MockStructWithTag struct { + mock.Mock +} + +type MockStructWithTag_Expecter struct { + mock *mock.Mock +} + +func (_m *MockStructWithTag) EXPECT() *MockStructWithTag_Expecter { + return &MockStructWithTag_Expecter{mock: &_m.Mock} +} + + + +// MethodA provides a mock function for the type MockStructWithTag +func (_mock *MockStructWithTag) MethodA(v *struct{FieldA int "json:\"field_a\""; FieldB int "json:\"field_b\" xml:\"field_b\""}) *struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""} { + ret := _mock.Called(v) + + if len(ret) == 0 { + panic("no return value specified for MethodA") + } + + + var r0 *struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""} + if returnFunc, ok := ret.Get(0).(func(*struct{FieldA int "json:\"field_a\""; FieldB int "json:\"field_b\" xml:\"field_b\""}) *struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""}); ok { + r0 = returnFunc(v) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(*struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""}) + } + } + return r0 +} + + + +// MockStructWithTag_MethodA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MethodA' +type MockStructWithTag_MethodA_Call struct { + *mock.Call +} + + + +// MethodA is a helper method to define mock.On call +// - v +func (_e *MockStructWithTag_Expecter) MethodA(v interface{}, ) *MockStructWithTag_MethodA_Call { + return &MockStructWithTag_MethodA_Call{Call: _e.mock.On("MethodA",v, )} +} + +func (_c *MockStructWithTag_MethodA_Call) Run(run func(v *struct{FieldA int "json:\"field_a\""; FieldB int "json:\"field_b\" xml:\"field_b\""})) *MockStructWithTag_MethodA_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*struct{FieldA int "json:\"field_a\""; FieldB int "json:\"field_b\" xml:\"field_b\""}),) + }) + return _c +} + +func (_c *MockStructWithTag_MethodA_Call) Return(val *struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""}) *MockStructWithTag_MethodA_Call { + _c.Call.Return(val) + return _c +} + +func (_c *MockStructWithTag_MethodA_Call) RunAndReturn(run func(v *struct{FieldA int "json:\"field_a\""; FieldB int "json:\"field_b\" xml:\"field_b\""})*struct{FieldC int "json:\"field_c\""; FieldD int "json:\"field_d\" xml:\"field_d\""}) *MockStructWithTag_MethodA_Call { + _c.Call.Return(run) + return _c +} + +// NewMockUnsafeInterface creates a new instance of MockUnsafeInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockUnsafeInterface (t interface { + mock.TestingT + Cleanup(func()) +}) *MockUnsafeInterface { + mock := &MockUnsafeInterface{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockUnsafeInterface is an autogenerated mock type for the UnsafeInterface type +type MockUnsafeInterface struct { + mock.Mock +} + +type MockUnsafeInterface_Expecter struct { + mock *mock.Mock +} + +func (_m *MockUnsafeInterface) EXPECT() *MockUnsafeInterface_Expecter { + return &MockUnsafeInterface_Expecter{mock: &_m.Mock} +} + + + +// Do provides a mock function for the type MockUnsafeInterface +func (_mock *MockUnsafeInterface) Do(ptr *unsafe.Pointer) { _mock.Called(ptr) + return +} + + + +// MockUnsafeInterface_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do' +type MockUnsafeInterface_Do_Call struct { + *mock.Call +} + + + +// Do is a helper method to define mock.On call +// - ptr +func (_e *MockUnsafeInterface_Expecter) Do(ptr interface{}, ) *MockUnsafeInterface_Do_Call { + return &MockUnsafeInterface_Do_Call{Call: _e.mock.On("Do",ptr, )} +} + +func (_c *MockUnsafeInterface_Do_Call) Run(run func(ptr *unsafe.Pointer)) *MockUnsafeInterface_Do_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(*unsafe.Pointer),) + }) + return _c +} + +func (_c *MockUnsafeInterface_Do_Call) Return() *MockUnsafeInterface_Do_Call { + _c.Call.Return() + return _c +} + +func (_c *MockUnsafeInterface_Do_Call) RunAndReturn(run func(ptr *unsafe.Pointer)) *MockUnsafeInterface_Do_Call { + _c.Run(run) + return _c +} + +// NewMockVariadic creates a new instance of MockVariadic. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockVariadic (t interface { + mock.TestingT + Cleanup(func()) +}) *MockVariadic { + mock := &MockVariadic{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockVariadic is an autogenerated mock type for the Variadic type +type MockVariadic struct { + mock.Mock +} + +type MockVariadic_Expecter struct { + mock *mock.Mock +} + +func (_m *MockVariadic) EXPECT() *MockVariadic_Expecter { + return &MockVariadic_Expecter{mock: &_m.Mock} +} + + + +// VariadicFunction provides a mock function for the type MockVariadic +func (_mock *MockVariadic) VariadicFunction(str string, vFunc VariadicFunction) error { + ret := _mock.Called(str, vFunc) + + if len(ret) == 0 { + panic("no return value specified for VariadicFunction") + } + + + var r0 error + if returnFunc, ok := ret.Get(0).(func(string, VariadicFunction) error); ok { + r0 = returnFunc(str, vFunc) + } else { + r0 = ret.Error(0) + } + return r0 +} + + + +// MockVariadic_VariadicFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicFunction' +type MockVariadic_VariadicFunction_Call struct { + *mock.Call +} + + + +// VariadicFunction is a helper method to define mock.On call +// - str +// - vFunc +func (_e *MockVariadic_Expecter) VariadicFunction(str interface{}, vFunc interface{}, ) *MockVariadic_VariadicFunction_Call { + return &MockVariadic_VariadicFunction_Call{Call: _e.mock.On("VariadicFunction",str,vFunc, )} +} + +func (_c *MockVariadic_VariadicFunction_Call) Run(run func(str string, vFunc VariadicFunction)) *MockVariadic_VariadicFunction_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),args[1].(VariadicFunction),) + }) + return _c +} + +func (_c *MockVariadic_VariadicFunction_Call) Return(err error) *MockVariadic_VariadicFunction_Call { + _c.Call.Return(err) + return _c +} + +func (_c *MockVariadic_VariadicFunction_Call) RunAndReturn(run func(str string, vFunc VariadicFunction)error) *MockVariadic_VariadicFunction_Call { + _c.Call.Return(run) + return _c +} + +// NewMockVariadicReturnFunc creates a new instance of MockVariadicReturnFunc. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. +// The first argument is typically a *testing.T value. +func NewMockVariadicReturnFunc (t interface { + mock.TestingT + Cleanup(func()) +}) *MockVariadicReturnFunc { + mock := &MockVariadicReturnFunc{} + mock.Mock.Test(t) + + t.Cleanup(func() { mock.AssertExpectations(t) }) + + return mock +} + + +// MockVariadicReturnFunc is an autogenerated mock type for the VariadicReturnFunc type +type MockVariadicReturnFunc struct { + mock.Mock +} + +type MockVariadicReturnFunc_Expecter struct { + mock *mock.Mock +} + +func (_m *MockVariadicReturnFunc) EXPECT() *MockVariadicReturnFunc_Expecter { + return &MockVariadicReturnFunc_Expecter{mock: &_m.Mock} +} + + + +// SampleMethod provides a mock function for the type MockVariadicReturnFunc +func (_mock *MockVariadicReturnFunc) SampleMethod(str string) func(str string, arr []int, a ...interface{}) { + ret := _mock.Called(str) + + if len(ret) == 0 { + panic("no return value specified for SampleMethod") + } + + + var r0 func(str string, arr []int, a ...interface{}) + if returnFunc, ok := ret.Get(0).(func(string) func(str string, arr []int, a ...interface{})); ok { + r0 = returnFunc(str) + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(func(str string, arr []int, a ...interface{})) + } + } + return r0 +} + + + +// MockVariadicReturnFunc_SampleMethod_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SampleMethod' +type MockVariadicReturnFunc_SampleMethod_Call struct { + *mock.Call +} + + + +// SampleMethod is a helper method to define mock.On call +// - str +func (_e *MockVariadicReturnFunc_Expecter) SampleMethod(str interface{}, ) *MockVariadicReturnFunc_SampleMethod_Call { + return &MockVariadicReturnFunc_SampleMethod_Call{Call: _e.mock.On("SampleMethod",str, )} +} + +func (_c *MockVariadicReturnFunc_SampleMethod_Call) Run(run func(str string)) *MockVariadicReturnFunc_SampleMethod_Call { + _c.Call.Run(func(args mock.Arguments) { + run(args[0].(string),) + }) + return _c +} + +func (_c *MockVariadicReturnFunc_SampleMethod_Call) Return(fn func(str string, arr []int, a ...interface{})) *MockVariadicReturnFunc_SampleMethod_Call { + _c.Call.Return(fn) + return _c +} + +func (_c *MockVariadicReturnFunc_SampleMethod_Call) RunAndReturn(run func(str string)func(str string, arr []int, a ...interface{})) *MockVariadicReturnFunc_SampleMethod_Call { + _c.Call.Return(run) + return _c +} + + diff --git a/pkg/fixtures/mocks_moq.go b/pkg/fixtures/mocks_moq.go new file mode 100644 index 00000000..7979a019 --- /dev/null +++ b/pkg/fixtures/mocks_moq.go @@ -0,0 +1,74 @@ +// Code generated by mockery; DO NOT EDIT. +// github.com/vektra/mockery + +package test + +import ( + "sync" +) + +// Ensure, that MoqRequester does implement Requester. +// If this is not the case, regenerate this file with moq. +var _ Requester = &MoqRequester{} + +// MoqRequester is a mock implementation of Requester. +// +// func TestSomethingThatUsesRequester(t *testing.T) { +// +// // make and configure a mocked Requester +// mockedRequester := &MoqRequester{ +// GetFunc: func(path string) (string, error) { +// panic("mock out the Get method") +// }, +// } +// +// // use mockedRequester in code that requires Requester +// // and then make assertions. +// +// } +type MoqRequester struct { + // GetFunc mocks the Get method. + GetFunc func(path string) (string, error) + + // calls tracks calls to the methods. + calls struct { + // Get holds details about calls to the Get method. + Get []struct { + // Path is the path argument value. + Path string + } + } + lockGet sync.RWMutex +} + +// Get calls GetFunc. +func (mock *MoqRequester) Get(path string) (string, error) { + if mock.GetFunc == nil { + panic("MoqRequester.GetFunc: method is nil but Requester.Get was just called") + } + callInfo := struct { + Path string + }{ + Path: path, + } + mock.lockGet.Lock() + mock.calls.Get = append(mock.calls.Get, callInfo) + mock.lockGet.Unlock() + return mock.GetFunc(path) +} + +// GetCalls gets all the calls that were made to Get. +// Check the length with: +// +// len(mockedRequester.GetCalls()) +func (mock *MoqRequester) GetCalls() []struct { + Path string +} { + var calls []struct { + Path string + } + mock.lockGet.RLock() + calls = mock.calls.Get + mock.lockGet.RUnlock() + return calls +} diff --git a/pkg/fixtures/panic_err_test.go b/pkg/fixtures/panic_err_test.go index 3525d6f5..43966a73 100644 --- a/pkg/fixtures/panic_err_test.go +++ b/pkg/fixtures/panic_err_test.go @@ -1,16 +1,14 @@ -package test_test +package test import ( "testing" "github.com/stretchr/testify/assert" "github.com/stretchr/testify/require" - - mocks "github.com/vektra/mockery/v3/mocks/github.com/vektra/mockery/v3/pkg/fixtures" ) func TestPanicOnNoReturnValue(t *testing.T) { - m := mocks.NewPanicOnNoReturnValue(t) + m := NewMockPanicOnNoReturnValue(t) m.EXPECT().DoSomething() var panicOccurred bool diff --git a/pkg/fixtures/requester_test.go b/pkg/fixtures/requester_test.go new file mode 100644 index 00000000..4cfdbbff --- /dev/null +++ b/pkg/fixtures/requester_test.go @@ -0,0 +1,58 @@ +package test + +import ( + "fmt" + "testing" + + "github.com/stretchr/testify/assert" + mock "github.com/stretchr/testify/mock" +) + +func TestRequesterMock(t *testing.T) { + m := NewMockRequester(t) + m.EXPECT().Get("foo").Return("bar", nil).Once() + retString, err := m.Get("foo") + assert.NoError(t, err) + assert.Equal(t, retString, "bar") +} + +func TestRequesterMockRunAndReturn(t *testing.T) { + m := NewMockRequester(t) + m.EXPECT().Get(mock.Anything).RunAndReturn(func(path string) (string, error) { + return path + " world", nil + }) + retString, err := m.Get("hello") + assert.NoError(t, err) + assert.Equal(t, retString, "hello world") +} + +func TestRequesterMockRun(t *testing.T) { + m := NewMockRequester(t) + m.EXPECT().Get(mock.Anything).Return("", nil) + m.EXPECT().Get(mock.Anything).Run(func(path string) { + fmt.Printf("Side effect! Argument is: %s", path) + }) + retString, err := m.Get("hello") + assert.NoError(t, err) + assert.Equal(t, retString, "") +} + +func TestRequesterMockTestifyEmbed(t *testing.T) { + m := NewMockRequester(t) + m.EXPECT().Get(mock.Anything).Return("", nil).Twice() + m.Get("hello") + m.Get("world") + assert.Equal(t, len(m.Mock.Calls), 2) +} + +func TestRequesterMoq(t *testing.T) { + m := &MoqRequester{ + GetFunc: func(path string) (string, error) { + fmt.Printf("Go path: %s\n", path) + return path + "/foo", nil + }, + } + result, err := m.Get("/path") + assert.NoError(t, err) + assert.Equal(t, "/path/foo", result) +}