test

package
v3.0.0-alpha.10 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Jan 2, 2025 License: BSD-3-Clause Imports: 11 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type A 

type A interface {
	Call() (B, error)
}

type AsyncProducer 

type AsyncProducer interface {
	Input() chan<- bool
	Output() <-chan bool
	Whatever() chan bool
}

type B 

type B struct{}

type Blank 

type Blank interface {
	Create(x interface{}) error
}

type C 

type C int

type ConsulLock 

type ConsulLock interface {
	Lock(<-chan struct{}) (<-chan struct{}, error)
	Unlock() error
}

type EmbeddedGet 

type EmbeddedGet[T constraints.Signed] interface{ GetGeneric[T] }

type Err 

type Err struct {
	// contains filtered or unexported fields
}

func (*Err) Code 

func (e *Err) Code() uint64

func (*Err) Error 

func (e *Err) Error() string

type Example 

type Example interface {
	A() http.Flusher
	B(fixtureshttp string) my_http.MyStruct
	C(fixtureshttp string) number_dir_http.MyStruct
}

Example is an example

type Expecter 

type Expecter interface {
	NoArg() string
	NoReturn(str string)
	ManyArgsReturns(str string, i int) (strs []string, err error)
	Variadic(ints ...int) error
	VariadicMany(i int, a string, intfs ...interface{}) error
}

type Fooer 

type Fooer interface {
	Foo(f func(x string) string) error
	Bar(f func([]int))
	Baz(path string) func(x string) string
}

type FuncArgsCollision 

type FuncArgsCollision interface {
	Foo(ret interface{}) error
}

type GenericInterface 

type GenericInterface[M any] interface {
	Func(arg *M) int
}

type GenericType 

type GenericType[T any, S GetInt] struct {
	Any  T
	Some []S
}

type GetGeneric 

type GetGeneric[T constraints.Integer] interface{ Get() T }

type GetInt 

type GetInt interface{ Get() int }

type HasConflictingNestedImports 

type HasConflictingNestedImports interface {
	RequesterNS
	Z() http.MyStruct
}

type ImportsSameAsPackage 

type ImportsSameAsPackage interface {
	A() test.B
	B() KeyManager
	C(C)
}

type InstantiatedGenericInterface 

type InstantiatedGenericInterface GenericInterface[float32]

type Issue766 

type Issue766 interface {
	FetchData(
		fetchFunc func(x ...int) ([]int, error),
	) ([]int, error)
}

type KeyManager 

type KeyManager interface {
	GetKey(string, uint16) ([]byte, *Err)
}

type MapFunc 

type MapFunc interface {
	Get(m map[string]func(string) string) error
}

type MapToInterface 

type MapToInterface interface {
	Foo(arg1 ...map[string]interface{})
}

type MockA 

type MockA struct {
	mock.Mock
}

MockA is an autogenerated mock type for the A type

func NewMockA 

func NewMockA(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockA

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 (*MockA) Call 

func (_mock *MockA) Call() (B, error)

Call provides a mock function for the type MockA

func (*MockA) EXPECT 

func (_m *MockA) EXPECT() *MockA_Expecter

type MockA_Call_Call 

type MockA_Call_Call struct {
	*mock.Call
}

MockA_Call_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Call'

func (*MockA_Call_Call) Return 

func (_c *MockA_Call_Call) Return(b B, err error) *MockA_Call_Call

func (*MockA_Call_Call) Run 

func (_c *MockA_Call_Call) Run(run func()) *MockA_Call_Call

func (*MockA_Call_Call) RunAndReturn 

func (_c *MockA_Call_Call) RunAndReturn(run func() (B, error)) *MockA_Call_Call

type MockA_Expecter 

type MockA_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockA_Expecter) Call 

func (_e *MockA_Expecter) Call() *MockA_Call_Call

Call is a helper method to define mock.On call

type MockAsyncProducer 

type MockAsyncProducer struct {
	mock.Mock
}

MockAsyncProducer is an autogenerated mock type for the AsyncProducer type

func NewMockAsyncProducer 

func NewMockAsyncProducer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockAsyncProducer

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 (*MockAsyncProducer) EXPECT 

func (_m *MockAsyncProducer) EXPECT() *MockAsyncProducer_Expecter

func (*MockAsyncProducer) Input 

func (_mock *MockAsyncProducer) Input() chan<- bool

Input provides a mock function for the type MockAsyncProducer

func (*MockAsyncProducer) Output 

func (_mock *MockAsyncProducer) Output() <-chan bool

Output provides a mock function for the type MockAsyncProducer

func (*MockAsyncProducer) Whatever 

func (_mock *MockAsyncProducer) Whatever() chan bool

Whatever provides a mock function for the type MockAsyncProducer

type MockAsyncProducer_Expecter 

type MockAsyncProducer_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockAsyncProducer_Expecter) Input 

func (_e *MockAsyncProducer_Expecter) Input() *MockAsyncProducer_Input_Call

Input is a helper method to define mock.On call

func (*MockAsyncProducer_Expecter) Output 

func (_e *MockAsyncProducer_Expecter) Output() *MockAsyncProducer_Output_Call

Output is a helper method to define mock.On call

func (*MockAsyncProducer_Expecter) Whatever 

func (_e *MockAsyncProducer_Expecter) Whatever() *MockAsyncProducer_Whatever_Call

Whatever is a helper method to define mock.On call

type MockAsyncProducer_Input_Call 

type MockAsyncProducer_Input_Call struct {
	*mock.Call
}

MockAsyncProducer_Input_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Input'

func (*MockAsyncProducer_Input_Call) Return 

func (_c *MockAsyncProducer_Input_Call) Return(boolCh chan<- bool) *MockAsyncProducer_Input_Call

func (*MockAsyncProducer_Input_Call) Run 

func (_c *MockAsyncProducer_Input_Call) Run(run func()) *MockAsyncProducer_Input_Call

func (*MockAsyncProducer_Input_Call) RunAndReturn 

func (_c *MockAsyncProducer_Input_Call) RunAndReturn(run func() chan<- bool) *MockAsyncProducer_Input_Call

type MockAsyncProducer_Output_Call 

type MockAsyncProducer_Output_Call struct {
	*mock.Call
}

MockAsyncProducer_Output_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Output'

func (*MockAsyncProducer_Output_Call) Return 

func (_c *MockAsyncProducer_Output_Call) Return(boolCh <-chan bool) *MockAsyncProducer_Output_Call

func (*MockAsyncProducer_Output_Call) Run 

func (_c *MockAsyncProducer_Output_Call) Run(run func()) *MockAsyncProducer_Output_Call

func (*MockAsyncProducer_Output_Call) RunAndReturn 

func (_c *MockAsyncProducer_Output_Call) RunAndReturn(run func() <-chan bool) *MockAsyncProducer_Output_Call

type MockAsyncProducer_Whatever_Call 

type MockAsyncProducer_Whatever_Call struct {
	*mock.Call
}

MockAsyncProducer_Whatever_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Whatever'

func (*MockAsyncProducer_Whatever_Call) Return 

func (_c *MockAsyncProducer_Whatever_Call) Return(boolCh chan bool) *MockAsyncProducer_Whatever_Call

func (*MockAsyncProducer_Whatever_Call) Run 

func (_c *MockAsyncProducer_Whatever_Call) Run(run func()) *MockAsyncProducer_Whatever_Call

func (*MockAsyncProducer_Whatever_Call) RunAndReturn 

func (_c *MockAsyncProducer_Whatever_Call) RunAndReturn(run func() chan bool) *MockAsyncProducer_Whatever_Call

type MockBlank 

type MockBlank struct {
	mock.Mock
}

MockBlank is an autogenerated mock type for the Blank type

func NewMockBlank 

func NewMockBlank(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockBlank

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 (*MockBlank) Create 

func (_mock *MockBlank) Create(x interface{}) error

Create provides a mock function for the type MockBlank

func (*MockBlank) EXPECT 

func (_m *MockBlank) EXPECT() *MockBlank_Expecter

type MockBlank_Create_Call 

type MockBlank_Create_Call struct {
	*mock.Call
}

MockBlank_Create_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Create'

func (*MockBlank_Create_Call) Return 

func (_c *MockBlank_Create_Call) Return(err error) *MockBlank_Create_Call

func (*MockBlank_Create_Call) Run 

func (_c *MockBlank_Create_Call) Run(run func(x interface{})) *MockBlank_Create_Call

func (*MockBlank_Create_Call) RunAndReturn 

func (_c *MockBlank_Create_Call) RunAndReturn(run func(x interface{}) error) *MockBlank_Create_Call

type MockBlank_Expecter 

type MockBlank_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockBlank_Expecter) Create 

func (_e *MockBlank_Expecter) Create(x interface{}) *MockBlank_Create_Call

Create is a helper method to define mock.On call

  • x

type MockConsulLock 

type MockConsulLock struct {
	mock.Mock
}

MockConsulLock is an autogenerated mock type for the ConsulLock type

func NewMockConsulLock 

func NewMockConsulLock(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockConsulLock

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 (*MockConsulLock) EXPECT 

func (_m *MockConsulLock) EXPECT() *MockConsulLock_Expecter

func (*MockConsulLock) Lock 

func (_mock *MockConsulLock) Lock(valCh <-chan struct{}) (<-chan struct{}, error)

Lock provides a mock function for the type MockConsulLock

func (*MockConsulLock) Unlock 

func (_mock *MockConsulLock) Unlock() error

Unlock provides a mock function for the type MockConsulLock

type MockConsulLock_Expecter 

type MockConsulLock_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockConsulLock_Expecter) Lock 

func (_e *MockConsulLock_Expecter) Lock(valCh interface{}) *MockConsulLock_Lock_Call

Lock is a helper method to define mock.On call

  • valCh

func (*MockConsulLock_Expecter) Unlock 

func (_e *MockConsulLock_Expecter) Unlock() *MockConsulLock_Unlock_Call

Unlock is a helper method to define mock.On call

type MockConsulLock_Lock_Call 

type MockConsulLock_Lock_Call struct {
	*mock.Call
}

MockConsulLock_Lock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Lock'

func (*MockConsulLock_Lock_Call) Return 

func (_c *MockConsulLock_Lock_Call) Return(valCh1 <-chan struct{}, err error) *MockConsulLock_Lock_Call

func (*MockConsulLock_Lock_Call) Run 

func (_c *MockConsulLock_Lock_Call) Run(run func(valCh <-chan struct{})) *MockConsulLock_Lock_Call

func (*MockConsulLock_Lock_Call) RunAndReturn 

func (_c *MockConsulLock_Lock_Call) RunAndReturn(run func(valCh <-chan struct{}) (<-chan struct{}, error)) *MockConsulLock_Lock_Call

type MockConsulLock_Unlock_Call 

type MockConsulLock_Unlock_Call struct {
	*mock.Call
}

MockConsulLock_Unlock_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unlock'

func (*MockConsulLock_Unlock_Call) Return 

func (_c *MockConsulLock_Unlock_Call) Return(err error) *MockConsulLock_Unlock_Call

func (*MockConsulLock_Unlock_Call) Run 

func (_c *MockConsulLock_Unlock_Call) Run(run func()) *MockConsulLock_Unlock_Call

func (*MockConsulLock_Unlock_Call) RunAndReturn 

func (_c *MockConsulLock_Unlock_Call) RunAndReturn(run func() error) *MockConsulLock_Unlock_Call

type MockEmbeddedGet 

type MockEmbeddedGet[T constraints.Signed] struct {
	mock.Mock
}

MockEmbeddedGet is an autogenerated mock type for the EmbeddedGet type

func NewMockEmbeddedGet 

func NewMockEmbeddedGet[T constraints.Signed](t interface {
	mock.TestingT
	Cleanup(func())
}) *MockEmbeddedGet[T]

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 (*MockEmbeddedGet[T]) EXPECT 

func (_m *MockEmbeddedGet[T]) EXPECT() *MockEmbeddedGet_Expecter[T]

func (*MockEmbeddedGet[T]) Get 

func (_mock *MockEmbeddedGet[T]) Get() T

Get provides a mock function for the type MockEmbeddedGet

type MockEmbeddedGet_Expecter 

type MockEmbeddedGet_Expecter[T constraints.Signed] struct {
	// contains filtered or unexported fields
}

func (*MockEmbeddedGet_Expecter[T]) Get 

func (_e *MockEmbeddedGet_Expecter[T]) Get() *MockEmbeddedGet_Get_Call[T]

Get is a helper method to define mock.On call

type MockEmbeddedGet_Get_Call 

type MockEmbeddedGet_Get_Call[T constraints.Signed] struct {
	*mock.Call
}

MockEmbeddedGet_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockEmbeddedGet_Get_Call[T]) Return 

func (_c *MockEmbeddedGet_Get_Call[T]) Return(v T) *MockEmbeddedGet_Get_Call[T]

func (*MockEmbeddedGet_Get_Call[T]) Run 

func (_c *MockEmbeddedGet_Get_Call[T]) Run(run func()) *MockEmbeddedGet_Get_Call[T]

func (*MockEmbeddedGet_Get_Call[T]) RunAndReturn 

func (_c *MockEmbeddedGet_Get_Call[T]) RunAndReturn(run func() T) *MockEmbeddedGet_Get_Call[T]

type MockExample 

type MockExample struct {
	mock.Mock
}

MockExample is an autogenerated mock type for the Example type

func NewMockExample 

func NewMockExample(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockExample

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 (*MockExample) A 

func (_mock *MockExample) A() http.Flusher

A provides a mock function for the type MockExample

func (*MockExample) B 

func (_mock *MockExample) B(fixtureshttp string) http0.MyStruct

B provides a mock function for the type MockExample

func (*MockExample) C 

func (_mock *MockExample) C(fixtureshttp string) http1.MyStruct

C provides a mock function for the type MockExample

func (*MockExample) EXPECT 

func (_m *MockExample) EXPECT() *MockExample_Expecter

type MockExample_A_Call 

type MockExample_A_Call struct {
	*mock.Call
}

MockExample_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A'

func (*MockExample_A_Call) Return 

func (_c *MockExample_A_Call) Return(flusher http.Flusher) *MockExample_A_Call

func (*MockExample_A_Call) Run 

func (_c *MockExample_A_Call) Run(run func()) *MockExample_A_Call

func (*MockExample_A_Call) RunAndReturn 

func (_c *MockExample_A_Call) RunAndReturn(run func() http.Flusher) *MockExample_A_Call

type MockExample_B_Call 

type MockExample_B_Call struct {
	*mock.Call
}

MockExample_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B'

func (*MockExample_B_Call) Return 

func (_c *MockExample_B_Call) Return(myStruct http0.MyStruct) *MockExample_B_Call

func (*MockExample_B_Call) Run 

func (_c *MockExample_B_Call) Run(run func(fixtureshttp string)) *MockExample_B_Call

func (*MockExample_B_Call) RunAndReturn 

func (_c *MockExample_B_Call) RunAndReturn(run func(fixtureshttp string) http0.MyStruct) *MockExample_B_Call

type MockExample_C_Call 

type MockExample_C_Call struct {
	*mock.Call
}

MockExample_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C'

func (*MockExample_C_Call) Return 

func (_c *MockExample_C_Call) Return(myStruct http1.MyStruct) *MockExample_C_Call

func (*MockExample_C_Call) Run 

func (_c *MockExample_C_Call) Run(run func(fixtureshttp string)) *MockExample_C_Call

func (*MockExample_C_Call) RunAndReturn 

func (_c *MockExample_C_Call) RunAndReturn(run func(fixtureshttp string) http1.MyStruct) *MockExample_C_Call

type MockExample_Expecter 

type MockExample_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockExample_Expecter) A 

func (_e *MockExample_Expecter) A() *MockExample_A_Call

A is a helper method to define mock.On call

func (*MockExample_Expecter) B 

func (_e *MockExample_Expecter) B(fixtureshttp interface{}) *MockExample_B_Call

B is a helper method to define mock.On call

  • fixtureshttp

func (*MockExample_Expecter) C 

func (_e *MockExample_Expecter) C(fixtureshttp interface{}) *MockExample_C_Call

C is a helper method to define mock.On call

  • fixtureshttp

type MockExpecter 

type MockExpecter struct {
	mock.Mock
}

MockExpecter is an autogenerated mock type for the Expecter type

func NewMockExpecter 

func NewMockExpecter(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockExpecter

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 (*MockExpecter) EXPECT 

func (_m *MockExpecter) EXPECT() *MockExpecter_Expecter

func (*MockExpecter) ManyArgsReturns 

func (_mock *MockExpecter) ManyArgsReturns(str string, i int) ([]string, error)

ManyArgsReturns provides a mock function for the type MockExpecter

func (*MockExpecter) NoArg 

func (_mock *MockExpecter) NoArg() string

NoArg provides a mock function for the type MockExpecter

func (*MockExpecter) NoReturn 

func (_mock *MockExpecter) NoReturn(str string)

NoReturn provides a mock function for the type MockExpecter

func (*MockExpecter) Variadic 

func (_mock *MockExpecter) Variadic(ints ...int) error

Variadic provides a mock function for the type MockExpecter

func (*MockExpecter) VariadicMany 

func (_mock *MockExpecter) VariadicMany(i int, a string, intfs ...interface{}) error

VariadicMany provides a mock function for the type MockExpecter

type MockExpecterAndRolledVariadic 

type MockExpecterAndRolledVariadic struct {
	mock.Mock
}

MockExpecterAndRolledVariadic is an autogenerated mock type for the Expecter type

func NewMockExpecterAndRolledVariadic 

func NewMockExpecterAndRolledVariadic(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockExpecterAndRolledVariadic

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 (*MockExpecterAndRolledVariadic) EXPECT 

func (_m *MockExpecterAndRolledVariadic) EXPECT() *MockExpecterAndRolledVariadic_Expecter

func (*MockExpecterAndRolledVariadic) ManyArgsReturns 

func (_mock *MockExpecterAndRolledVariadic) ManyArgsReturns(str string, i int) ([]string, error)

ManyArgsReturns provides a mock function for the type MockExpecterAndRolledVariadic

func (*MockExpecterAndRolledVariadic) NoArg 

func (_mock *MockExpecterAndRolledVariadic) NoArg() string

NoArg provides a mock function for the type MockExpecterAndRolledVariadic

func (*MockExpecterAndRolledVariadic) NoReturn 

func (_mock *MockExpecterAndRolledVariadic) NoReturn(str string)

NoReturn provides a mock function for the type MockExpecterAndRolledVariadic

func (*MockExpecterAndRolledVariadic) Variadic 

func (_mock *MockExpecterAndRolledVariadic) Variadic(ints ...int) error

Variadic provides a mock function for the type MockExpecterAndRolledVariadic

func (*MockExpecterAndRolledVariadic) VariadicMany 

func (_mock *MockExpecterAndRolledVariadic) VariadicMany(i int, a string, intfs ...interface{}) error

VariadicMany provides a mock function for the type MockExpecterAndRolledVariadic

type MockExpecterAndRolledVariadic_Expecter 

type MockExpecterAndRolledVariadic_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockExpecterAndRolledVariadic_Expecter) ManyArgsReturns 

func (_e *MockExpecterAndRolledVariadic_Expecter) ManyArgsReturns(str interface{}, i interface{}) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call

ManyArgsReturns is a helper method to define mock.On call

  • str
  • i

func (*MockExpecterAndRolledVariadic_Expecter) NoArg 

func (_e *MockExpecterAndRolledVariadic_Expecter) NoArg() *MockExpecterAndRolledVariadic_NoArg_Call

NoArg is a helper method to define mock.On call

func (*MockExpecterAndRolledVariadic_Expecter) NoReturn 

func (_e *MockExpecterAndRolledVariadic_Expecter) NoReturn(str interface{}) *MockExpecterAndRolledVariadic_NoReturn_Call

NoReturn is a helper method to define mock.On call

  • str

func (*MockExpecterAndRolledVariadic_Expecter) Variadic 

func (_e *MockExpecterAndRolledVariadic_Expecter) Variadic(ints ...interface{}) *MockExpecterAndRolledVariadic_Variadic_Call

Variadic is a helper method to define mock.On call

  • ints

func (*MockExpecterAndRolledVariadic_Expecter) VariadicMany 

func (_e *MockExpecterAndRolledVariadic_Expecter) VariadicMany(i interface{}, a interface{}, intfs ...interface{}) *MockExpecterAndRolledVariadic_VariadicMany_Call

VariadicMany is a helper method to define mock.On call

  • i
  • a
  • intfs

type MockExpecterAndRolledVariadic_ManyArgsReturns_Call 

type MockExpecterAndRolledVariadic_ManyArgsReturns_Call struct {
	*mock.Call
}

MockExpecterAndRolledVariadic_ManyArgsReturns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManyArgsReturns'

func (*MockExpecterAndRolledVariadic_ManyArgsReturns_Call) Return 

func (_c *MockExpecterAndRolledVariadic_ManyArgsReturns_Call) Return(strs []string, err error) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call

func (*MockExpecterAndRolledVariadic_ManyArgsReturns_Call) Run 

func (_c *MockExpecterAndRolledVariadic_ManyArgsReturns_Call) Run(run func(str string, i int)) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call

func (*MockExpecterAndRolledVariadic_ManyArgsReturns_Call) RunAndReturn 

func (_c *MockExpecterAndRolledVariadic_ManyArgsReturns_Call) RunAndReturn(run func(str string, i int) ([]string, error)) *MockExpecterAndRolledVariadic_ManyArgsReturns_Call

type MockExpecterAndRolledVariadic_NoArg_Call 

type MockExpecterAndRolledVariadic_NoArg_Call struct {
	*mock.Call
}

MockExpecterAndRolledVariadic_NoArg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoArg'

func (*MockExpecterAndRolledVariadic_NoArg_Call) Return 

func (_c *MockExpecterAndRolledVariadic_NoArg_Call) Return(s string) *MockExpecterAndRolledVariadic_NoArg_Call

func (*MockExpecterAndRolledVariadic_NoArg_Call) Run 

func (_c *MockExpecterAndRolledVariadic_NoArg_Call) Run(run func()) *MockExpecterAndRolledVariadic_NoArg_Call

func (*MockExpecterAndRolledVariadic_NoArg_Call) RunAndReturn 

func (_c *MockExpecterAndRolledVariadic_NoArg_Call) RunAndReturn(run func() string) *MockExpecterAndRolledVariadic_NoArg_Call

type MockExpecterAndRolledVariadic_NoReturn_Call 

type MockExpecterAndRolledVariadic_NoReturn_Call struct {
	*mock.Call
}

MockExpecterAndRolledVariadic_NoReturn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoReturn'

func (*MockExpecterAndRolledVariadic_NoReturn_Call) Return 

func (_c *MockExpecterAndRolledVariadic_NoReturn_Call) Return() *MockExpecterAndRolledVariadic_NoReturn_Call

func (*MockExpecterAndRolledVariadic_NoReturn_Call) Run 

func (_c *MockExpecterAndRolledVariadic_NoReturn_Call) Run(run func(str string)) *MockExpecterAndRolledVariadic_NoReturn_Call

func (*MockExpecterAndRolledVariadic_NoReturn_Call) RunAndReturn 

func (_c *MockExpecterAndRolledVariadic_NoReturn_Call) RunAndReturn(run func(str string)) *MockExpecterAndRolledVariadic_NoReturn_Call

type MockExpecterAndRolledVariadic_VariadicMany_Call 

type MockExpecterAndRolledVariadic_VariadicMany_Call struct {
	*mock.Call
}

MockExpecterAndRolledVariadic_VariadicMany_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicMany'

func (*MockExpecterAndRolledVariadic_VariadicMany_Call) Return 

func (_c *MockExpecterAndRolledVariadic_VariadicMany_Call) Return(err error) *MockExpecterAndRolledVariadic_VariadicMany_Call

func (*MockExpecterAndRolledVariadic_VariadicMany_Call) Run 

func (_c *MockExpecterAndRolledVariadic_VariadicMany_Call) Run(run func(i int, a string, intfs ...interface{})) *MockExpecterAndRolledVariadic_VariadicMany_Call

func (*MockExpecterAndRolledVariadic_VariadicMany_Call) RunAndReturn 

func (_c *MockExpecterAndRolledVariadic_VariadicMany_Call) RunAndReturn(run func(i int, a string, intfs ...interface{}) error) *MockExpecterAndRolledVariadic_VariadicMany_Call

type MockExpecterAndRolledVariadic_Variadic_Call 

type MockExpecterAndRolledVariadic_Variadic_Call struct {
	*mock.Call
}

MockExpecterAndRolledVariadic_Variadic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Variadic'

func (*MockExpecterAndRolledVariadic_Variadic_Call) Return 

func (_c *MockExpecterAndRolledVariadic_Variadic_Call) Return(err error) *MockExpecterAndRolledVariadic_Variadic_Call

func (*MockExpecterAndRolledVariadic_Variadic_Call) Run 

func (_c *MockExpecterAndRolledVariadic_Variadic_Call) Run(run func(ints ...int)) *MockExpecterAndRolledVariadic_Variadic_Call

func (*MockExpecterAndRolledVariadic_Variadic_Call) RunAndReturn 

func (_c *MockExpecterAndRolledVariadic_Variadic_Call) RunAndReturn(run func(ints ...int) error) *MockExpecterAndRolledVariadic_Variadic_Call

type MockExpecter_Expecter 

type MockExpecter_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockExpecter_Expecter) ManyArgsReturns 

func (_e *MockExpecter_Expecter) ManyArgsReturns(str interface{}, i interface{}) *MockExpecter_ManyArgsReturns_Call

ManyArgsReturns is a helper method to define mock.On call

  • str
  • i

func (*MockExpecter_Expecter) NoArg 

func (_e *MockExpecter_Expecter) NoArg() *MockExpecter_NoArg_Call

NoArg is a helper method to define mock.On call

func (*MockExpecter_Expecter) NoReturn 

func (_e *MockExpecter_Expecter) NoReturn(str interface{}) *MockExpecter_NoReturn_Call

NoReturn is a helper method to define mock.On call

  • str

func (*MockExpecter_Expecter) Variadic 

func (_e *MockExpecter_Expecter) Variadic(ints ...interface{}) *MockExpecter_Variadic_Call

Variadic is a helper method to define mock.On call

  • ints

func (*MockExpecter_Expecter) VariadicMany 

func (_e *MockExpecter_Expecter) VariadicMany(i interface{}, a interface{}, intfs ...interface{}) *MockExpecter_VariadicMany_Call

VariadicMany is a helper method to define mock.On call

  • i
  • a
  • intfs

type MockExpecter_ManyArgsReturns_Call 

type MockExpecter_ManyArgsReturns_Call struct {
	*mock.Call
}

MockExpecter_ManyArgsReturns_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManyArgsReturns'

func (*MockExpecter_ManyArgsReturns_Call) Return 

func (_c *MockExpecter_ManyArgsReturns_Call) Return(strs []string, err error) *MockExpecter_ManyArgsReturns_Call

func (*MockExpecter_ManyArgsReturns_Call) Run 

func (_c *MockExpecter_ManyArgsReturns_Call) Run(run func(str string, i int)) *MockExpecter_ManyArgsReturns_Call

func (*MockExpecter_ManyArgsReturns_Call) RunAndReturn 

func (_c *MockExpecter_ManyArgsReturns_Call) RunAndReturn(run func(str string, i int) ([]string, error)) *MockExpecter_ManyArgsReturns_Call

type MockExpecter_NoArg_Call 

type MockExpecter_NoArg_Call struct {
	*mock.Call
}

MockExpecter_NoArg_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoArg'

func (*MockExpecter_NoArg_Call) Return 

func (_c *MockExpecter_NoArg_Call) Return(s string) *MockExpecter_NoArg_Call

func (*MockExpecter_NoArg_Call) Run 

func (_c *MockExpecter_NoArg_Call) Run(run func()) *MockExpecter_NoArg_Call

func (*MockExpecter_NoArg_Call) RunAndReturn 

func (_c *MockExpecter_NoArg_Call) RunAndReturn(run func() string) *MockExpecter_NoArg_Call

type MockExpecter_NoReturn_Call 

type MockExpecter_NoReturn_Call struct {
	*mock.Call
}

MockExpecter_NoReturn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NoReturn'

func (*MockExpecter_NoReturn_Call) Return 

func (_c *MockExpecter_NoReturn_Call) Return() *MockExpecter_NoReturn_Call

func (*MockExpecter_NoReturn_Call) Run 

func (_c *MockExpecter_NoReturn_Call) Run(run func(str string)) *MockExpecter_NoReturn_Call

func (*MockExpecter_NoReturn_Call) RunAndReturn 

func (_c *MockExpecter_NoReturn_Call) RunAndReturn(run func(str string)) *MockExpecter_NoReturn_Call

type MockExpecter_VariadicMany_Call 

type MockExpecter_VariadicMany_Call struct {
	*mock.Call
}

MockExpecter_VariadicMany_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicMany'

func (*MockExpecter_VariadicMany_Call) Return 

func (_c *MockExpecter_VariadicMany_Call) Return(err error) *MockExpecter_VariadicMany_Call

func (*MockExpecter_VariadicMany_Call) Run 

func (_c *MockExpecter_VariadicMany_Call) Run(run func(i int, a string, intfs ...interface{})) *MockExpecter_VariadicMany_Call

func (*MockExpecter_VariadicMany_Call) RunAndReturn 

func (_c *MockExpecter_VariadicMany_Call) RunAndReturn(run func(i int, a string, intfs ...interface{}) error) *MockExpecter_VariadicMany_Call

type MockExpecter_Variadic_Call 

type MockExpecter_Variadic_Call struct {
	*mock.Call
}

MockExpecter_Variadic_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Variadic'

func (*MockExpecter_Variadic_Call) Return 

func (_c *MockExpecter_Variadic_Call) Return(err error) *MockExpecter_Variadic_Call

func (*MockExpecter_Variadic_Call) Run 

func (_c *MockExpecter_Variadic_Call) Run(run func(ints ...int)) *MockExpecter_Variadic_Call

func (*MockExpecter_Variadic_Call) RunAndReturn 

func (_c *MockExpecter_Variadic_Call) RunAndReturn(run func(ints ...int) error) *MockExpecter_Variadic_Call

type MockFooer 

type MockFooer struct {
	mock.Mock
}

MockFooer is an autogenerated mock type for the Fooer type

func NewMockFooer 

func NewMockFooer(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFooer

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 (*MockFooer) Bar 

func (_mock *MockFooer) Bar(f func([]int))

Bar provides a mock function for the type MockFooer

func (*MockFooer) Baz 

func (_mock *MockFooer) Baz(path string) func(x string) string

Baz provides a mock function for the type MockFooer

func (*MockFooer) EXPECT 

func (_m *MockFooer) EXPECT() *MockFooer_Expecter

func (*MockFooer) Foo 

func (_mock *MockFooer) Foo(f func(x string) string) error

Foo provides a mock function for the type MockFooer

type MockFooer_Bar_Call 

type MockFooer_Bar_Call struct {
	*mock.Call
}

MockFooer_Bar_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bar'

func (*MockFooer_Bar_Call) Return 

func (_c *MockFooer_Bar_Call) Return() *MockFooer_Bar_Call

func (*MockFooer_Bar_Call) Run 

func (_c *MockFooer_Bar_Call) Run(run func(f func([]int))) *MockFooer_Bar_Call

func (*MockFooer_Bar_Call) RunAndReturn 

func (_c *MockFooer_Bar_Call) RunAndReturn(run func(f func([]int))) *MockFooer_Bar_Call

type MockFooer_Baz_Call 

type MockFooer_Baz_Call struct {
	*mock.Call
}

MockFooer_Baz_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Baz'

func (*MockFooer_Baz_Call) Return 

func (_c *MockFooer_Baz_Call) Return(fn func(x string) string) *MockFooer_Baz_Call

func (*MockFooer_Baz_Call) Run 

func (_c *MockFooer_Baz_Call) Run(run func(path string)) *MockFooer_Baz_Call

func (*MockFooer_Baz_Call) RunAndReturn 

func (_c *MockFooer_Baz_Call) RunAndReturn(run func(path string) func(x string) string) *MockFooer_Baz_Call

type MockFooer_Expecter 

type MockFooer_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockFooer_Expecter) Bar 

func (_e *MockFooer_Expecter) Bar(f interface{}) *MockFooer_Bar_Call

Bar is a helper method to define mock.On call

  • f

func (*MockFooer_Expecter) Baz 

func (_e *MockFooer_Expecter) Baz(path interface{}) *MockFooer_Baz_Call

Baz is a helper method to define mock.On call

  • path

func (*MockFooer_Expecter) Foo 

func (_e *MockFooer_Expecter) Foo(f interface{}) *MockFooer_Foo_Call

Foo is a helper method to define mock.On call

  • f

type MockFooer_Foo_Call 

type MockFooer_Foo_Call struct {
	*mock.Call
}

MockFooer_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'

func (*MockFooer_Foo_Call) Return 

func (_c *MockFooer_Foo_Call) Return(err error) *MockFooer_Foo_Call

func (*MockFooer_Foo_Call) Run 

func (_c *MockFooer_Foo_Call) Run(run func(f func(x string) string)) *MockFooer_Foo_Call

func (*MockFooer_Foo_Call) RunAndReturn 

func (_c *MockFooer_Foo_Call) RunAndReturn(run func(f func(x string) string) error) *MockFooer_Foo_Call

type MockFuncArgsCollision 

type MockFuncArgsCollision struct {
	mock.Mock
}

MockFuncArgsCollision is an autogenerated mock type for the FuncArgsCollision type

func NewMockFuncArgsCollision 

func NewMockFuncArgsCollision(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockFuncArgsCollision

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 (*MockFuncArgsCollision) EXPECT 

func (_m *MockFuncArgsCollision) EXPECT() *MockFuncArgsCollision_Expecter

func (*MockFuncArgsCollision) Foo 

func (_mock *MockFuncArgsCollision) Foo(ret interface{}) error

Foo provides a mock function for the type MockFuncArgsCollision

type MockFuncArgsCollision_Expecter 

type MockFuncArgsCollision_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockFuncArgsCollision_Expecter) Foo 

func (_e *MockFuncArgsCollision_Expecter) Foo(ret interface{}) *MockFuncArgsCollision_Foo_Call

Foo is a helper method to define mock.On call

  • ret

type MockFuncArgsCollision_Foo_Call 

type MockFuncArgsCollision_Foo_Call struct {
	*mock.Call
}

MockFuncArgsCollision_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'

func (*MockFuncArgsCollision_Foo_Call) Return 

func (_c *MockFuncArgsCollision_Foo_Call) Return(err error) *MockFuncArgsCollision_Foo_Call

func (*MockFuncArgsCollision_Foo_Call) Run 

func (_c *MockFuncArgsCollision_Foo_Call) Run(run func(ret interface{})) *MockFuncArgsCollision_Foo_Call

func (*MockFuncArgsCollision_Foo_Call) RunAndReturn 

func (_c *MockFuncArgsCollision_Foo_Call) RunAndReturn(run func(ret interface{}) error) *MockFuncArgsCollision_Foo_Call

type MockGenericInterface 

type MockGenericInterface[M any] struct {
	mock.Mock
}

MockGenericInterface is an autogenerated mock type for the GenericInterface type

func NewMockGenericInterface 

func NewMockGenericInterface[M any](t interface {
	mock.TestingT
	Cleanup(func())
}) *MockGenericInterface[M]

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 (*MockGenericInterface[M]) EXPECT 

func (_m *MockGenericInterface[M]) EXPECT() *MockGenericInterface_Expecter[M]

func (*MockGenericInterface[M]) Func 

func (_mock *MockGenericInterface[M]) Func(arg *M) int

Func provides a mock function for the type MockGenericInterface

type MockGenericInterface_Expecter 

type MockGenericInterface_Expecter[M any] struct {
	// contains filtered or unexported fields
}

func (*MockGenericInterface_Expecter[M]) Func 

func (_e *MockGenericInterface_Expecter[M]) Func(arg interface{}) *MockGenericInterface_Func_Call[M]

Func is a helper method to define mock.On call

  • arg

type MockGenericInterface_Func_Call 

type MockGenericInterface_Func_Call[M any] struct {
	*mock.Call
}

MockGenericInterface_Func_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Func'

func (*MockGenericInterface_Func_Call[M]) Return 

func (_c *MockGenericInterface_Func_Call[M]) Return(n int) *MockGenericInterface_Func_Call[M]

func (*MockGenericInterface_Func_Call[M]) Run 

func (_c *MockGenericInterface_Func_Call[M]) Run(run func(arg *M)) *MockGenericInterface_Func_Call[M]

func (*MockGenericInterface_Func_Call[M]) RunAndReturn 

func (_c *MockGenericInterface_Func_Call[M]) RunAndReturn(run func(arg *M) int) *MockGenericInterface_Func_Call[M]

type MockGetGeneric 

type MockGetGeneric[T constraints.Integer] struct {
	mock.Mock
}

MockGetGeneric is an autogenerated mock type for the GetGeneric type

func NewMockGetGeneric 

func NewMockGetGeneric[T constraints.Integer](t interface {
	mock.TestingT
	Cleanup(func())
}) *MockGetGeneric[T]

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 (*MockGetGeneric[T]) EXPECT 

func (_m *MockGetGeneric[T]) EXPECT() *MockGetGeneric_Expecter[T]

func (*MockGetGeneric[T]) Get 

func (_mock *MockGetGeneric[T]) Get() T

Get provides a mock function for the type MockGetGeneric

type MockGetGeneric_Expecter 

type MockGetGeneric_Expecter[T constraints.Integer] struct {
	// contains filtered or unexported fields
}

func (*MockGetGeneric_Expecter[T]) Get 

func (_e *MockGetGeneric_Expecter[T]) Get() *MockGetGeneric_Get_Call[T]

Get is a helper method to define mock.On call

type MockGetGeneric_Get_Call 

type MockGetGeneric_Get_Call[T constraints.Integer] struct {
	*mock.Call
}

MockGetGeneric_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockGetGeneric_Get_Call[T]) Return 

func (_c *MockGetGeneric_Get_Call[T]) Return(v T) *MockGetGeneric_Get_Call[T]

func (*MockGetGeneric_Get_Call[T]) Run 

func (_c *MockGetGeneric_Get_Call[T]) Run(run func()) *MockGetGeneric_Get_Call[T]

func (*MockGetGeneric_Get_Call[T]) RunAndReturn 

func (_c *MockGetGeneric_Get_Call[T]) RunAndReturn(run func() T) *MockGetGeneric_Get_Call[T]

type MockGetInt 

type MockGetInt struct {
	mock.Mock
}

MockGetInt is an autogenerated mock type for the GetInt type

func NewMockGetInt 

func NewMockGetInt(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockGetInt

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 (*MockGetInt) EXPECT 

func (_m *MockGetInt) EXPECT() *MockGetInt_Expecter

func (*MockGetInt) Get 

func (_mock *MockGetInt) Get() int

Get provides a mock function for the type MockGetInt

type MockGetInt_Expecter 

type MockGetInt_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockGetInt_Expecter) Get 

func (_e *MockGetInt_Expecter) Get() *MockGetInt_Get_Call

Get is a helper method to define mock.On call

type MockGetInt_Get_Call 

type MockGetInt_Get_Call struct {
	*mock.Call
}

MockGetInt_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockGetInt_Get_Call) Return 

func (_c *MockGetInt_Get_Call) Return(n int) *MockGetInt_Get_Call

func (*MockGetInt_Get_Call) Run 

func (_c *MockGetInt_Get_Call) Run(run func()) *MockGetInt_Get_Call

func (*MockGetInt_Get_Call) RunAndReturn 

func (_c *MockGetInt_Get_Call) RunAndReturn(run func() int) *MockGetInt_Get_Call

type MockHasConflictingNestedImports 

type MockHasConflictingNestedImports struct {
	mock.Mock
}

MockHasConflictingNestedImports is an autogenerated mock type for the HasConflictingNestedImports type

func NewMockHasConflictingNestedImports 

func NewMockHasConflictingNestedImports(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockHasConflictingNestedImports

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 (*MockHasConflictingNestedImports) EXPECT 

func (_m *MockHasConflictingNestedImports) EXPECT() *MockHasConflictingNestedImports_Expecter

func (*MockHasConflictingNestedImports) Get 

func (_mock *MockHasConflictingNestedImports) Get(path string) (http.Response, error)

Get provides a mock function for the type MockHasConflictingNestedImports

func (*MockHasConflictingNestedImports) Z 

func (_mock *MockHasConflictingNestedImports) Z() http0.MyStruct

Z provides a mock function for the type MockHasConflictingNestedImports

type MockHasConflictingNestedImports_Expecter 

type MockHasConflictingNestedImports_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockHasConflictingNestedImports_Expecter) Get 

func (_e *MockHasConflictingNestedImports_Expecter) Get(path interface{}) *MockHasConflictingNestedImports_Get_Call

Get is a helper method to define mock.On call

  • path

func (*MockHasConflictingNestedImports_Expecter) Z 

func (_e *MockHasConflictingNestedImports_Expecter) Z() *MockHasConflictingNestedImports_Z_Call

Z is a helper method to define mock.On call

type MockHasConflictingNestedImports_Get_Call 

type MockHasConflictingNestedImports_Get_Call struct {
	*mock.Call
}

MockHasConflictingNestedImports_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockHasConflictingNestedImports_Get_Call) Return 

func (_c *MockHasConflictingNestedImports_Get_Call) Return(response http.Response, err error) *MockHasConflictingNestedImports_Get_Call

func (*MockHasConflictingNestedImports_Get_Call) Run 

func (_c *MockHasConflictingNestedImports_Get_Call) Run(run func(path string)) *MockHasConflictingNestedImports_Get_Call

func (*MockHasConflictingNestedImports_Get_Call) RunAndReturn 

func (_c *MockHasConflictingNestedImports_Get_Call) RunAndReturn(run func(path string) (http.Response, error)) *MockHasConflictingNestedImports_Get_Call

type MockHasConflictingNestedImports_Z_Call 

type MockHasConflictingNestedImports_Z_Call struct {
	*mock.Call
}

MockHasConflictingNestedImports_Z_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Z'

func (*MockHasConflictingNestedImports_Z_Call) Return 

func (_c *MockHasConflictingNestedImports_Z_Call) Return(myStruct http0.MyStruct) *MockHasConflictingNestedImports_Z_Call

func (*MockHasConflictingNestedImports_Z_Call) Run 

func (_c *MockHasConflictingNestedImports_Z_Call) Run(run func()) *MockHasConflictingNestedImports_Z_Call

func (*MockHasConflictingNestedImports_Z_Call) RunAndReturn 

func (_c *MockHasConflictingNestedImports_Z_Call) RunAndReturn(run func() http0.MyStruct) *MockHasConflictingNestedImports_Z_Call

type MockImportsSameAsPackage 

type MockImportsSameAsPackage struct {
	mock.Mock
}

MockImportsSameAsPackage is an autogenerated mock type for the ImportsSameAsPackage type

func NewMockImportsSameAsPackage 

func NewMockImportsSameAsPackage(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockImportsSameAsPackage

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 (*MockImportsSameAsPackage) A 

func (_mock *MockImportsSameAsPackage) A() test.B

A provides a mock function for the type MockImportsSameAsPackage

func (*MockImportsSameAsPackage) B 

func (_mock *MockImportsSameAsPackage) B() KeyManager

B provides a mock function for the type MockImportsSameAsPackage

func (*MockImportsSameAsPackage) C 

func (_mock *MockImportsSameAsPackage) C(c C)

C provides a mock function for the type MockImportsSameAsPackage

func (*MockImportsSameAsPackage) EXPECT 

func (_m *MockImportsSameAsPackage) EXPECT() *MockImportsSameAsPackage_Expecter

type MockImportsSameAsPackage_A_Call 

type MockImportsSameAsPackage_A_Call struct {
	*mock.Call
}

MockImportsSameAsPackage_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A'

func (*MockImportsSameAsPackage_A_Call) Return 

func (_c *MockImportsSameAsPackage_A_Call) Return(b test.B) *MockImportsSameAsPackage_A_Call

func (*MockImportsSameAsPackage_A_Call) Run 

func (_c *MockImportsSameAsPackage_A_Call) Run(run func()) *MockImportsSameAsPackage_A_Call

func (*MockImportsSameAsPackage_A_Call) RunAndReturn 

func (_c *MockImportsSameAsPackage_A_Call) RunAndReturn(run func() test.B) *MockImportsSameAsPackage_A_Call

type MockImportsSameAsPackage_B_Call 

type MockImportsSameAsPackage_B_Call struct {
	*mock.Call
}

MockImportsSameAsPackage_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B'

func (*MockImportsSameAsPackage_B_Call) Return 

func (_c *MockImportsSameAsPackage_B_Call) Return(keyManager KeyManager) *MockImportsSameAsPackage_B_Call

func (*MockImportsSameAsPackage_B_Call) Run 

func (_c *MockImportsSameAsPackage_B_Call) Run(run func()) *MockImportsSameAsPackage_B_Call

func (*MockImportsSameAsPackage_B_Call) RunAndReturn 

func (_c *MockImportsSameAsPackage_B_Call) RunAndReturn(run func() KeyManager) *MockImportsSameAsPackage_B_Call

type MockImportsSameAsPackage_C_Call 

type MockImportsSameAsPackage_C_Call struct {
	*mock.Call
}

MockImportsSameAsPackage_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C'

func (*MockImportsSameAsPackage_C_Call) Return 

func (_c *MockImportsSameAsPackage_C_Call) Return() *MockImportsSameAsPackage_C_Call

func (*MockImportsSameAsPackage_C_Call) Run 

func (_c *MockImportsSameAsPackage_C_Call) Run(run func(c C)) *MockImportsSameAsPackage_C_Call

func (*MockImportsSameAsPackage_C_Call) RunAndReturn 

func (_c *MockImportsSameAsPackage_C_Call) RunAndReturn(run func(c C)) *MockImportsSameAsPackage_C_Call

type MockImportsSameAsPackage_Expecter 

type MockImportsSameAsPackage_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockImportsSameAsPackage_Expecter) A 

func (_e *MockImportsSameAsPackage_Expecter) A() *MockImportsSameAsPackage_A_Call

A is a helper method to define mock.On call

func (*MockImportsSameAsPackage_Expecter) B 

func (_e *MockImportsSameAsPackage_Expecter) B() *MockImportsSameAsPackage_B_Call

B is a helper method to define mock.On call

func (*MockImportsSameAsPackage_Expecter) C 

func (_e *MockImportsSameAsPackage_Expecter) C(c interface{}) *MockImportsSameAsPackage_C_Call

C is a helper method to define mock.On call

  • c

type MockInstantiatedGenericInterface 

type MockInstantiatedGenericInterface struct {
	mock.Mock
}

MockInstantiatedGenericInterface is an autogenerated mock type for the InstantiatedGenericInterface type

func NewMockInstantiatedGenericInterface 

func NewMockInstantiatedGenericInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockInstantiatedGenericInterface

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 (*MockInstantiatedGenericInterface) EXPECT 

func (_m *MockInstantiatedGenericInterface) EXPECT() *MockInstantiatedGenericInterface_Expecter

func (*MockInstantiatedGenericInterface) Func 

func (_mock *MockInstantiatedGenericInterface) Func(arg *float32) int

Func provides a mock function for the type MockInstantiatedGenericInterface

type MockInstantiatedGenericInterface_Expecter 

type MockInstantiatedGenericInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockInstantiatedGenericInterface_Expecter) Func 

func (_e *MockInstantiatedGenericInterface_Expecter) Func(arg interface{}) *MockInstantiatedGenericInterface_Func_Call

Func is a helper method to define mock.On call

  • arg

type MockInstantiatedGenericInterface_Func_Call 

type MockInstantiatedGenericInterface_Func_Call struct {
	*mock.Call
}

MockInstantiatedGenericInterface_Func_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Func'

func (*MockInstantiatedGenericInterface_Func_Call) Return 

func (_c *MockInstantiatedGenericInterface_Func_Call) Return(n int) *MockInstantiatedGenericInterface_Func_Call

func (*MockInstantiatedGenericInterface_Func_Call) Run 

func (_c *MockInstantiatedGenericInterface_Func_Call) Run(run func(arg *float32)) *MockInstantiatedGenericInterface_Func_Call

func (*MockInstantiatedGenericInterface_Func_Call) RunAndReturn 

func (_c *MockInstantiatedGenericInterface_Func_Call) RunAndReturn(run func(arg *float32) int) *MockInstantiatedGenericInterface_Func_Call

type MockIssue766 

type MockIssue766 struct {
	mock.Mock
}

MockIssue766 is an autogenerated mock type for the Issue766 type

func NewMockIssue766 

func NewMockIssue766(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockIssue766

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 (*MockIssue766) EXPECT 

func (_m *MockIssue766) EXPECT() *MockIssue766_Expecter

func (*MockIssue766) FetchData 

func (_mock *MockIssue766) FetchData(fetchFunc func(x ...int) ([]int, error)) ([]int, error)

FetchData provides a mock function for the type MockIssue766

type MockIssue766_Expecter 

type MockIssue766_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockIssue766_Expecter) FetchData 

func (_e *MockIssue766_Expecter) FetchData(fetchFunc interface{}) *MockIssue766_FetchData_Call

FetchData is a helper method to define mock.On call

  • fetchFunc

type MockIssue766_FetchData_Call 

type MockIssue766_FetchData_Call struct {
	*mock.Call
}

MockIssue766_FetchData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FetchData'

func (*MockIssue766_FetchData_Call) Return 

func (_c *MockIssue766_FetchData_Call) Return(ints []int, err error) *MockIssue766_FetchData_Call

func (*MockIssue766_FetchData_Call) Run 

func (_c *MockIssue766_FetchData_Call) Run(run func(fetchFunc func(x ...int) ([]int, error))) *MockIssue766_FetchData_Call

func (*MockIssue766_FetchData_Call) RunAndReturn 

func (_c *MockIssue766_FetchData_Call) RunAndReturn(run func(fetchFunc func(x ...int) ([]int, error)) ([]int, error)) *MockIssue766_FetchData_Call

type MockKeyManager 

type MockKeyManager struct {
	mock.Mock
}

MockKeyManager is an autogenerated mock type for the KeyManager type

func NewMockKeyManager 

func NewMockKeyManager(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockKeyManager

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 (*MockKeyManager) EXPECT 

func (_m *MockKeyManager) EXPECT() *MockKeyManager_Expecter

func (*MockKeyManager) GetKey 

func (_mock *MockKeyManager) GetKey(s string, v uint16) ([]byte, *Err)

GetKey provides a mock function for the type MockKeyManager

type MockKeyManager_Expecter 

type MockKeyManager_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockKeyManager_Expecter) GetKey 

func (_e *MockKeyManager_Expecter) GetKey(s interface{}, v interface{}) *MockKeyManager_GetKey_Call

GetKey is a helper method to define mock.On call

  • s
  • v

type MockKeyManager_GetKey_Call 

type MockKeyManager_GetKey_Call struct {
	*mock.Call
}

MockKeyManager_GetKey_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetKey'

func (*MockKeyManager_GetKey_Call) Return 

func (_c *MockKeyManager_GetKey_Call) Return(bytes []byte, err *Err) *MockKeyManager_GetKey_Call

func (*MockKeyManager_GetKey_Call) Run 

func (_c *MockKeyManager_GetKey_Call) Run(run func(s string, v uint16)) *MockKeyManager_GetKey_Call

func (*MockKeyManager_GetKey_Call) RunAndReturn 

func (_c *MockKeyManager_GetKey_Call) RunAndReturn(run func(s string, v uint16) ([]byte, *Err)) *MockKeyManager_GetKey_Call

type MockMapFunc 

type MockMapFunc struct {
	mock.Mock
}

MockMapFunc is an autogenerated mock type for the MapFunc type

func NewMockMapFunc 

func NewMockMapFunc(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMapFunc

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 (*MockMapFunc) EXPECT 

func (_m *MockMapFunc) EXPECT() *MockMapFunc_Expecter

func (*MockMapFunc) Get 

func (_mock *MockMapFunc) Get(m map[string]func(string) string) error

Get provides a mock function for the type MockMapFunc

type MockMapFunc_Expecter 

type MockMapFunc_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockMapFunc_Expecter) Get 

func (_e *MockMapFunc_Expecter) Get(m interface{}) *MockMapFunc_Get_Call

Get is a helper method to define mock.On call

  • m

type MockMapFunc_Get_Call 

type MockMapFunc_Get_Call struct {
	*mock.Call
}

MockMapFunc_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockMapFunc_Get_Call) Return 

func (_c *MockMapFunc_Get_Call) Return(err error) *MockMapFunc_Get_Call

func (*MockMapFunc_Get_Call) Run 

func (_c *MockMapFunc_Get_Call) Run(run func(m map[string]func(string) string)) *MockMapFunc_Get_Call

func (*MockMapFunc_Get_Call) RunAndReturn 

func (_c *MockMapFunc_Get_Call) RunAndReturn(run func(m map[string]func(string) string) error) *MockMapFunc_Get_Call

type MockMapToInterface 

type MockMapToInterface struct {
	mock.Mock
}

MockMapToInterface is an autogenerated mock type for the MapToInterface type

func NewMockMapToInterface 

func NewMockMapToInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMapToInterface

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 (*MockMapToInterface) EXPECT 

func (_m *MockMapToInterface) EXPECT() *MockMapToInterface_Expecter

func (*MockMapToInterface) Foo 

func (_mock *MockMapToInterface) Foo(arg1 ...map[string]interface{})

Foo provides a mock function for the type MockMapToInterface

type MockMapToInterface_Expecter 

type MockMapToInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockMapToInterface_Expecter) Foo 

func (_e *MockMapToInterface_Expecter) Foo(arg1 ...interface{}) *MockMapToInterface_Foo_Call

Foo is a helper method to define mock.On call

  • arg1

type MockMapToInterface_Foo_Call 

type MockMapToInterface_Foo_Call struct {
	*mock.Call
}

MockMapToInterface_Foo_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Foo'

func (*MockMapToInterface_Foo_Call) Return 

func (_c *MockMapToInterface_Foo_Call) Return() *MockMapToInterface_Foo_Call

func (*MockMapToInterface_Foo_Call) Run 

func (_c *MockMapToInterface_Foo_Call) Run(run func(arg1 ...map[string]interface{})) *MockMapToInterface_Foo_Call

func (*MockMapToInterface_Foo_Call) RunAndReturn 

func (_c *MockMapToInterface_Foo_Call) RunAndReturn(run func(arg1 ...map[string]interface{})) *MockMapToInterface_Foo_Call

type MockMyReader 

type MockMyReader struct {
	mock.Mock
}

MockMyReader is an autogenerated mock type for the MyReader type

func NewMockMyReader 

func NewMockMyReader(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockMyReader

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 (*MockMyReader) EXPECT 

func (_m *MockMyReader) EXPECT() *MockMyReader_Expecter

func (*MockMyReader) Read 

func (_mock *MockMyReader) Read(p []byte) (int, error)

Read provides a mock function for the type MockMyReader

type MockMyReader_Expecter 

type MockMyReader_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockMyReader_Expecter) Read 

func (_e *MockMyReader_Expecter) Read(p interface{}) *MockMyReader_Read_Call

Read is a helper method to define mock.On call

  • p

type MockMyReader_Read_Call 

type MockMyReader_Read_Call struct {
	*mock.Call
}

MockMyReader_Read_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Read'

func (*MockMyReader_Read_Call) Return 

func (_c *MockMyReader_Read_Call) Return(n int, err error) *MockMyReader_Read_Call

func (*MockMyReader_Read_Call) Run 

func (_c *MockMyReader_Read_Call) Run(run func(p []byte)) *MockMyReader_Read_Call

func (*MockMyReader_Read_Call) RunAndReturn 

func (_c *MockMyReader_Read_Call) RunAndReturn(run func(p []byte) (int, error)) *MockMyReader_Read_Call

type MockPanicOnNoReturnValue 

type MockPanicOnNoReturnValue struct {
	mock.Mock
}

MockPanicOnNoReturnValue is an autogenerated mock type for the PanicOnNoReturnValue type

func NewMockPanicOnNoReturnValue 

func NewMockPanicOnNoReturnValue(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockPanicOnNoReturnValue

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 (*MockPanicOnNoReturnValue) DoSomething 

func (_mock *MockPanicOnNoReturnValue) DoSomething() string

DoSomething provides a mock function for the type MockPanicOnNoReturnValue

func (*MockPanicOnNoReturnValue) EXPECT 

func (_m *MockPanicOnNoReturnValue) EXPECT() *MockPanicOnNoReturnValue_Expecter

type MockPanicOnNoReturnValue_DoSomething_Call 

type MockPanicOnNoReturnValue_DoSomething_Call struct {
	*mock.Call
}

MockPanicOnNoReturnValue_DoSomething_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoSomething'

func (*MockPanicOnNoReturnValue_DoSomething_Call) Return 

func (_c *MockPanicOnNoReturnValue_DoSomething_Call) Return(s string) *MockPanicOnNoReturnValue_DoSomething_Call

func (*MockPanicOnNoReturnValue_DoSomething_Call) Run 

func (_c *MockPanicOnNoReturnValue_DoSomething_Call) Run(run func()) *MockPanicOnNoReturnValue_DoSomething_Call

func (*MockPanicOnNoReturnValue_DoSomething_Call) RunAndReturn 

func (_c *MockPanicOnNoReturnValue_DoSomething_Call) RunAndReturn(run func() string) *MockPanicOnNoReturnValue_DoSomething_Call

type MockPanicOnNoReturnValue_Expecter 

type MockPanicOnNoReturnValue_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockPanicOnNoReturnValue_Expecter) DoSomething 

func (_e *MockPanicOnNoReturnValue_Expecter) DoSomething() *MockPanicOnNoReturnValue_DoSomething_Call

DoSomething is a helper method to define mock.On call

type MockReplaceGeneric 

type MockReplaceGeneric[TImport any, TConstraint constraints.Signed, TKeep any] struct {
	mock.Mock
}

MockReplaceGeneric is an autogenerated mock type for the ReplaceGeneric type

func NewMockReplaceGeneric 

func NewMockReplaceGeneric[TImport any, TConstraint constraints.Signed, TKeep any](t interface {
	mock.TestingT
	Cleanup(func())
}) *MockReplaceGeneric[TImport, TConstraint, TKeep]

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 (*MockReplaceGeneric[TImport, TConstraint, TKeep]) A 

func (_mock *MockReplaceGeneric[TImport, TConstraint, TKeep]) A(t1 TImport) TKeep

A provides a mock function for the type MockReplaceGeneric

func (*MockReplaceGeneric[TImport, TConstraint, TKeep]) B 

func (_mock *MockReplaceGeneric[TImport, TConstraint, TKeep]) B() TImport

B provides a mock function for the type MockReplaceGeneric

func (*MockReplaceGeneric[TImport, TConstraint, TKeep]) C 

func (_mock *MockReplaceGeneric[TImport, TConstraint, TKeep]) C() TConstraint

C provides a mock function for the type MockReplaceGeneric

func (*MockReplaceGeneric[TImport, TConstraint, TKeep]) EXPECT 

func (_m *MockReplaceGeneric[TImport, TConstraint, TKeep]) EXPECT() *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]

type MockReplaceGenericSelf 

type MockReplaceGenericSelf[T any] struct {
	mock.Mock
}

MockReplaceGenericSelf is an autogenerated mock type for the ReplaceGenericSelf type

func NewMockReplaceGenericSelf 

func NewMockReplaceGenericSelf[T any](t interface {
	mock.TestingT
	Cleanup(func())
}) *MockReplaceGenericSelf[T]

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 (*MockReplaceGenericSelf[T]) A 

func (_mock *MockReplaceGenericSelf[T]) A() T

A provides a mock function for the type MockReplaceGenericSelf

func (*MockReplaceGenericSelf[T]) EXPECT 

func (_m *MockReplaceGenericSelf[T]) EXPECT() *MockReplaceGenericSelf_Expecter[T]

type MockReplaceGenericSelf_A_Call 

type MockReplaceGenericSelf_A_Call[T any] struct {
	*mock.Call
}

MockReplaceGenericSelf_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A'

func (*MockReplaceGenericSelf_A_Call[T]) Return 

func (_c *MockReplaceGenericSelf_A_Call[T]) Return(v T) *MockReplaceGenericSelf_A_Call[T]

func (*MockReplaceGenericSelf_A_Call[T]) Run 

func (_c *MockReplaceGenericSelf_A_Call[T]) Run(run func()) *MockReplaceGenericSelf_A_Call[T]

func (*MockReplaceGenericSelf_A_Call[T]) RunAndReturn 

func (_c *MockReplaceGenericSelf_A_Call[T]) RunAndReturn(run func() T) *MockReplaceGenericSelf_A_Call[T]

type MockReplaceGenericSelf_Expecter 

type MockReplaceGenericSelf_Expecter[T any] struct {
	// contains filtered or unexported fields
}

func (*MockReplaceGenericSelf_Expecter[T]) A 

func (_e *MockReplaceGenericSelf_Expecter[T]) A() *MockReplaceGenericSelf_A_Call[T]

A is a helper method to define mock.On call

type MockReplaceGeneric_A_Call 

type MockReplaceGeneric_A_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct {
	*mock.Call
}

MockReplaceGeneric_A_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'A'

func (*MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) Return 

func (_c *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) Return(v TKeep) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]

func (*MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) Run 

func (_c *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) Run(run func(t1 TImport)) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]

func (*MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) RunAndReturn 

func (_c *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func(t1 TImport) TKeep) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]

type MockReplaceGeneric_B_Call 

type MockReplaceGeneric_B_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct {
	*mock.Call
}

MockReplaceGeneric_B_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'B'

func (*MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) Return 

func (_c *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) Return(v TImport) *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]

func (*MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) Run 

func (_c *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) Run(run func()) *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]

func (*MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) RunAndReturn 

func (_c *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func() TImport) *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]

type MockReplaceGeneric_C_Call 

type MockReplaceGeneric_C_Call[TImport any, TConstraint constraints.Signed, TKeep any] struct {
	*mock.Call
}

MockReplaceGeneric_C_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'C'

func (*MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) Return 

func (_c *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) Return(v TConstraint) *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]

func (*MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) Run 

func (_c *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) Run(run func()) *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]

func (*MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) RunAndReturn 

func (_c *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]) RunAndReturn(run func() TConstraint) *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]

type MockReplaceGeneric_Expecter 

type MockReplaceGeneric_Expecter[TImport any, TConstraint constraints.Signed, TKeep any] struct {
	// contains filtered or unexported fields
}

func (*MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) A 

func (_e *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) A(t1 interface{}) *MockReplaceGeneric_A_Call[TImport, TConstraint, TKeep]

A is a helper method to define mock.On call

  • t1

func (*MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) B 

func (_e *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) B() *MockReplaceGeneric_B_Call[TImport, TConstraint, TKeep]

B is a helper method to define mock.On call

func (*MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) C 

func (_e *MockReplaceGeneric_Expecter[TImport, TConstraint, TKeep]) C() *MockReplaceGeneric_C_Call[TImport, TConstraint, TKeep]

C is a helper method to define mock.On call

type MockRequester 

type MockRequester struct {
	mock.Mock
}

MockRequester is an autogenerated mock type for the Requester type

func NewMockRequester 

func NewMockRequester(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequester

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 (*MockRequester) EXPECT 

func (_m *MockRequester) EXPECT() *MockRequester_Expecter

func (*MockRequester) Get 

func (_mock *MockRequester) Get(path string) (string, error)

Get provides a mock function for the type MockRequester

type MockRequester2 

type MockRequester2 struct {
	mock.Mock
}

MockRequester2 is an autogenerated mock type for the Requester2 type

func NewMockRequester2 

func NewMockRequester2(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequester2

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 (*MockRequester2) EXPECT 

func (_m *MockRequester2) EXPECT() *MockRequester2_Expecter

func (*MockRequester2) Get 

func (_mock *MockRequester2) Get(path string) error

Get provides a mock function for the type MockRequester2

type MockRequester2_Expecter 

type MockRequester2_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequester2_Expecter) Get 

func (_e *MockRequester2_Expecter) Get(path interface{}) *MockRequester2_Get_Call

Get is a helper method to define mock.On call

  • path

type MockRequester2_Get_Call 

type MockRequester2_Get_Call struct {
	*mock.Call
}

MockRequester2_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequester2_Get_Call) Return 

func (_c *MockRequester2_Get_Call) Return(err error) *MockRequester2_Get_Call

func (*MockRequester2_Get_Call) Run 

func (_c *MockRequester2_Get_Call) Run(run func(path string)) *MockRequester2_Get_Call

func (*MockRequester2_Get_Call) RunAndReturn 

func (_c *MockRequester2_Get_Call) RunAndReturn(run func(path string) error) *MockRequester2_Get_Call

type MockRequester3 

type MockRequester3 struct {
	mock.Mock
}

MockRequester3 is an autogenerated mock type for the Requester3 type

func NewMockRequester3 

func NewMockRequester3(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequester3

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 (*MockRequester3) EXPECT 

func (_m *MockRequester3) EXPECT() *MockRequester3_Expecter

func (*MockRequester3) Get 

func (_mock *MockRequester3) Get() error

Get provides a mock function for the type MockRequester3

type MockRequester3_Expecter 

type MockRequester3_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequester3_Expecter) Get 

func (_e *MockRequester3_Expecter) Get() *MockRequester3_Get_Call

Get is a helper method to define mock.On call

type MockRequester3_Get_Call 

type MockRequester3_Get_Call struct {
	*mock.Call
}

MockRequester3_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequester3_Get_Call) Return 

func (_c *MockRequester3_Get_Call) Return(err error) *MockRequester3_Get_Call

func (*MockRequester3_Get_Call) Run 

func (_c *MockRequester3_Get_Call) Run(run func()) *MockRequester3_Get_Call

func (*MockRequester3_Get_Call) RunAndReturn 

func (_c *MockRequester3_Get_Call) RunAndReturn(run func() error) *MockRequester3_Get_Call

type MockRequester4 

type MockRequester4 struct {
	mock.Mock
}

MockRequester4 is an autogenerated mock type for the Requester4 type

func NewMockRequester4 

func NewMockRequester4(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequester4

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 (*MockRequester4) EXPECT 

func (_m *MockRequester4) EXPECT() *MockRequester4_Expecter

func (*MockRequester4) Get 

func (_mock *MockRequester4) Get()

Get provides a mock function for the type MockRequester4

type MockRequester4_Expecter 

type MockRequester4_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequester4_Expecter) Get 

func (_e *MockRequester4_Expecter) Get() *MockRequester4_Get_Call

Get is a helper method to define mock.On call

type MockRequester4_Get_Call 

type MockRequester4_Get_Call struct {
	*mock.Call
}

MockRequester4_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequester4_Get_Call) Return 

func (_c *MockRequester4_Get_Call) Return() *MockRequester4_Get_Call

func (*MockRequester4_Get_Call) Run 

func (_c *MockRequester4_Get_Call) Run(run func()) *MockRequester4_Get_Call

func (*MockRequester4_Get_Call) RunAndReturn 

func (_c *MockRequester4_Get_Call) RunAndReturn(run func()) *MockRequester4_Get_Call

type MockRequesterArgSameAsImport 

type MockRequesterArgSameAsImport struct {
	mock.Mock
}

MockRequesterArgSameAsImport is an autogenerated mock type for the RequesterArgSameAsImport type

func NewMockRequesterArgSameAsImport 

func NewMockRequesterArgSameAsImport(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterArgSameAsImport

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 (*MockRequesterArgSameAsImport) EXPECT 

func (_m *MockRequesterArgSameAsImport) EXPECT() *MockRequesterArgSameAsImport_Expecter

func (*MockRequesterArgSameAsImport) Get 

func (_mock *MockRequesterArgSameAsImport) Get(json1 string) *json.RawMessage

Get provides a mock function for the type MockRequesterArgSameAsImport

type MockRequesterArgSameAsImport_Expecter 

type MockRequesterArgSameAsImport_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequesterArgSameAsImport_Expecter) Get 

func (_e *MockRequesterArgSameAsImport_Expecter) Get(json1 interface{}) *MockRequesterArgSameAsImport_Get_Call

Get is a helper method to define mock.On call

  • json1

type MockRequesterArgSameAsImport_Get_Call 

type MockRequesterArgSameAsImport_Get_Call struct {
	*mock.Call
}

MockRequesterArgSameAsImport_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequesterArgSameAsImport_Get_Call) Return 

func (_c *MockRequesterArgSameAsImport_Get_Call) Return(rawMessage *json.RawMessage) *MockRequesterArgSameAsImport_Get_Call

func (*MockRequesterArgSameAsImport_Get_Call) Run 

func (_c *MockRequesterArgSameAsImport_Get_Call) Run(run func(json1 string)) *MockRequesterArgSameAsImport_Get_Call

func (*MockRequesterArgSameAsImport_Get_Call) RunAndReturn 

func (_c *MockRequesterArgSameAsImport_Get_Call) RunAndReturn(run func(json1 string) *json.RawMessage) *MockRequesterArgSameAsImport_Get_Call

type MockRequesterArgSameAsNamedImport 

type MockRequesterArgSameAsNamedImport struct {
	mock.Mock
}

MockRequesterArgSameAsNamedImport is an autogenerated mock type for the RequesterArgSameAsNamedImport type

func NewMockRequesterArgSameAsNamedImport 

func NewMockRequesterArgSameAsNamedImport(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterArgSameAsNamedImport

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 (*MockRequesterArgSameAsNamedImport) EXPECT 

func (_m *MockRequesterArgSameAsNamedImport) EXPECT() *MockRequesterArgSameAsNamedImport_Expecter

func (*MockRequesterArgSameAsNamedImport) Get 

func (_mock *MockRequesterArgSameAsNamedImport) Get(json1 string) *json.RawMessage

Get provides a mock function for the type MockRequesterArgSameAsNamedImport

type MockRequesterArgSameAsNamedImport_Expecter 

type MockRequesterArgSameAsNamedImport_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequesterArgSameAsNamedImport_Expecter) Get 

func (_e *MockRequesterArgSameAsNamedImport_Expecter) Get(json1 interface{}) *MockRequesterArgSameAsNamedImport_Get_Call

Get is a helper method to define mock.On call

  • json1

type MockRequesterArgSameAsNamedImport_Get_Call 

type MockRequesterArgSameAsNamedImport_Get_Call struct {
	*mock.Call
}

MockRequesterArgSameAsNamedImport_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequesterArgSameAsNamedImport_Get_Call) Return 

func (_c *MockRequesterArgSameAsNamedImport_Get_Call) Return(rawMessage *json.RawMessage) *MockRequesterArgSameAsNamedImport_Get_Call

func (*MockRequesterArgSameAsNamedImport_Get_Call) Run 

func (_c *MockRequesterArgSameAsNamedImport_Get_Call) Run(run func(json1 string)) *MockRequesterArgSameAsNamedImport_Get_Call

func (*MockRequesterArgSameAsNamedImport_Get_Call) RunAndReturn 

func (_c *MockRequesterArgSameAsNamedImport_Get_Call) RunAndReturn(run func(json1 string) *json.RawMessage) *MockRequesterArgSameAsNamedImport_Get_Call

type MockRequesterArgSameAsPkg 

type MockRequesterArgSameAsPkg struct {
	mock.Mock
}

MockRequesterArgSameAsPkg is an autogenerated mock type for the RequesterArgSameAsPkg type

func NewMockRequesterArgSameAsPkg 

func NewMockRequesterArgSameAsPkg(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterArgSameAsPkg

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 (*MockRequesterArgSameAsPkg) EXPECT 

func (_m *MockRequesterArgSameAsPkg) EXPECT() *MockRequesterArgSameAsPkg_Expecter

func (*MockRequesterArgSameAsPkg) Get 

func (_mock *MockRequesterArgSameAsPkg) Get(test1 string)

Get provides a mock function for the type MockRequesterArgSameAsPkg

type MockRequesterArgSameAsPkg_Expecter 

type MockRequesterArgSameAsPkg_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequesterArgSameAsPkg_Expecter) Get 

func (_e *MockRequesterArgSameAsPkg_Expecter) Get(test1 interface{}) *MockRequesterArgSameAsPkg_Get_Call

Get is a helper method to define mock.On call

  • test1

type MockRequesterArgSameAsPkg_Get_Call 

type MockRequesterArgSameAsPkg_Get_Call struct {
	*mock.Call
}

MockRequesterArgSameAsPkg_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequesterArgSameAsPkg_Get_Call) Return 

func (_c *MockRequesterArgSameAsPkg_Get_Call) Return() *MockRequesterArgSameAsPkg_Get_Call

func (*MockRequesterArgSameAsPkg_Get_Call) Run 

func (_c *MockRequesterArgSameAsPkg_Get_Call) Run(run func(test1 string)) *MockRequesterArgSameAsPkg_Get_Call

func (*MockRequesterArgSameAsPkg_Get_Call) RunAndReturn 

func (_c *MockRequesterArgSameAsPkg_Get_Call) RunAndReturn(run func(test1 string)) *MockRequesterArgSameAsPkg_Get_Call

type MockRequesterArray 

type MockRequesterArray struct {
	mock.Mock
}

MockRequesterArray is an autogenerated mock type for the RequesterArray type

func NewMockRequesterArray 

func NewMockRequesterArray(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterArray

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 (*MockRequesterArray) EXPECT 

func (_m *MockRequesterArray) EXPECT() *MockRequesterArray_Expecter

func (*MockRequesterArray) Get 

func (_mock *MockRequesterArray) Get(path string) ([2]string, error)

Get provides a mock function for the type MockRequesterArray

type MockRequesterArray_Expecter 

type MockRequesterArray_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequesterArray_Expecter) Get 

func (_e *MockRequesterArray_Expecter) Get(path interface{}) *MockRequesterArray_Get_Call

Get is a helper method to define mock.On call

  • path

type MockRequesterArray_Get_Call 

type MockRequesterArray_Get_Call struct {
	*mock.Call
}

MockRequesterArray_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequesterArray_Get_Call) Return 

func (_c *MockRequesterArray_Get_Call) Return(strings [2]string, err error) *MockRequesterArray_Get_Call

func (*MockRequesterArray_Get_Call) Run 

func (_c *MockRequesterArray_Get_Call) Run(run func(path string)) *MockRequesterArray_Get_Call

func (*MockRequesterArray_Get_Call) RunAndReturn 

func (_c *MockRequesterArray_Get_Call) RunAndReturn(run func(path string) ([2]string, error)) *MockRequesterArray_Get_Call

type MockRequesterElided 

type MockRequesterElided struct {
	mock.Mock
}

MockRequesterElided is an autogenerated mock type for the RequesterElided type

func NewMockRequesterElided 

func NewMockRequesterElided(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterElided

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 (*MockRequesterElided) EXPECT 

func (_m *MockRequesterElided) EXPECT() *MockRequesterElided_Expecter

func (*MockRequesterElided) Get 

func (_mock *MockRequesterElided) Get(path string, url string) error

Get provides a mock function for the type MockRequesterElided

type MockRequesterElided_Expecter 

type MockRequesterElided_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequesterElided_Expecter) Get 

func (_e *MockRequesterElided_Expecter) Get(path interface{}, url interface{}) *MockRequesterElided_Get_Call

Get is a helper method to define mock.On call

  • path
  • url

type MockRequesterElided_Get_Call 

type MockRequesterElided_Get_Call struct {
	*mock.Call
}

MockRequesterElided_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequesterElided_Get_Call) Return 

func (_c *MockRequesterElided_Get_Call) Return(err error) *MockRequesterElided_Get_Call

func (*MockRequesterElided_Get_Call) Run 

func (_c *MockRequesterElided_Get_Call) Run(run func(path string, url string)) *MockRequesterElided_Get_Call

func (*MockRequesterElided_Get_Call) RunAndReturn 

func (_c *MockRequesterElided_Get_Call) RunAndReturn(run func(path string, url string) error) *MockRequesterElided_Get_Call

type MockRequesterGenerics 

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
}

MockRequesterGenerics is an autogenerated mock type for the RequesterGenerics type

func NewMockRequesterGenerics 

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]

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 (*MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) EXPECT 

func (_m *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) EXPECT() *MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]

func (*MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericAnonymousStructs 

func (_mock *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericAnonymousStructs(val struct{ Type1 TExternalIntf }) struct {
	Type2 GenericType[string, EmbeddedGet[int]]
}

GenericAnonymousStructs provides a mock function for the type MockRequesterGenerics

func (*MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericArguments 

func (_mock *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericArguments(v TAny, v1 TComparable) (TSigned, TIntf)

GenericArguments provides a mock function for the type MockRequesterGenerics

func (*MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericStructs 

func (_mock *MockRequesterGenerics[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericStructs(genericType GenericType[TAny, TIntf]) GenericType[TSigned, TIntf]

GenericStructs provides a mock function for the type MockRequesterGenerics

type MockRequesterGenerics_Expecter 

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 {
	// contains filtered or unexported fields
}

func (*MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericAnonymousStructs 

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]

GenericAnonymousStructs is a helper method to define mock.On call

  • val

func (*MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericArguments 

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]

GenericArguments is a helper method to define mock.On call

  • v
  • v1

func (*MockRequesterGenerics_Expecter[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) GenericStructs 

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]

GenericStructs is a helper method to define mock.On call

  • genericType

type MockRequesterGenerics_GenericAnonymousStructs_Call 

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
}

MockRequesterGenerics_GenericAnonymousStructs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericAnonymousStructs'

func (*MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return 

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]

func (*MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run 

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]

func (*MockRequesterGenerics_GenericAnonymousStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn 

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]

type MockRequesterGenerics_GenericArguments_Call 

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
}

MockRequesterGenerics_GenericArguments_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericArguments'

func (*MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return 

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]

func (*MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run 

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]

func (*MockRequesterGenerics_GenericArguments_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn 

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]

type MockRequesterGenerics_GenericStructs_Call 

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
}

MockRequesterGenerics_GenericStructs_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GenericStructs'

func (*MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Return 

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]

func (*MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) Run 

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]

func (*MockRequesterGenerics_GenericStructs_Call[TAny, TComparable, TSigned, TIntf, TExternalIntf, TGenIntf, TInlineType, TInlineTypeGeneric]) RunAndReturn 

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]

type MockRequesterIface 

type MockRequesterIface struct {
	mock.Mock
}

MockRequesterIface is an autogenerated mock type for the RequesterIface type

func NewMockRequesterIface 

func NewMockRequesterIface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterIface

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 (*MockRequesterIface) EXPECT 

func (_m *MockRequesterIface) EXPECT() *MockRequesterIface_Expecter

func (*MockRequesterIface) Get 

func (_mock *MockRequesterIface) Get() io.Reader

Get provides a mock function for the type MockRequesterIface

type MockRequesterIface_Expecter 

type MockRequesterIface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequesterIface_Expecter) Get 

func (_e *MockRequesterIface_Expecter) Get() *MockRequesterIface_Get_Call

Get is a helper method to define mock.On call

type MockRequesterIface_Get_Call 

type MockRequesterIface_Get_Call struct {
	*mock.Call
}

MockRequesterIface_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequesterIface_Get_Call) Return 

func (_c *MockRequesterIface_Get_Call) Return(reader io.Reader) *MockRequesterIface_Get_Call

func (*MockRequesterIface_Get_Call) Run 

func (_c *MockRequesterIface_Get_Call) Run(run func()) *MockRequesterIface_Get_Call

func (*MockRequesterIface_Get_Call) RunAndReturn 

func (_c *MockRequesterIface_Get_Call) RunAndReturn(run func() io.Reader) *MockRequesterIface_Get_Call

type MockRequesterNS 

type MockRequesterNS struct {
	mock.Mock
}

MockRequesterNS is an autogenerated mock type for the RequesterNS type

func NewMockRequesterNS 

func NewMockRequesterNS(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterNS

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 (*MockRequesterNS) EXPECT 

func (_m *MockRequesterNS) EXPECT() *MockRequesterNS_Expecter

func (*MockRequesterNS) Get 

func (_mock *MockRequesterNS) Get(path string) (http.Response, error)

Get provides a mock function for the type MockRequesterNS

type MockRequesterNS_Expecter 

type MockRequesterNS_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequesterNS_Expecter) Get 

func (_e *MockRequesterNS_Expecter) Get(path interface{}) *MockRequesterNS_Get_Call

Get is a helper method to define mock.On call

  • path

type MockRequesterNS_Get_Call 

type MockRequesterNS_Get_Call struct {
	*mock.Call
}

MockRequesterNS_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequesterNS_Get_Call) Return 

func (_c *MockRequesterNS_Get_Call) Return(response http.Response, err error) *MockRequesterNS_Get_Call

func (*MockRequesterNS_Get_Call) Run 

func (_c *MockRequesterNS_Get_Call) Run(run func(path string)) *MockRequesterNS_Get_Call

func (*MockRequesterNS_Get_Call) RunAndReturn 

func (_c *MockRequesterNS_Get_Call) RunAndReturn(run func(path string) (http.Response, error)) *MockRequesterNS_Get_Call

type MockRequesterPtr 

type MockRequesterPtr struct {
	mock.Mock
}

MockRequesterPtr is an autogenerated mock type for the RequesterPtr type

func NewMockRequesterPtr 

func NewMockRequesterPtr(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterPtr

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 (*MockRequesterPtr) EXPECT 

func (_m *MockRequesterPtr) EXPECT() *MockRequesterPtr_Expecter

func (*MockRequesterPtr) Get 

func (_mock *MockRequesterPtr) Get(path string) (*string, error)

Get provides a mock function for the type MockRequesterPtr

type MockRequesterPtr_Expecter 

type MockRequesterPtr_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequesterPtr_Expecter) Get 

func (_e *MockRequesterPtr_Expecter) Get(path interface{}) *MockRequesterPtr_Get_Call

Get is a helper method to define mock.On call

  • path

type MockRequesterPtr_Get_Call 

type MockRequesterPtr_Get_Call struct {
	*mock.Call
}

MockRequesterPtr_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequesterPtr_Get_Call) Return 

func (_c *MockRequesterPtr_Get_Call) Return(s *string, err error) *MockRequesterPtr_Get_Call

func (*MockRequesterPtr_Get_Call) Run 

func (_c *MockRequesterPtr_Get_Call) Run(run func(path string)) *MockRequesterPtr_Get_Call

func (*MockRequesterPtr_Get_Call) RunAndReturn 

func (_c *MockRequesterPtr_Get_Call) RunAndReturn(run func(path string) (*string, error)) *MockRequesterPtr_Get_Call

type MockRequesterReturnElided 

type MockRequesterReturnElided struct {
	mock.Mock
}

MockRequesterReturnElided is an autogenerated mock type for the RequesterReturnElided type

func NewMockRequesterReturnElided 

func NewMockRequesterReturnElided(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterReturnElided

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 (*MockRequesterReturnElided) EXPECT 

func (_m *MockRequesterReturnElided) EXPECT() *MockRequesterReturnElided_Expecter

func (*MockRequesterReturnElided) Get 

func (_mock *MockRequesterReturnElided) Get(path string) (int, int, int, error)

Get provides a mock function for the type MockRequesterReturnElided

func (*MockRequesterReturnElided) Put 

func (_mock *MockRequesterReturnElided) Put(path string) (int, error)

Put provides a mock function for the type MockRequesterReturnElided

type MockRequesterReturnElided_Expecter 

type MockRequesterReturnElided_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequesterReturnElided_Expecter) Get 

func (_e *MockRequesterReturnElided_Expecter) Get(path interface{}) *MockRequesterReturnElided_Get_Call

Get is a helper method to define mock.On call

  • path

func (*MockRequesterReturnElided_Expecter) Put 

func (_e *MockRequesterReturnElided_Expecter) Put(path interface{}) *MockRequesterReturnElided_Put_Call

Put is a helper method to define mock.On call

  • path

type MockRequesterReturnElided_Get_Call 

type MockRequesterReturnElided_Get_Call struct {
	*mock.Call
}

MockRequesterReturnElided_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequesterReturnElided_Get_Call) Return 

func (_c *MockRequesterReturnElided_Get_Call) Return(a int, b int, c int, err error) *MockRequesterReturnElided_Get_Call

func (*MockRequesterReturnElided_Get_Call) Run 

func (_c *MockRequesterReturnElided_Get_Call) Run(run func(path string)) *MockRequesterReturnElided_Get_Call

func (*MockRequesterReturnElided_Get_Call) RunAndReturn 

func (_c *MockRequesterReturnElided_Get_Call) RunAndReturn(run func(path string) (int, int, int, error)) *MockRequesterReturnElided_Get_Call

type MockRequesterReturnElided_Put_Call 

type MockRequesterReturnElided_Put_Call struct {
	*mock.Call
}

MockRequesterReturnElided_Put_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Put'

func (*MockRequesterReturnElided_Put_Call) Return 

func (_c *MockRequesterReturnElided_Put_Call) Return(n int, err error) *MockRequesterReturnElided_Put_Call

func (*MockRequesterReturnElided_Put_Call) Run 

func (_c *MockRequesterReturnElided_Put_Call) Run(run func(path string)) *MockRequesterReturnElided_Put_Call

func (*MockRequesterReturnElided_Put_Call) RunAndReturn 

func (_c *MockRequesterReturnElided_Put_Call) RunAndReturn(run func(path string) (int, error)) *MockRequesterReturnElided_Put_Call

type MockRequesterSlice 

type MockRequesterSlice struct {
	mock.Mock
}

MockRequesterSlice is an autogenerated mock type for the RequesterSlice type

func NewMockRequesterSlice 

func NewMockRequesterSlice(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterSlice

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 (*MockRequesterSlice) EXPECT 

func (_m *MockRequesterSlice) EXPECT() *MockRequesterSlice_Expecter

func (*MockRequesterSlice) Get 

func (_mock *MockRequesterSlice) Get(path string) ([]string, error)

Get provides a mock function for the type MockRequesterSlice

type MockRequesterSlice_Expecter 

type MockRequesterSlice_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequesterSlice_Expecter) Get 

func (_e *MockRequesterSlice_Expecter) Get(path interface{}) *MockRequesterSlice_Get_Call

Get is a helper method to define mock.On call

  • path

type MockRequesterSlice_Get_Call 

type MockRequesterSlice_Get_Call struct {
	*mock.Call
}

MockRequesterSlice_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequesterSlice_Get_Call) Return 

func (_c *MockRequesterSlice_Get_Call) Return(strings []string, err error) *MockRequesterSlice_Get_Call

func (*MockRequesterSlice_Get_Call) Run 

func (_c *MockRequesterSlice_Get_Call) Run(run func(path string)) *MockRequesterSlice_Get_Call

func (*MockRequesterSlice_Get_Call) RunAndReturn 

func (_c *MockRequesterSlice_Get_Call) RunAndReturn(run func(path string) ([]string, error)) *MockRequesterSlice_Get_Call

type MockRequesterVariadic 

type MockRequesterVariadic struct {
	mock.Mock
}

MockRequesterVariadic is an autogenerated mock type for the RequesterVariadic type

func NewMockRequesterVariadic 

func NewMockRequesterVariadic(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterVariadic

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 (*MockRequesterVariadic) EXPECT 

func (_m *MockRequesterVariadic) EXPECT() *MockRequesterVariadic_Expecter

func (*MockRequesterVariadic) Get 

func (_mock *MockRequesterVariadic) Get(values ...string) bool

Get provides a mock function for the type MockRequesterVariadic

func (*MockRequesterVariadic) MultiWriteToFile 

func (_mock *MockRequesterVariadic) MultiWriteToFile(filename string, w ...io.Writer) string

MultiWriteToFile provides a mock function for the type MockRequesterVariadic

func (*MockRequesterVariadic) OneInterface 

func (_mock *MockRequesterVariadic) OneInterface(a ...interface{}) bool

OneInterface provides a mock function for the type MockRequesterVariadic

func (*MockRequesterVariadic) Sprintf 

func (_mock *MockRequesterVariadic) Sprintf(format string, a ...interface{}) string

Sprintf provides a mock function for the type MockRequesterVariadic

type MockRequesterVariadicOneArgument 

type MockRequesterVariadicOneArgument struct {
	mock.Mock
}

MockRequesterVariadicOneArgument is an autogenerated mock type for the RequesterVariadic type

func NewMockRequesterVariadicOneArgument 

func NewMockRequesterVariadicOneArgument(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockRequesterVariadicOneArgument

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 (*MockRequesterVariadicOneArgument) EXPECT 

func (_m *MockRequesterVariadicOneArgument) EXPECT() *MockRequesterVariadicOneArgument_Expecter

func (*MockRequesterVariadicOneArgument) Get 

func (_mock *MockRequesterVariadicOneArgument) Get(values ...string) bool

Get provides a mock function for the type MockRequesterVariadicOneArgument

func (*MockRequesterVariadicOneArgument) MultiWriteToFile 

func (_mock *MockRequesterVariadicOneArgument) MultiWriteToFile(filename string, w ...io.Writer) string

MultiWriteToFile provides a mock function for the type MockRequesterVariadicOneArgument

func (*MockRequesterVariadicOneArgument) OneInterface 

func (_mock *MockRequesterVariadicOneArgument) OneInterface(a ...interface{}) bool

OneInterface provides a mock function for the type MockRequesterVariadicOneArgument

func (*MockRequesterVariadicOneArgument) Sprintf 

func (_mock *MockRequesterVariadicOneArgument) Sprintf(format string, a ...interface{}) string

Sprintf provides a mock function for the type MockRequesterVariadicOneArgument

type MockRequesterVariadicOneArgument_Expecter 

type MockRequesterVariadicOneArgument_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequesterVariadicOneArgument_Expecter) Get 

func (_e *MockRequesterVariadicOneArgument_Expecter) Get(values ...interface{}) *MockRequesterVariadicOneArgument_Get_Call

Get is a helper method to define mock.On call

  • values

func (*MockRequesterVariadicOneArgument_Expecter) MultiWriteToFile 

func (_e *MockRequesterVariadicOneArgument_Expecter) MultiWriteToFile(filename interface{}, w ...interface{}) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call

MultiWriteToFile is a helper method to define mock.On call

  • filename
  • w

func (*MockRequesterVariadicOneArgument_Expecter) OneInterface 

func (_e *MockRequesterVariadicOneArgument_Expecter) OneInterface(a ...interface{}) *MockRequesterVariadicOneArgument_OneInterface_Call

OneInterface is a helper method to define mock.On call

  • a

func (*MockRequesterVariadicOneArgument_Expecter) Sprintf 

func (_e *MockRequesterVariadicOneArgument_Expecter) Sprintf(format interface{}, a ...interface{}) *MockRequesterVariadicOneArgument_Sprintf_Call

Sprintf is a helper method to define mock.On call

  • format
  • a

type MockRequesterVariadicOneArgument_Get_Call 

type MockRequesterVariadicOneArgument_Get_Call struct {
	*mock.Call
}

MockRequesterVariadicOneArgument_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequesterVariadicOneArgument_Get_Call) Return 

func (_c *MockRequesterVariadicOneArgument_Get_Call) Return(b bool) *MockRequesterVariadicOneArgument_Get_Call

func (*MockRequesterVariadicOneArgument_Get_Call) Run 

func (_c *MockRequesterVariadicOneArgument_Get_Call) Run(run func(values ...string)) *MockRequesterVariadicOneArgument_Get_Call

func (*MockRequesterVariadicOneArgument_Get_Call) RunAndReturn 

func (_c *MockRequesterVariadicOneArgument_Get_Call) RunAndReturn(run func(values ...string) bool) *MockRequesterVariadicOneArgument_Get_Call

type MockRequesterVariadicOneArgument_MultiWriteToFile_Call 

type MockRequesterVariadicOneArgument_MultiWriteToFile_Call struct {
	*mock.Call
}

MockRequesterVariadicOneArgument_MultiWriteToFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiWriteToFile'

func (*MockRequesterVariadicOneArgument_MultiWriteToFile_Call) Return 

func (_c *MockRequesterVariadicOneArgument_MultiWriteToFile_Call) Return(s string) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call

func (*MockRequesterVariadicOneArgument_MultiWriteToFile_Call) Run 

func (_c *MockRequesterVariadicOneArgument_MultiWriteToFile_Call) Run(run func(filename string, w ...io.Writer)) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call

func (*MockRequesterVariadicOneArgument_MultiWriteToFile_Call) RunAndReturn 

func (_c *MockRequesterVariadicOneArgument_MultiWriteToFile_Call) RunAndReturn(run func(filename string, w ...io.Writer) string) *MockRequesterVariadicOneArgument_MultiWriteToFile_Call

type MockRequesterVariadicOneArgument_OneInterface_Call 

type MockRequesterVariadicOneArgument_OneInterface_Call struct {
	*mock.Call
}

MockRequesterVariadicOneArgument_OneInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OneInterface'

func (*MockRequesterVariadicOneArgument_OneInterface_Call) Return 

func (_c *MockRequesterVariadicOneArgument_OneInterface_Call) Return(b bool) *MockRequesterVariadicOneArgument_OneInterface_Call

func (*MockRequesterVariadicOneArgument_OneInterface_Call) Run 

func (_c *MockRequesterVariadicOneArgument_OneInterface_Call) Run(run func(a ...interface{})) *MockRequesterVariadicOneArgument_OneInterface_Call

func (*MockRequesterVariadicOneArgument_OneInterface_Call) RunAndReturn 

func (_c *MockRequesterVariadicOneArgument_OneInterface_Call) RunAndReturn(run func(a ...interface{}) bool) *MockRequesterVariadicOneArgument_OneInterface_Call

type MockRequesterVariadicOneArgument_Sprintf_Call 

type MockRequesterVariadicOneArgument_Sprintf_Call struct {
	*mock.Call
}

MockRequesterVariadicOneArgument_Sprintf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sprintf'

func (*MockRequesterVariadicOneArgument_Sprintf_Call) Return 

func (_c *MockRequesterVariadicOneArgument_Sprintf_Call) Return(s string) *MockRequesterVariadicOneArgument_Sprintf_Call

func (*MockRequesterVariadicOneArgument_Sprintf_Call) Run 

func (_c *MockRequesterVariadicOneArgument_Sprintf_Call) Run(run func(format string, a ...interface{})) *MockRequesterVariadicOneArgument_Sprintf_Call

func (*MockRequesterVariadicOneArgument_Sprintf_Call) RunAndReturn 

func (_c *MockRequesterVariadicOneArgument_Sprintf_Call) RunAndReturn(run func(format string, a ...interface{}) string) *MockRequesterVariadicOneArgument_Sprintf_Call

type MockRequesterVariadic_Expecter 

type MockRequesterVariadic_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequesterVariadic_Expecter) Get 

func (_e *MockRequesterVariadic_Expecter) Get(values ...interface{}) *MockRequesterVariadic_Get_Call

Get is a helper method to define mock.On call

  • values

func (*MockRequesterVariadic_Expecter) MultiWriteToFile 

func (_e *MockRequesterVariadic_Expecter) MultiWriteToFile(filename interface{}, w ...interface{}) *MockRequesterVariadic_MultiWriteToFile_Call

MultiWriteToFile is a helper method to define mock.On call

  • filename
  • w

func (*MockRequesterVariadic_Expecter) OneInterface 

func (_e *MockRequesterVariadic_Expecter) OneInterface(a ...interface{}) *MockRequesterVariadic_OneInterface_Call

OneInterface is a helper method to define mock.On call

  • a

func (*MockRequesterVariadic_Expecter) Sprintf 

func (_e *MockRequesterVariadic_Expecter) Sprintf(format interface{}, a ...interface{}) *MockRequesterVariadic_Sprintf_Call

Sprintf is a helper method to define mock.On call

  • format
  • a

type MockRequesterVariadic_Get_Call 

type MockRequesterVariadic_Get_Call struct {
	*mock.Call
}

MockRequesterVariadic_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequesterVariadic_Get_Call) Return 

func (_c *MockRequesterVariadic_Get_Call) Return(b bool) *MockRequesterVariadic_Get_Call

func (*MockRequesterVariadic_Get_Call) Run 

func (_c *MockRequesterVariadic_Get_Call) Run(run func(values ...string)) *MockRequesterVariadic_Get_Call

func (*MockRequesterVariadic_Get_Call) RunAndReturn 

func (_c *MockRequesterVariadic_Get_Call) RunAndReturn(run func(values ...string) bool) *MockRequesterVariadic_Get_Call

type MockRequesterVariadic_MultiWriteToFile_Call 

type MockRequesterVariadic_MultiWriteToFile_Call struct {
	*mock.Call
}

MockRequesterVariadic_MultiWriteToFile_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MultiWriteToFile'

func (*MockRequesterVariadic_MultiWriteToFile_Call) Return 

func (_c *MockRequesterVariadic_MultiWriteToFile_Call) Return(s string) *MockRequesterVariadic_MultiWriteToFile_Call

func (*MockRequesterVariadic_MultiWriteToFile_Call) Run 

func (_c *MockRequesterVariadic_MultiWriteToFile_Call) Run(run func(filename string, w ...io.Writer)) *MockRequesterVariadic_MultiWriteToFile_Call

func (*MockRequesterVariadic_MultiWriteToFile_Call) RunAndReturn 

func (_c *MockRequesterVariadic_MultiWriteToFile_Call) RunAndReturn(run func(filename string, w ...io.Writer) string) *MockRequesterVariadic_MultiWriteToFile_Call

type MockRequesterVariadic_OneInterface_Call 

type MockRequesterVariadic_OneInterface_Call struct {
	*mock.Call
}

MockRequesterVariadic_OneInterface_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OneInterface'

func (*MockRequesterVariadic_OneInterface_Call) Return 

func (_c *MockRequesterVariadic_OneInterface_Call) Return(b bool) *MockRequesterVariadic_OneInterface_Call

func (*MockRequesterVariadic_OneInterface_Call) Run 

func (_c *MockRequesterVariadic_OneInterface_Call) Run(run func(a ...interface{})) *MockRequesterVariadic_OneInterface_Call

func (*MockRequesterVariadic_OneInterface_Call) RunAndReturn 

func (_c *MockRequesterVariadic_OneInterface_Call) RunAndReturn(run func(a ...interface{}) bool) *MockRequesterVariadic_OneInterface_Call

type MockRequesterVariadic_Sprintf_Call 

type MockRequesterVariadic_Sprintf_Call struct {
	*mock.Call
}

MockRequesterVariadic_Sprintf_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Sprintf'

func (*MockRequesterVariadic_Sprintf_Call) Return 

func (_c *MockRequesterVariadic_Sprintf_Call) Return(s string) *MockRequesterVariadic_Sprintf_Call

func (*MockRequesterVariadic_Sprintf_Call) Run 

func (_c *MockRequesterVariadic_Sprintf_Call) Run(run func(format string, a ...interface{})) *MockRequesterVariadic_Sprintf_Call

func (*MockRequesterVariadic_Sprintf_Call) RunAndReturn 

func (_c *MockRequesterVariadic_Sprintf_Call) RunAndReturn(run func(format string, a ...interface{}) string) *MockRequesterVariadic_Sprintf_Call

type MockRequester_Expecter 

type MockRequester_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockRequester_Expecter) Get 

func (_e *MockRequester_Expecter) Get(path interface{}) *MockRequester_Get_Call

Get is a helper method to define mock.On call

  • path

type MockRequester_Get_Call 

type MockRequester_Get_Call struct {
	*mock.Call
}

MockRequester_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockRequester_Get_Call) Return 

func (_c *MockRequester_Get_Call) Return(s string, err error) *MockRequester_Get_Call

func (*MockRequester_Get_Call) Run 

func (_c *MockRequester_Get_Call) Run(run func(path string)) *MockRequester_Get_Call

func (*MockRequester_Get_Call) RunAndReturn 

func (_c *MockRequester_Get_Call) RunAndReturn(run func(path string) (string, error)) *MockRequester_Get_Call

type MockSibling 

type MockSibling struct {
	mock.Mock
}

MockSibling is an autogenerated mock type for the Sibling type

func NewMockSibling 

func NewMockSibling(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockSibling

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 (*MockSibling) DoSomething 

func (_mock *MockSibling) DoSomething()

DoSomething provides a mock function for the type MockSibling

func (*MockSibling) EXPECT 

func (_m *MockSibling) EXPECT() *MockSibling_Expecter

type MockSibling_DoSomething_Call 

type MockSibling_DoSomething_Call struct {
	*mock.Call
}

MockSibling_DoSomething_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoSomething'

func (*MockSibling_DoSomething_Call) Return 

func (_c *MockSibling_DoSomething_Call) Return() *MockSibling_DoSomething_Call

func (*MockSibling_DoSomething_Call) Run 

func (_c *MockSibling_DoSomething_Call) Run(run func()) *MockSibling_DoSomething_Call

func (*MockSibling_DoSomething_Call) RunAndReturn 

func (_c *MockSibling_DoSomething_Call) RunAndReturn(run func()) *MockSibling_DoSomething_Call

type MockSibling_Expecter 

type MockSibling_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockSibling_Expecter) DoSomething 

func (_e *MockSibling_Expecter) DoSomething() *MockSibling_DoSomething_Call

DoSomething is a helper method to define mock.On call

type MockStructWithTag 

type MockStructWithTag struct {
	mock.Mock
}

MockStructWithTag is an autogenerated mock type for the StructWithTag type

func NewMockStructWithTag 

func NewMockStructWithTag(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockStructWithTag

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 (*MockStructWithTag) EXPECT 

func (_m *MockStructWithTag) EXPECT() *MockStructWithTag_Expecter

func (*MockStructWithTag) MethodA 

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\""
}

MethodA provides a mock function for the type MockStructWithTag

type MockStructWithTag_Expecter 

type MockStructWithTag_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockStructWithTag_Expecter) MethodA 

func (_e *MockStructWithTag_Expecter) MethodA(v interface{}) *MockStructWithTag_MethodA_Call

MethodA is a helper method to define mock.On call

  • v

type MockStructWithTag_MethodA_Call 

type MockStructWithTag_MethodA_Call struct {
	*mock.Call
}

MockStructWithTag_MethodA_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'MethodA'

func (*MockStructWithTag_MethodA_Call) Return 

func (_c *MockStructWithTag_MethodA_Call) Return(val *struct {
	FieldC int "json:\"field_c\""
	FieldD int "json:\"field_d\" xml:\"field_d\""
}) *MockStructWithTag_MethodA_Call

func (*MockStructWithTag_MethodA_Call) Run 

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

func (*MockStructWithTag_MethodA_Call) RunAndReturn 

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

type MockUnsafeInterface 

type MockUnsafeInterface struct {
	mock.Mock
}

MockUnsafeInterface is an autogenerated mock type for the UnsafeInterface type

func NewMockUnsafeInterface 

func NewMockUnsafeInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockUnsafeInterface

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 (*MockUnsafeInterface) Do 

func (_mock *MockUnsafeInterface) Do(ptr *unsafe.Pointer)

Do provides a mock function for the type MockUnsafeInterface

func (*MockUnsafeInterface) EXPECT 

func (_m *MockUnsafeInterface) EXPECT() *MockUnsafeInterface_Expecter

type MockUnsafeInterface_Do_Call 

type MockUnsafeInterface_Do_Call struct {
	*mock.Call
}

MockUnsafeInterface_Do_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Do'

func (*MockUnsafeInterface_Do_Call) Return 

func (_c *MockUnsafeInterface_Do_Call) Return() *MockUnsafeInterface_Do_Call

func (*MockUnsafeInterface_Do_Call) Run 

func (_c *MockUnsafeInterface_Do_Call) Run(run func(ptr *unsafe.Pointer)) *MockUnsafeInterface_Do_Call

func (*MockUnsafeInterface_Do_Call) RunAndReturn 

func (_c *MockUnsafeInterface_Do_Call) RunAndReturn(run func(ptr *unsafe.Pointer)) *MockUnsafeInterface_Do_Call

type MockUnsafeInterface_Expecter 

type MockUnsafeInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockUnsafeInterface_Expecter) Do 

func (_e *MockUnsafeInterface_Expecter) Do(ptr interface{}) *MockUnsafeInterface_Do_Call

Do is a helper method to define mock.On call

  • ptr

type MockUsesAny 

type MockUsesAny struct {
	mock.Mock
}

MockUsesAny is an autogenerated mock type for the UsesAny type

func NewMockUsesAny 

func NewMockUsesAny(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockUsesAny

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 (*MockUsesAny) EXPECT 

func (_m *MockUsesAny) EXPECT() *MockUsesAny_Expecter

func (*MockUsesAny) GetReader 

func (_mock *MockUsesAny) GetReader() any

GetReader provides a mock function for the type MockUsesAny

type MockUsesAny_Expecter 

type MockUsesAny_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockUsesAny_Expecter) GetReader 

func (_e *MockUsesAny_Expecter) GetReader() *MockUsesAny_GetReader_Call

GetReader is a helper method to define mock.On call

type MockUsesAny_GetReader_Call 

type MockUsesAny_GetReader_Call struct {
	*mock.Call
}

MockUsesAny_GetReader_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetReader'

func (*MockUsesAny_GetReader_Call) Return 

func (_c *MockUsesAny_GetReader_Call) Return(v any) *MockUsesAny_GetReader_Call

func (*MockUsesAny_GetReader_Call) Run 

func (_c *MockUsesAny_GetReader_Call) Run(run func()) *MockUsesAny_GetReader_Call

func (*MockUsesAny_GetReader_Call) RunAndReturn 

func (_c *MockUsesAny_GetReader_Call) RunAndReturn(run func() any) *MockUsesAny_GetReader_Call

type MockUsesOtherPkgIface 

type MockUsesOtherPkgIface struct {
	mock.Mock
}

MockUsesOtherPkgIface is an autogenerated mock type for the UsesOtherPkgIface type

func NewMockUsesOtherPkgIface 

func NewMockUsesOtherPkgIface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockUsesOtherPkgIface

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 (*MockUsesOtherPkgIface) DoSomethingElse 

func (_mock *MockUsesOtherPkgIface) DoSomethingElse(obj Sibling)

DoSomethingElse provides a mock function for the type MockUsesOtherPkgIface

func (*MockUsesOtherPkgIface) EXPECT 

func (_m *MockUsesOtherPkgIface) EXPECT() *MockUsesOtherPkgIface_Expecter

type MockUsesOtherPkgIface_DoSomethingElse_Call 

type MockUsesOtherPkgIface_DoSomethingElse_Call struct {
	*mock.Call
}

MockUsesOtherPkgIface_DoSomethingElse_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DoSomethingElse'

func (*MockUsesOtherPkgIface_DoSomethingElse_Call) Return 

func (_c *MockUsesOtherPkgIface_DoSomethingElse_Call) Return() *MockUsesOtherPkgIface_DoSomethingElse_Call

func (*MockUsesOtherPkgIface_DoSomethingElse_Call) Run 

func (_c *MockUsesOtherPkgIface_DoSomethingElse_Call) Run(run func(obj Sibling)) *MockUsesOtherPkgIface_DoSomethingElse_Call

func (*MockUsesOtherPkgIface_DoSomethingElse_Call) RunAndReturn 

func (_c *MockUsesOtherPkgIface_DoSomethingElse_Call) RunAndReturn(run func(obj Sibling)) *MockUsesOtherPkgIface_DoSomethingElse_Call

type MockUsesOtherPkgIface_Expecter 

type MockUsesOtherPkgIface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockUsesOtherPkgIface_Expecter) DoSomethingElse 

func (_e *MockUsesOtherPkgIface_Expecter) DoSomethingElse(obj interface{}) *MockUsesOtherPkgIface_DoSomethingElse_Call

DoSomethingElse is a helper method to define mock.On call

  • obj

type MockVariadic 

type MockVariadic struct {
	mock.Mock
}

MockVariadic is an autogenerated mock type for the Variadic type

func NewMockVariadic 

func NewMockVariadic(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockVariadic

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 (*MockVariadic) EXPECT 

func (_m *MockVariadic) EXPECT() *MockVariadic_Expecter

func (*MockVariadic) VariadicFunction 

func (_mock *MockVariadic) VariadicFunction(str string, vFunc VariadicFunction) error

VariadicFunction provides a mock function for the type MockVariadic

type MockVariadicNoReturnInterface 

type MockVariadicNoReturnInterface struct {
	mock.Mock
}

MockVariadicNoReturnInterface is an autogenerated mock type for the VariadicNoReturnInterface type

func NewMockVariadicNoReturnInterface 

func NewMockVariadicNoReturnInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockVariadicNoReturnInterface

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 (*MockVariadicNoReturnInterface) EXPECT 

func (_m *MockVariadicNoReturnInterface) EXPECT() *MockVariadicNoReturnInterface_Expecter

func (*MockVariadicNoReturnInterface) VariadicNoReturn 

func (_mock *MockVariadicNoReturnInterface) VariadicNoReturn(j int, is ...interface{})

VariadicNoReturn provides a mock function for the type MockVariadicNoReturnInterface

type MockVariadicNoReturnInterface_Expecter 

type MockVariadicNoReturnInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockVariadicNoReturnInterface_Expecter) VariadicNoReturn 

func (_e *MockVariadicNoReturnInterface_Expecter) VariadicNoReturn(j interface{}, is ...interface{}) *MockVariadicNoReturnInterface_VariadicNoReturn_Call

VariadicNoReturn is a helper method to define mock.On call

  • j
  • is

type MockVariadicNoReturnInterface_VariadicNoReturn_Call 

type MockVariadicNoReturnInterface_VariadicNoReturn_Call struct {
	*mock.Call
}

MockVariadicNoReturnInterface_VariadicNoReturn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicNoReturn'

func (*MockVariadicNoReturnInterface_VariadicNoReturn_Call) Return 

func (_c *MockVariadicNoReturnInterface_VariadicNoReturn_Call) Return() *MockVariadicNoReturnInterface_VariadicNoReturn_Call

func (*MockVariadicNoReturnInterface_VariadicNoReturn_Call) Run 

func (_c *MockVariadicNoReturnInterface_VariadicNoReturn_Call) Run(run func(j int, is ...interface{})) *MockVariadicNoReturnInterface_VariadicNoReturn_Call

func (*MockVariadicNoReturnInterface_VariadicNoReturn_Call) RunAndReturn 

func (_c *MockVariadicNoReturnInterface_VariadicNoReturn_Call) RunAndReturn(run func(j int, is ...interface{})) *MockVariadicNoReturnInterface_VariadicNoReturn_Call

type MockVariadicReturnFunc 

type MockVariadicReturnFunc struct {
	mock.Mock
}

MockVariadicReturnFunc is an autogenerated mock type for the VariadicReturnFunc type

func NewMockVariadicReturnFunc 

func NewMockVariadicReturnFunc(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockVariadicReturnFunc

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 (*MockVariadicReturnFunc) EXPECT 

func (_m *MockVariadicReturnFunc) EXPECT() *MockVariadicReturnFunc_Expecter

func (*MockVariadicReturnFunc) SampleMethod 

func (_mock *MockVariadicReturnFunc) SampleMethod(str string) func(str string, arr []int, a ...interface{})

SampleMethod provides a mock function for the type MockVariadicReturnFunc

type MockVariadicReturnFunc_Expecter 

type MockVariadicReturnFunc_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockVariadicReturnFunc_Expecter) SampleMethod 

func (_e *MockVariadicReturnFunc_Expecter) SampleMethod(str interface{}) *MockVariadicReturnFunc_SampleMethod_Call

SampleMethod is a helper method to define mock.On call

  • str

type MockVariadicReturnFunc_SampleMethod_Call 

type MockVariadicReturnFunc_SampleMethod_Call struct {
	*mock.Call
}

MockVariadicReturnFunc_SampleMethod_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SampleMethod'

func (*MockVariadicReturnFunc_SampleMethod_Call) Return 

func (_c *MockVariadicReturnFunc_SampleMethod_Call) Return(fn func(str string, arr []int, a ...interface{})) *MockVariadicReturnFunc_SampleMethod_Call

func (*MockVariadicReturnFunc_SampleMethod_Call) Run 

func (_c *MockVariadicReturnFunc_SampleMethod_Call) Run(run func(str string)) *MockVariadicReturnFunc_SampleMethod_Call

func (*MockVariadicReturnFunc_SampleMethod_Call) RunAndReturn 

func (_c *MockVariadicReturnFunc_SampleMethod_Call) RunAndReturn(run func(str string) func(str string, arr []int, a ...interface{})) *MockVariadicReturnFunc_SampleMethod_Call

type MockVariadic_Expecter 

type MockVariadic_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockVariadic_Expecter) VariadicFunction 

func (_e *MockVariadic_Expecter) VariadicFunction(str interface{}, vFunc interface{}) *MockVariadic_VariadicFunction_Call

VariadicFunction is a helper method to define mock.On call

  • str
  • vFunc

type MockVariadic_VariadicFunction_Call 

type MockVariadic_VariadicFunction_Call struct {
	*mock.Call
}

MockVariadic_VariadicFunction_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VariadicFunction'

func (*MockVariadic_VariadicFunction_Call) Return 

func (_c *MockVariadic_VariadicFunction_Call) Return(err error) *MockVariadic_VariadicFunction_Call

func (*MockVariadic_VariadicFunction_Call) Run 

func (_c *MockVariadic_VariadicFunction_Call) Run(run func(str string, vFunc VariadicFunction)) *MockVariadic_VariadicFunction_Call

func (*MockVariadic_VariadicFunction_Call) RunAndReturn 

func (_c *MockVariadic_VariadicFunction_Call) RunAndReturn(run func(str string, vFunc VariadicFunction) error) *MockVariadic_VariadicFunction_Call

type MockrequesterUnexported 

type MockrequesterUnexported struct {
	mock.Mock
}

MockrequesterUnexported is an autogenerated mock type for the requesterUnexported type

func NewMockrequesterUnexported 

func NewMockrequesterUnexported(t interface {
	mock.TestingT
	Cleanup(func())
}) *MockrequesterUnexported

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 (*MockrequesterUnexported) EXPECT 

func (_m *MockrequesterUnexported) EXPECT() *MockrequesterUnexported_Expecter

func (*MockrequesterUnexported) Get 

func (_mock *MockrequesterUnexported) Get()

Get provides a mock function for the type MockrequesterUnexported

type MockrequesterUnexported_Expecter 

type MockrequesterUnexported_Expecter struct {
	// contains filtered or unexported fields
}

func (*MockrequesterUnexported_Expecter) Get 

func (_e *MockrequesterUnexported_Expecter) Get() *MockrequesterUnexported_Get_Call

Get is a helper method to define mock.On call

type MockrequesterUnexported_Get_Call 

type MockrequesterUnexported_Get_Call struct {
	*mock.Call
}

MockrequesterUnexported_Get_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Get'

func (*MockrequesterUnexported_Get_Call) Return 

func (_c *MockrequesterUnexported_Get_Call) Return() *MockrequesterUnexported_Get_Call

func (*MockrequesterUnexported_Get_Call) Run 

func (_c *MockrequesterUnexported_Get_Call) Run(run func()) *MockrequesterUnexported_Get_Call

func (*MockrequesterUnexported_Get_Call) RunAndReturn 

func (_c *MockrequesterUnexported_Get_Call) RunAndReturn(run func()) *MockrequesterUnexported_Get_Call

type MoqRequester 

type MoqRequester struct {
	// GetFunc mocks the Get method.
	GetFunc func(path string) (string, error)
	// contains filtered or unexported fields
}

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.

}

func (*MoqRequester) Get 

func (mock *MoqRequester) Get(path string) (string, error)

Get calls GetFunc.

func (*MoqRequester) GetCalls 

func (mock *MoqRequester) GetCalls() []struct {
	Path string
}

GetCalls gets all the calls that were made to Get. Check the length with: 

len(mockedRequester.GetCalls())

type MyReader 

type MyReader interface {
	io.Reader
}

type PanicOnNoReturnValue 

type PanicOnNoReturnValue interface {
	DoSomething() string
}

type ReplaceGeneric 

type ReplaceGeneric[
	TImport any,
	TConstraint constraints.Signed,
	TKeep any,
] interface {
	A(t1 TImport) TKeep
	B() TImport
	C() TConstraint
}

type ReplaceGenericSelf 

type ReplaceGenericSelf[T any] interface {
	A() T
}

type Requester 

type Requester interface {
	Get(path string) (string, error)
}

type Requester2 

type Requester2 interface {
	Get(path string) error
}

type Requester3 

type Requester3 interface {
	Get() error
}

type Requester4 

type Requester4 interface {
	Get()
}

type RequesterArgSameAsImport 

type RequesterArgSameAsImport interface {
	Get(json string) *json.RawMessage
}

type RequesterArgSameAsNamedImport 

type RequesterArgSameAsNamedImport interface {
	Get(json string) *json.RawMessage
}

type RequesterArgSameAsPkg 

type RequesterArgSameAsPkg interface {
	Get(test string)
}

type RequesterArray 

type RequesterArray interface {
	Get(path string) ([2]string, error)
}

type RequesterElided 

type RequesterElided interface {
	Get(path, url string) error
}

type RequesterGenerics 

type RequesterGenerics[
	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
	},
] interface {
	GenericArguments(TAny, TComparable) (TSigned, TIntf)
	GenericStructs(GenericType[TAny, TIntf]) GenericType[TSigned, TIntf]
	GenericAnonymousStructs(struct{ Type1 TExternalIntf }) struct {
		Type2 GenericType[string, EmbeddedGet[int]]
	}
}

type RequesterIface 

type RequesterIface interface {
	Get() io.Reader
}

type RequesterNS 

type RequesterNS interface {
	Get(path string) (http.Response, error)
}

type RequesterPtr 

type RequesterPtr interface {
	Get(path string) (*string, error)
}

type RequesterReturnElided 

type RequesterReturnElided interface {
	Get(path string) (a, b, c int, err error)
	Put(path string) (_ int, err error)
}

type RequesterSlice 

type RequesterSlice interface {
	Get(path string) ([]string, error)
}

type RequesterVariadic 

type RequesterVariadic interface {
	// cases: only variadic argument, w/ and w/out interface type
	Get(values ...string) bool
	OneInterface(a ...interface{}) bool

	// cases: normal argument + variadic argument, w/ and w/o interface type
	Sprintf(format string, a ...interface{}) string
	MultiWriteToFile(filename string, w ...io.Writer) string
}

type SendFunc 

type SendFunc func(ctx context.Context, data string) (int, error)

type Sibling 

type Sibling interface {
	DoSomething()
}

type StructWithTag 

type StructWithTag interface {
	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"`
	}
}

type UnsafeInterface 

type UnsafeInterface interface {
	Do(ptr *unsafe.Pointer)
}

type UsesAny 

type UsesAny interface {
	GetReader() any
}

type UsesOtherPkgIface 

type UsesOtherPkgIface interface {
	DoSomethingElse(obj Sibling)
}

type Variadic 

type Variadic interface {
	VariadicFunction(str string, vFunc VariadicFunction) error
}

type VariadicFunction 

type VariadicFunction = func(args1 string, args2 ...interface{}) interface{}

type VariadicNoReturnInterface 

type VariadicNoReturnInterface interface {
	VariadicNoReturn(j int, is ...interface{})
}

type VariadicReturnFunc 

type VariadicReturnFunc interface {
	SampleMethod(str string) func(str string, arr []int, a ...interface{})
}

Source Files

View all Source files

Directories

Path Synopsis
12345678
http
buildtag
comment
filename
bar/foo
baz
baz/internal/foo
context
foo
pkg_with_subpkgs
pkg_with_subpkgs/subpkg1
pkg_with_subpkgs/subpkg2
pkg_with_subpkgs/subpkg2/subpkg3
replace_type
replace_type/rti/internal
replace_type/rti/rt1
replace_type/rti/rt2
subpkg
method_args
same_name_arg_and_type
pkg_with_no_files
subpkg
subpkg1
subpkg2
subpkg_with_only_autogenerated_files
Code generated by an arbitrary code generator thingy.
 Code generated by an arbitrary code generator thingy.
subpkg

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.