exported

package
v0.25.0 Latest Latest
Warning

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

 Go to latest Published: Feb 19, 2023 License: BSD-3-Clause Imports: 7 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type MoqDifficultParamNamesFn 

type MoqDifficultParamNamesFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqDifficultParamNamesFn_mock

	ResultsByParams []MoqDifficultParamNamesFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct {
			Param1 moq.ParamIndexing
			Param2 moq.ParamIndexing
			Param3 moq.ParamIndexing
			Param  moq.ParamIndexing
			Param5 moq.ParamIndexing
			Param6 moq.ParamIndexing
			Param7 moq.ParamIndexing
			Param8 moq.ParamIndexing
			Param9 moq.ParamIndexing
		}
	}
}

MoqDifficultParamNamesFn holds the state of a moq of the DifficultParamNamesFn type

func NewMoqDifficultParamNamesFn 

func NewMoqDifficultParamNamesFn(scene *moq.Scene, config *moq.Config) *MoqDifficultParamNamesFn

NewMoqDifficultParamNamesFn creates a new moq of the DifficultParamNamesFn type

func (*MoqDifficultParamNamesFn) AssertExpectationsMet 

func (m *MoqDifficultParamNamesFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqDifficultParamNamesFn) Mock 

func (m *MoqDifficultParamNamesFn) Mock() testmoqs.DifficultParamNamesFn

Mock returns the moq implementation of the DifficultParamNamesFn type

func (*MoqDifficultParamNamesFn) OnCall 

func (m *MoqDifficultParamNamesFn) OnCall(param1, param2 bool, param3 string, param, param5, param6 int, param7, param8, param9 float32) *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn) ParamsKey 

func (m *MoqDifficultParamNamesFn) ParamsKey(params MoqDifficultParamNamesFn_params, anyParams uint64) MoqDifficultParamNamesFn_paramsKey

func (*MoqDifficultParamNamesFn) PrettyParams 

func (m *MoqDifficultParamNamesFn) PrettyParams(params MoqDifficultParamNamesFn_params) string

func (*MoqDifficultParamNamesFn) Reset 

func (m *MoqDifficultParamNamesFn) Reset()

Reset resets the state of the moq

type MoqDifficultParamNamesFn_anyParams 

type MoqDifficultParamNamesFn_anyParams struct {
	Recorder *MoqDifficultParamNamesFn_fnRecorder
}

MoqDifficultParamNamesFn_anyParams isolates the any params functions of the DifficultParamNamesFn type

func (*MoqDifficultParamNamesFn_anyParams) Param 

func (a *MoqDifficultParamNamesFn_anyParams) Param() *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_anyParams) Param1 

func (a *MoqDifficultParamNamesFn_anyParams) Param1() *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_anyParams) Param2 

func (a *MoqDifficultParamNamesFn_anyParams) Param2() *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_anyParams) Param3 

func (a *MoqDifficultParamNamesFn_anyParams) Param3() *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_anyParams) Param5 

func (a *MoqDifficultParamNamesFn_anyParams) Param5() *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_anyParams) Param6 

func (a *MoqDifficultParamNamesFn_anyParams) Param6() *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_anyParams) Param7 

func (a *MoqDifficultParamNamesFn_anyParams) Param7() *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_anyParams) Param8 

func (a *MoqDifficultParamNamesFn_anyParams) Param8() *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_anyParams) Param9 

func (a *MoqDifficultParamNamesFn_anyParams) Param9() *MoqDifficultParamNamesFn_fnRecorder

type MoqDifficultParamNamesFn_doFn 

type MoqDifficultParamNamesFn_doFn func(m, r bool, sequence string, param, params, i int, result, results, _ float32)

MoqDifficultParamNamesFn_doFn defines the type of function needed when calling AndDo for the DifficultParamNamesFn type

type MoqDifficultParamNamesFn_doReturnFn 

type MoqDifficultParamNamesFn_doReturnFn func(m, r bool, sequence string, param, params, i int, result, results, _ float32)

MoqDifficultParamNamesFn_doReturnFn defines the type of function needed when calling DoReturnResults for the DifficultParamNamesFn type

type MoqDifficultParamNamesFn_fnRecorder 

type MoqDifficultParamNamesFn_fnRecorder struct {
	Params    MoqDifficultParamNamesFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqDifficultParamNamesFn_results
	Moq       *MoqDifficultParamNamesFn
}

MoqDifficultParamNamesFn_fnRecorder routes recorded function calls to the MoqDifficultParamNamesFn moq

func (*MoqDifficultParamNamesFn_fnRecorder) AndDo 

func (r *MoqDifficultParamNamesFn_fnRecorder) AndDo(fn MoqDifficultParamNamesFn_doFn) *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_fnRecorder) Any 

func (r *MoqDifficultParamNamesFn_fnRecorder) Any() *MoqDifficultParamNamesFn_anyParams

func (*MoqDifficultParamNamesFn_fnRecorder) DoReturnResults 

func (r *MoqDifficultParamNamesFn_fnRecorder) DoReturnResults(fn MoqDifficultParamNamesFn_doReturnFn) *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_fnRecorder) FindResults 

func (r *MoqDifficultParamNamesFn_fnRecorder) FindResults()

func (*MoqDifficultParamNamesFn_fnRecorder) NoSeq 

func (r *MoqDifficultParamNamesFn_fnRecorder) NoSeq() *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_fnRecorder) Repeat 

func (r *MoqDifficultParamNamesFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_fnRecorder) ReturnResults 

func (r *MoqDifficultParamNamesFn_fnRecorder) ReturnResults() *MoqDifficultParamNamesFn_fnRecorder

func (*MoqDifficultParamNamesFn_fnRecorder) Seq 

func (r *MoqDifficultParamNamesFn_fnRecorder) Seq() *MoqDifficultParamNamesFn_fnRecorder

type MoqDifficultParamNamesFn_mock 

type MoqDifficultParamNamesFn_mock struct {
	Moq *MoqDifficultParamNamesFn
}

MoqDifficultParamNamesFn_mock isolates the mock interface of the DifficultParamNamesFn type

func (*MoqDifficultParamNamesFn_mock) Fn 

func (m *MoqDifficultParamNamesFn_mock) Fn(param1, param2 bool, param3 string, param, param5, param6 int, param7, param8, param9 float32)

type MoqDifficultParamNamesFn_params 

type MoqDifficultParamNamesFn_params struct {
	Param1, Param2         bool
	Param3                 string
	Param, Param5, Param6  int
	Param7, Param8, Param9 float32
}

MoqDifficultParamNamesFn_params holds the params of the DifficultParamNamesFn type

type MoqDifficultParamNamesFn_paramsKey 

type MoqDifficultParamNamesFn_paramsKey struct {
	Params struct {
		Param1, Param2         bool
		Param3                 string
		Param, Param5, Param6  int
		Param7, Param8, Param9 float32
	}
	Hashes struct {
		Param1, Param2         hash.Hash
		Param3                 hash.Hash
		Param, Param5, Param6  hash.Hash
		Param7, Param8, Param9 hash.Hash
	}
}

MoqDifficultParamNamesFn_paramsKey holds the map key params of the DifficultParamNamesFn type

type MoqDifficultParamNamesFn_results 

type MoqDifficultParamNamesFn_results struct {
	Params  MoqDifficultParamNamesFn_params
	Results []struct {
		Values     *struct{}
		Sequence   uint32
		DoFn       MoqDifficultParamNamesFn_doFn
		DoReturnFn MoqDifficultParamNamesFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqDifficultParamNamesFn_results holds the results of the DifficultParamNamesFn type

type MoqDifficultParamNamesFn_resultsByParams 

type MoqDifficultParamNamesFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqDifficultParamNamesFn_paramsKey]*MoqDifficultParamNamesFn_results
}

MoqDifficultParamNamesFn_resultsByParams contains the results for a given set of parameters for the DifficultParamNamesFn type

type MoqDifficultResultNamesFn 

type MoqDifficultResultNamesFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqDifficultResultNamesFn_mock

	ResultsByParams []MoqDifficultResultNamesFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct{}
	}
}

MoqDifficultResultNamesFn holds the state of a moq of the DifficultResultNamesFn type

func NewMoqDifficultResultNamesFn 

func NewMoqDifficultResultNamesFn(scene *moq.Scene, config *moq.Config) *MoqDifficultResultNamesFn

NewMoqDifficultResultNamesFn creates a new moq of the DifficultResultNamesFn type

func (*MoqDifficultResultNamesFn) AssertExpectationsMet 

func (m *MoqDifficultResultNamesFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqDifficultResultNamesFn) Mock 

func (m *MoqDifficultResultNamesFn) Mock() testmoqs.DifficultResultNamesFn

Mock returns the moq implementation of the DifficultResultNamesFn type

func (*MoqDifficultResultNamesFn) OnCall 

func (m *MoqDifficultResultNamesFn) OnCall() *MoqDifficultResultNamesFn_fnRecorder

func (*MoqDifficultResultNamesFn) ParamsKey 

func (m *MoqDifficultResultNamesFn) ParamsKey(params MoqDifficultResultNamesFn_params, anyParams uint64) MoqDifficultResultNamesFn_paramsKey

func (*MoqDifficultResultNamesFn) PrettyParams 

func (m *MoqDifficultResultNamesFn) PrettyParams(params MoqDifficultResultNamesFn_params) string

func (*MoqDifficultResultNamesFn) Reset 

func (m *MoqDifficultResultNamesFn) Reset()

Reset resets the state of the moq

type MoqDifficultResultNamesFn_anyParams 

type MoqDifficultResultNamesFn_anyParams struct {
	Recorder *MoqDifficultResultNamesFn_fnRecorder
}

MoqDifficultResultNamesFn_anyParams isolates the any params functions of the DifficultResultNamesFn type

type MoqDifficultResultNamesFn_doFn 

type MoqDifficultResultNamesFn_doFn func()

MoqDifficultResultNamesFn_doFn defines the type of function needed when calling AndDo for the DifficultResultNamesFn type

type MoqDifficultResultNamesFn_doReturnFn 

type MoqDifficultResultNamesFn_doReturnFn func() (m, r string, sequence error, param, params, i int, result, results, _ float32)

MoqDifficultResultNamesFn_doReturnFn defines the type of function needed when calling DoReturnResults for the DifficultResultNamesFn type

type MoqDifficultResultNamesFn_fnRecorder 

type MoqDifficultResultNamesFn_fnRecorder struct {
	Params    MoqDifficultResultNamesFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqDifficultResultNamesFn_results
	Moq       *MoqDifficultResultNamesFn
}

MoqDifficultResultNamesFn_fnRecorder routes recorded function calls to the MoqDifficultResultNamesFn moq

func (*MoqDifficultResultNamesFn_fnRecorder) AndDo 

func (r *MoqDifficultResultNamesFn_fnRecorder) AndDo(fn MoqDifficultResultNamesFn_doFn) *MoqDifficultResultNamesFn_fnRecorder

func (*MoqDifficultResultNamesFn_fnRecorder) Any 

func (r *MoqDifficultResultNamesFn_fnRecorder) Any() *MoqDifficultResultNamesFn_anyParams

func (*MoqDifficultResultNamesFn_fnRecorder) DoReturnResults 

func (r *MoqDifficultResultNamesFn_fnRecorder) DoReturnResults(fn MoqDifficultResultNamesFn_doReturnFn) *MoqDifficultResultNamesFn_fnRecorder

func (*MoqDifficultResultNamesFn_fnRecorder) FindResults 

func (r *MoqDifficultResultNamesFn_fnRecorder) FindResults()

func (*MoqDifficultResultNamesFn_fnRecorder) NoSeq 

func (r *MoqDifficultResultNamesFn_fnRecorder) NoSeq() *MoqDifficultResultNamesFn_fnRecorder

func (*MoqDifficultResultNamesFn_fnRecorder) Repeat 

func (r *MoqDifficultResultNamesFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqDifficultResultNamesFn_fnRecorder

func (*MoqDifficultResultNamesFn_fnRecorder) ReturnResults 

func (r *MoqDifficultResultNamesFn_fnRecorder) ReturnResults(result1, result2 string, result3 error, param, result5, result6 int, result7, result8, result9 float32) *MoqDifficultResultNamesFn_fnRecorder

func (*MoqDifficultResultNamesFn_fnRecorder) Seq 

func (r *MoqDifficultResultNamesFn_fnRecorder) Seq() *MoqDifficultResultNamesFn_fnRecorder

type MoqDifficultResultNamesFn_mock 

type MoqDifficultResultNamesFn_mock struct {
	Moq *MoqDifficultResultNamesFn
}

MoqDifficultResultNamesFn_mock isolates the mock interface of the DifficultResultNamesFn type

func (*MoqDifficultResultNamesFn_mock) Fn 

func (m *MoqDifficultResultNamesFn_mock) Fn() (result1, result2 string, result3 error, param, result5, result6 int, result7, result8, result9 float32)

type MoqDifficultResultNamesFn_params 

type MoqDifficultResultNamesFn_params struct{}

MoqDifficultResultNamesFn_params holds the params of the DifficultResultNamesFn type

type MoqDifficultResultNamesFn_paramsKey 

type MoqDifficultResultNamesFn_paramsKey struct {
	Params struct{}
	Hashes struct{}
}

MoqDifficultResultNamesFn_paramsKey holds the map key params of the DifficultResultNamesFn type

type MoqDifficultResultNamesFn_results 

type MoqDifficultResultNamesFn_results struct {
	Params  MoqDifficultResultNamesFn_params
	Results []struct {
		Values *struct {
			Result1, Result2          string
			Result3                   error
			Param, Result5, Result6   int
			Result7, Result8, Result9 float32
		}
		Sequence   uint32
		DoFn       MoqDifficultResultNamesFn_doFn
		DoReturnFn MoqDifficultResultNamesFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqDifficultResultNamesFn_results holds the results of the DifficultResultNamesFn type

type MoqDifficultResultNamesFn_resultsByParams 

type MoqDifficultResultNamesFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqDifficultResultNamesFn_paramsKey]*MoqDifficultResultNamesFn_results
}

MoqDifficultResultNamesFn_resultsByParams contains the results for a given set of parameters for the DifficultResultNamesFn type

type MoqInterfaceParamFn 

type MoqInterfaceParamFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqInterfaceParamFn_mock

	ResultsByParams []MoqInterfaceParamFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct {
			W moq.ParamIndexing
		}
	}
}

MoqInterfaceParamFn holds the state of a moq of the InterfaceParamFn type

func NewMoqInterfaceParamFn 

func NewMoqInterfaceParamFn(scene *moq.Scene, config *moq.Config) *MoqInterfaceParamFn

NewMoqInterfaceParamFn creates a new moq of the InterfaceParamFn type

func (*MoqInterfaceParamFn) AssertExpectationsMet 

func (m *MoqInterfaceParamFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqInterfaceParamFn) Mock 

func (m *MoqInterfaceParamFn) Mock() testmoqs.InterfaceParamFn

Mock returns the moq implementation of the InterfaceParamFn type

func (*MoqInterfaceParamFn) OnCall 

func (m *MoqInterfaceParamFn) OnCall(w io.Writer) *MoqInterfaceParamFn_fnRecorder

func (*MoqInterfaceParamFn) ParamsKey 

func (m *MoqInterfaceParamFn) ParamsKey(params MoqInterfaceParamFn_params, anyParams uint64) MoqInterfaceParamFn_paramsKey

func (*MoqInterfaceParamFn) PrettyParams 

func (m *MoqInterfaceParamFn) PrettyParams(params MoqInterfaceParamFn_params) string

func (*MoqInterfaceParamFn) Reset 

func (m *MoqInterfaceParamFn) Reset()

Reset resets the state of the moq

type MoqInterfaceParamFn_anyParams 

type MoqInterfaceParamFn_anyParams struct {
	Recorder *MoqInterfaceParamFn_fnRecorder
}

MoqInterfaceParamFn_anyParams isolates the any params functions of the InterfaceParamFn type

func (*MoqInterfaceParamFn_anyParams) W 

func (a *MoqInterfaceParamFn_anyParams) W() *MoqInterfaceParamFn_fnRecorder

type MoqInterfaceParamFn_doFn 

type MoqInterfaceParamFn_doFn func(w io.Writer)

MoqInterfaceParamFn_doFn defines the type of function needed when calling AndDo for the InterfaceParamFn type

type MoqInterfaceParamFn_doReturnFn 

type MoqInterfaceParamFn_doReturnFn func(w io.Writer) (sResult string, err error)

MoqInterfaceParamFn_doReturnFn defines the type of function needed when calling DoReturnResults for the InterfaceParamFn type

type MoqInterfaceParamFn_fnRecorder 

type MoqInterfaceParamFn_fnRecorder struct {
	Params    MoqInterfaceParamFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqInterfaceParamFn_results
	Moq       *MoqInterfaceParamFn
}

MoqInterfaceParamFn_fnRecorder routes recorded function calls to the MoqInterfaceParamFn moq

func (*MoqInterfaceParamFn_fnRecorder) AndDo 

func (r *MoqInterfaceParamFn_fnRecorder) AndDo(fn MoqInterfaceParamFn_doFn) *MoqInterfaceParamFn_fnRecorder

func (*MoqInterfaceParamFn_fnRecorder) Any 

func (r *MoqInterfaceParamFn_fnRecorder) Any() *MoqInterfaceParamFn_anyParams

func (*MoqInterfaceParamFn_fnRecorder) DoReturnResults 

func (r *MoqInterfaceParamFn_fnRecorder) DoReturnResults(fn MoqInterfaceParamFn_doReturnFn) *MoqInterfaceParamFn_fnRecorder

func (*MoqInterfaceParamFn_fnRecorder) FindResults 

func (r *MoqInterfaceParamFn_fnRecorder) FindResults()

func (*MoqInterfaceParamFn_fnRecorder) NoSeq 

func (r *MoqInterfaceParamFn_fnRecorder) NoSeq() *MoqInterfaceParamFn_fnRecorder

func (*MoqInterfaceParamFn_fnRecorder) Repeat 

func (r *MoqInterfaceParamFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqInterfaceParamFn_fnRecorder

func (*MoqInterfaceParamFn_fnRecorder) ReturnResults 

func (r *MoqInterfaceParamFn_fnRecorder) ReturnResults(sResult string, err error) *MoqInterfaceParamFn_fnRecorder

func (*MoqInterfaceParamFn_fnRecorder) Seq 

func (r *MoqInterfaceParamFn_fnRecorder) Seq() *MoqInterfaceParamFn_fnRecorder

type MoqInterfaceParamFn_mock 

type MoqInterfaceParamFn_mock struct {
	Moq *MoqInterfaceParamFn
}

MoqInterfaceParamFn_mock isolates the mock interface of the InterfaceParamFn type

func (*MoqInterfaceParamFn_mock) Fn 

func (m *MoqInterfaceParamFn_mock) Fn(w io.Writer) (sResult string, err error)

type MoqInterfaceParamFn_params 

type MoqInterfaceParamFn_params struct{ W io.Writer }

MoqInterfaceParamFn_params holds the params of the InterfaceParamFn type

type MoqInterfaceParamFn_paramsKey 

type MoqInterfaceParamFn_paramsKey struct {
	Params struct{ W io.Writer }
	Hashes struct{ W hash.Hash }
}

MoqInterfaceParamFn_paramsKey holds the map key params of the InterfaceParamFn type

type MoqInterfaceParamFn_results 

type MoqInterfaceParamFn_results struct {
	Params  MoqInterfaceParamFn_params
	Results []struct {
		Values *struct {
			SResult string
			Err     error
		}
		Sequence   uint32
		DoFn       MoqInterfaceParamFn_doFn
		DoReturnFn MoqInterfaceParamFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqInterfaceParamFn_results holds the results of the InterfaceParamFn type

type MoqInterfaceParamFn_resultsByParams 

type MoqInterfaceParamFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqInterfaceParamFn_paramsKey]*MoqInterfaceParamFn_results
}

MoqInterfaceParamFn_resultsByParams contains the results for a given set of parameters for the InterfaceParamFn type

type MoqInterfaceResultFn 

type MoqInterfaceResultFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqInterfaceResultFn_mock

	ResultsByParams []MoqInterfaceResultFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct {
			SParam moq.ParamIndexing
			BParam moq.ParamIndexing
		}
	}
}

MoqInterfaceResultFn holds the state of a moq of the InterfaceResultFn type

func NewMoqInterfaceResultFn 

func NewMoqInterfaceResultFn(scene *moq.Scene, config *moq.Config) *MoqInterfaceResultFn

NewMoqInterfaceResultFn creates a new moq of the InterfaceResultFn type

func (*MoqInterfaceResultFn) AssertExpectationsMet 

func (m *MoqInterfaceResultFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqInterfaceResultFn) Mock 

func (m *MoqInterfaceResultFn) Mock() testmoqs.InterfaceResultFn

Mock returns the moq implementation of the InterfaceResultFn type

func (*MoqInterfaceResultFn) OnCall 

func (m *MoqInterfaceResultFn) OnCall(sParam string, bParam bool) *MoqInterfaceResultFn_fnRecorder

func (*MoqInterfaceResultFn) ParamsKey 

func (m *MoqInterfaceResultFn) ParamsKey(params MoqInterfaceResultFn_params, anyParams uint64) MoqInterfaceResultFn_paramsKey

func (*MoqInterfaceResultFn) PrettyParams 

func (m *MoqInterfaceResultFn) PrettyParams(params MoqInterfaceResultFn_params) string

func (*MoqInterfaceResultFn) Reset 

func (m *MoqInterfaceResultFn) Reset()

Reset resets the state of the moq

type MoqInterfaceResultFn_anyParams 

type MoqInterfaceResultFn_anyParams struct {
	Recorder *MoqInterfaceResultFn_fnRecorder
}

MoqInterfaceResultFn_anyParams isolates the any params functions of the InterfaceResultFn type

func (*MoqInterfaceResultFn_anyParams) BParam 

func (a *MoqInterfaceResultFn_anyParams) BParam() *MoqInterfaceResultFn_fnRecorder

func (*MoqInterfaceResultFn_anyParams) SParam 

func (a *MoqInterfaceResultFn_anyParams) SParam() *MoqInterfaceResultFn_fnRecorder

type MoqInterfaceResultFn_doFn 

type MoqInterfaceResultFn_doFn func(sParam string, bParam bool)

MoqInterfaceResultFn_doFn defines the type of function needed when calling AndDo for the InterfaceResultFn type

type MoqInterfaceResultFn_doReturnFn 

type MoqInterfaceResultFn_doReturnFn func(sParam string, bParam bool) (r io.Reader)

MoqInterfaceResultFn_doReturnFn defines the type of function needed when calling DoReturnResults for the InterfaceResultFn type

type MoqInterfaceResultFn_fnRecorder 

type MoqInterfaceResultFn_fnRecorder struct {
	Params    MoqInterfaceResultFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqInterfaceResultFn_results
	Moq       *MoqInterfaceResultFn
}

MoqInterfaceResultFn_fnRecorder routes recorded function calls to the MoqInterfaceResultFn moq

func (*MoqInterfaceResultFn_fnRecorder) AndDo 

func (r *MoqInterfaceResultFn_fnRecorder) AndDo(fn MoqInterfaceResultFn_doFn) *MoqInterfaceResultFn_fnRecorder

func (*MoqInterfaceResultFn_fnRecorder) Any 

func (r *MoqInterfaceResultFn_fnRecorder) Any() *MoqInterfaceResultFn_anyParams

func (*MoqInterfaceResultFn_fnRecorder) DoReturnResults 

func (r *MoqInterfaceResultFn_fnRecorder) DoReturnResults(fn MoqInterfaceResultFn_doReturnFn) *MoqInterfaceResultFn_fnRecorder

func (*MoqInterfaceResultFn_fnRecorder) FindResults 

func (r *MoqInterfaceResultFn_fnRecorder) FindResults()

func (*MoqInterfaceResultFn_fnRecorder) NoSeq 

func (r *MoqInterfaceResultFn_fnRecorder) NoSeq() *MoqInterfaceResultFn_fnRecorder

func (*MoqInterfaceResultFn_fnRecorder) Repeat 

func (r *MoqInterfaceResultFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqInterfaceResultFn_fnRecorder

func (*MoqInterfaceResultFn_fnRecorder) ReturnResults 

func (r *MoqInterfaceResultFn_fnRecorder) ReturnResults(result1 io.Reader) *MoqInterfaceResultFn_fnRecorder

func (*MoqInterfaceResultFn_fnRecorder) Seq 

func (r *MoqInterfaceResultFn_fnRecorder) Seq() *MoqInterfaceResultFn_fnRecorder

type MoqInterfaceResultFn_mock 

type MoqInterfaceResultFn_mock struct {
	Moq *MoqInterfaceResultFn
}

MoqInterfaceResultFn_mock isolates the mock interface of the InterfaceResultFn type

func (*MoqInterfaceResultFn_mock) Fn 

func (m *MoqInterfaceResultFn_mock) Fn(sParam string, bParam bool) (result1 io.Reader)

type MoqInterfaceResultFn_params 

type MoqInterfaceResultFn_params struct {
	SParam string
	BParam bool
}

MoqInterfaceResultFn_params holds the params of the InterfaceResultFn type

type MoqInterfaceResultFn_paramsKey 

type MoqInterfaceResultFn_paramsKey struct {
	Params struct {
		SParam string
		BParam bool
	}
	Hashes struct {
		SParam hash.Hash
		BParam hash.Hash
	}
}

MoqInterfaceResultFn_paramsKey holds the map key params of the InterfaceResultFn type

type MoqInterfaceResultFn_results 

type MoqInterfaceResultFn_results struct {
	Params  MoqInterfaceResultFn_params
	Results []struct {
		Values     *struct{ Result1 io.Reader }
		Sequence   uint32
		DoFn       MoqInterfaceResultFn_doFn
		DoReturnFn MoqInterfaceResultFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqInterfaceResultFn_results holds the results of the InterfaceResultFn type

type MoqInterfaceResultFn_resultsByParams 

type MoqInterfaceResultFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqInterfaceResultFn_paramsKey]*MoqInterfaceResultFn_results
}

MoqInterfaceResultFn_resultsByParams contains the results for a given set of parameters for the InterfaceResultFn type

type MoqNoNamesFn 

type MoqNoNamesFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqNoNamesFn_mock

	ResultsByParams []MoqNoNamesFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct {
			Param1 moq.ParamIndexing
			Param2 moq.ParamIndexing
		}
	}
}

MoqNoNamesFn holds the state of a moq of the NoNamesFn type

func NewMoqNoNamesFn 

func NewMoqNoNamesFn(scene *moq.Scene, config *moq.Config) *MoqNoNamesFn

NewMoqNoNamesFn creates a new moq of the NoNamesFn type

func (*MoqNoNamesFn) AssertExpectationsMet 

func (m *MoqNoNamesFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqNoNamesFn) Mock 

func (m *MoqNoNamesFn) Mock() testmoqs.NoNamesFn

Mock returns the moq implementation of the NoNamesFn type

func (*MoqNoNamesFn) OnCall 

func (m *MoqNoNamesFn) OnCall(param1 string, param2 bool) *MoqNoNamesFn_fnRecorder

func (*MoqNoNamesFn) ParamsKey 

func (m *MoqNoNamesFn) ParamsKey(params MoqNoNamesFn_params, anyParams uint64) MoqNoNamesFn_paramsKey

func (*MoqNoNamesFn) PrettyParams 

func (m *MoqNoNamesFn) PrettyParams(params MoqNoNamesFn_params) string

func (*MoqNoNamesFn) Reset 

func (m *MoqNoNamesFn) Reset()

Reset resets the state of the moq

type MoqNoNamesFn_anyParams 

type MoqNoNamesFn_anyParams struct {
	Recorder *MoqNoNamesFn_fnRecorder
}

MoqNoNamesFn_anyParams isolates the any params functions of the NoNamesFn type

func (*MoqNoNamesFn_anyParams) Param1 

func (a *MoqNoNamesFn_anyParams) Param1() *MoqNoNamesFn_fnRecorder

func (*MoqNoNamesFn_anyParams) Param2 

func (a *MoqNoNamesFn_anyParams) Param2() *MoqNoNamesFn_fnRecorder

type MoqNoNamesFn_doFn 

type MoqNoNamesFn_doFn func(string, bool)

MoqNoNamesFn_doFn defines the type of function needed when calling AndDo for the NoNamesFn type

type MoqNoNamesFn_doReturnFn 

type MoqNoNamesFn_doReturnFn func(string, bool) (string, error)

MoqNoNamesFn_doReturnFn defines the type of function needed when calling DoReturnResults for the NoNamesFn type

type MoqNoNamesFn_fnRecorder 

type MoqNoNamesFn_fnRecorder struct {
	Params    MoqNoNamesFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqNoNamesFn_results
	Moq       *MoqNoNamesFn
}

MoqNoNamesFn_fnRecorder routes recorded function calls to the MoqNoNamesFn moq

func (*MoqNoNamesFn_fnRecorder) AndDo 

func (r *MoqNoNamesFn_fnRecorder) AndDo(fn MoqNoNamesFn_doFn) *MoqNoNamesFn_fnRecorder

func (*MoqNoNamesFn_fnRecorder) Any 

func (r *MoqNoNamesFn_fnRecorder) Any() *MoqNoNamesFn_anyParams

func (*MoqNoNamesFn_fnRecorder) DoReturnResults 

func (r *MoqNoNamesFn_fnRecorder) DoReturnResults(fn MoqNoNamesFn_doReturnFn) *MoqNoNamesFn_fnRecorder

func (*MoqNoNamesFn_fnRecorder) FindResults 

func (r *MoqNoNamesFn_fnRecorder) FindResults()

func (*MoqNoNamesFn_fnRecorder) NoSeq 

func (r *MoqNoNamesFn_fnRecorder) NoSeq() *MoqNoNamesFn_fnRecorder

func (*MoqNoNamesFn_fnRecorder) Repeat 

func (r *MoqNoNamesFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqNoNamesFn_fnRecorder

func (*MoqNoNamesFn_fnRecorder) ReturnResults 

func (r *MoqNoNamesFn_fnRecorder) ReturnResults(result1 string, result2 error) *MoqNoNamesFn_fnRecorder

func (*MoqNoNamesFn_fnRecorder) Seq 

func (r *MoqNoNamesFn_fnRecorder) Seq() *MoqNoNamesFn_fnRecorder

type MoqNoNamesFn_mock 

type MoqNoNamesFn_mock struct {
	Moq *MoqNoNamesFn
}

MoqNoNamesFn_mock isolates the mock interface of the NoNamesFn type

func (*MoqNoNamesFn_mock) Fn 

func (m *MoqNoNamesFn_mock) Fn(param1 string, param2 bool) (result1 string, result2 error)

type MoqNoNamesFn_params 

type MoqNoNamesFn_params struct {
	Param1 string
	Param2 bool
}

MoqNoNamesFn_params holds the params of the NoNamesFn type

type MoqNoNamesFn_paramsKey 

type MoqNoNamesFn_paramsKey struct {
	Params struct {
		Param1 string
		Param2 bool
	}
	Hashes struct {
		Param1 hash.Hash
		Param2 hash.Hash
	}
}

MoqNoNamesFn_paramsKey holds the map key params of the NoNamesFn type

type MoqNoNamesFn_results 

type MoqNoNamesFn_results struct {
	Params  MoqNoNamesFn_params
	Results []struct {
		Values *struct {
			Result1 string
			Result2 error
		}
		Sequence   uint32
		DoFn       MoqNoNamesFn_doFn
		DoReturnFn MoqNoNamesFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqNoNamesFn_results holds the results of the NoNamesFn type

type MoqNoNamesFn_resultsByParams 

type MoqNoNamesFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqNoNamesFn_paramsKey]*MoqNoNamesFn_results
}

MoqNoNamesFn_resultsByParams contains the results for a given set of parameters for the NoNamesFn type

type MoqNoParamsFn 

type MoqNoParamsFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqNoParamsFn_mock

	ResultsByParams []MoqNoParamsFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct{}
	}
}

MoqNoParamsFn holds the state of a moq of the NoParamsFn type

func NewMoqNoParamsFn 

func NewMoqNoParamsFn(scene *moq.Scene, config *moq.Config) *MoqNoParamsFn

NewMoqNoParamsFn creates a new moq of the NoParamsFn type

func (*MoqNoParamsFn) AssertExpectationsMet 

func (m *MoqNoParamsFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqNoParamsFn) Mock 

func (m *MoqNoParamsFn) Mock() testmoqs.NoParamsFn

Mock returns the moq implementation of the NoParamsFn type

func (*MoqNoParamsFn) OnCall 

func (m *MoqNoParamsFn) OnCall() *MoqNoParamsFn_fnRecorder

func (*MoqNoParamsFn) ParamsKey 

func (m *MoqNoParamsFn) ParamsKey(params MoqNoParamsFn_params, anyParams uint64) MoqNoParamsFn_paramsKey

func (*MoqNoParamsFn) PrettyParams 

func (m *MoqNoParamsFn) PrettyParams(params MoqNoParamsFn_params) string

func (*MoqNoParamsFn) Reset 

func (m *MoqNoParamsFn) Reset()

Reset resets the state of the moq

type MoqNoParamsFn_anyParams 

type MoqNoParamsFn_anyParams struct {
	Recorder *MoqNoParamsFn_fnRecorder
}

MoqNoParamsFn_anyParams isolates the any params functions of the NoParamsFn type

type MoqNoParamsFn_doFn 

type MoqNoParamsFn_doFn func()

MoqNoParamsFn_doFn defines the type of function needed when calling AndDo for the NoParamsFn type

type MoqNoParamsFn_doReturnFn 

type MoqNoParamsFn_doReturnFn func() (sResult string, err error)

MoqNoParamsFn_doReturnFn defines the type of function needed when calling DoReturnResults for the NoParamsFn type

type MoqNoParamsFn_fnRecorder 

type MoqNoParamsFn_fnRecorder struct {
	Params    MoqNoParamsFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqNoParamsFn_results
	Moq       *MoqNoParamsFn
}

MoqNoParamsFn_fnRecorder routes recorded function calls to the MoqNoParamsFn moq

func (*MoqNoParamsFn_fnRecorder) AndDo 

func (r *MoqNoParamsFn_fnRecorder) AndDo(fn MoqNoParamsFn_doFn) *MoqNoParamsFn_fnRecorder

func (*MoqNoParamsFn_fnRecorder) Any 

func (r *MoqNoParamsFn_fnRecorder) Any() *MoqNoParamsFn_anyParams

func (*MoqNoParamsFn_fnRecorder) DoReturnResults 

func (r *MoqNoParamsFn_fnRecorder) DoReturnResults(fn MoqNoParamsFn_doReturnFn) *MoqNoParamsFn_fnRecorder

func (*MoqNoParamsFn_fnRecorder) FindResults 

func (r *MoqNoParamsFn_fnRecorder) FindResults()

func (*MoqNoParamsFn_fnRecorder) NoSeq 

func (r *MoqNoParamsFn_fnRecorder) NoSeq() *MoqNoParamsFn_fnRecorder

func (*MoqNoParamsFn_fnRecorder) Repeat 

func (r *MoqNoParamsFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqNoParamsFn_fnRecorder

func (*MoqNoParamsFn_fnRecorder) ReturnResults 

func (r *MoqNoParamsFn_fnRecorder) ReturnResults(sResult string, err error) *MoqNoParamsFn_fnRecorder

func (*MoqNoParamsFn_fnRecorder) Seq 

func (r *MoqNoParamsFn_fnRecorder) Seq() *MoqNoParamsFn_fnRecorder

type MoqNoParamsFn_mock 

type MoqNoParamsFn_mock struct {
	Moq *MoqNoParamsFn
}

MoqNoParamsFn_mock isolates the mock interface of the NoParamsFn type

func (*MoqNoParamsFn_mock) Fn 

func (m *MoqNoParamsFn_mock) Fn() (sResult string, err error)

type MoqNoParamsFn_params 

type MoqNoParamsFn_params struct{}

MoqNoParamsFn_params holds the params of the NoParamsFn type

type MoqNoParamsFn_paramsKey 

type MoqNoParamsFn_paramsKey struct {
	Params struct{}
	Hashes struct{}
}

MoqNoParamsFn_paramsKey holds the map key params of the NoParamsFn type

type MoqNoParamsFn_results 

type MoqNoParamsFn_results struct {
	Params  MoqNoParamsFn_params
	Results []struct {
		Values *struct {
			SResult string
			Err     error
		}
		Sequence   uint32
		DoFn       MoqNoParamsFn_doFn
		DoReturnFn MoqNoParamsFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqNoParamsFn_results holds the results of the NoParamsFn type

type MoqNoParamsFn_resultsByParams 

type MoqNoParamsFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqNoParamsFn_paramsKey]*MoqNoParamsFn_results
}

MoqNoParamsFn_resultsByParams contains the results for a given set of parameters for the NoParamsFn type

type MoqNoResultsFn 

type MoqNoResultsFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqNoResultsFn_mock

	ResultsByParams []MoqNoResultsFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct {
			SParam moq.ParamIndexing
			BParam moq.ParamIndexing
		}
	}
}

MoqNoResultsFn holds the state of a moq of the NoResultsFn type

func NewMoqNoResultsFn 

func NewMoqNoResultsFn(scene *moq.Scene, config *moq.Config) *MoqNoResultsFn

NewMoqNoResultsFn creates a new moq of the NoResultsFn type

func (*MoqNoResultsFn) AssertExpectationsMet 

func (m *MoqNoResultsFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqNoResultsFn) Mock 

func (m *MoqNoResultsFn) Mock() testmoqs.NoResultsFn

Mock returns the moq implementation of the NoResultsFn type

func (*MoqNoResultsFn) OnCall 

func (m *MoqNoResultsFn) OnCall(sParam string, bParam bool) *MoqNoResultsFn_fnRecorder

func (*MoqNoResultsFn) ParamsKey 

func (m *MoqNoResultsFn) ParamsKey(params MoqNoResultsFn_params, anyParams uint64) MoqNoResultsFn_paramsKey

func (*MoqNoResultsFn) PrettyParams 

func (m *MoqNoResultsFn) PrettyParams(params MoqNoResultsFn_params) string

func (*MoqNoResultsFn) Reset 

func (m *MoqNoResultsFn) Reset()

Reset resets the state of the moq

type MoqNoResultsFn_anyParams 

type MoqNoResultsFn_anyParams struct {
	Recorder *MoqNoResultsFn_fnRecorder
}

MoqNoResultsFn_anyParams isolates the any params functions of the NoResultsFn type

func (*MoqNoResultsFn_anyParams) BParam 

func (a *MoqNoResultsFn_anyParams) BParam() *MoqNoResultsFn_fnRecorder

func (*MoqNoResultsFn_anyParams) SParam 

func (a *MoqNoResultsFn_anyParams) SParam() *MoqNoResultsFn_fnRecorder

type MoqNoResultsFn_doFn 

type MoqNoResultsFn_doFn func(sParam string, bParam bool)

MoqNoResultsFn_doFn defines the type of function needed when calling AndDo for the NoResultsFn type

type MoqNoResultsFn_doReturnFn 

type MoqNoResultsFn_doReturnFn func(sParam string, bParam bool)

MoqNoResultsFn_doReturnFn defines the type of function needed when calling DoReturnResults for the NoResultsFn type

type MoqNoResultsFn_fnRecorder 

type MoqNoResultsFn_fnRecorder struct {
	Params    MoqNoResultsFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqNoResultsFn_results
	Moq       *MoqNoResultsFn
}

MoqNoResultsFn_fnRecorder routes recorded function calls to the MoqNoResultsFn moq

func (*MoqNoResultsFn_fnRecorder) AndDo 

func (r *MoqNoResultsFn_fnRecorder) AndDo(fn MoqNoResultsFn_doFn) *MoqNoResultsFn_fnRecorder

func (*MoqNoResultsFn_fnRecorder) Any 

func (r *MoqNoResultsFn_fnRecorder) Any() *MoqNoResultsFn_anyParams

func (*MoqNoResultsFn_fnRecorder) DoReturnResults 

func (r *MoqNoResultsFn_fnRecorder) DoReturnResults(fn MoqNoResultsFn_doReturnFn) *MoqNoResultsFn_fnRecorder

func (*MoqNoResultsFn_fnRecorder) FindResults 

func (r *MoqNoResultsFn_fnRecorder) FindResults()

func (*MoqNoResultsFn_fnRecorder) NoSeq 

func (r *MoqNoResultsFn_fnRecorder) NoSeq() *MoqNoResultsFn_fnRecorder

func (*MoqNoResultsFn_fnRecorder) Repeat 

func (r *MoqNoResultsFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqNoResultsFn_fnRecorder

func (*MoqNoResultsFn_fnRecorder) ReturnResults 

func (r *MoqNoResultsFn_fnRecorder) ReturnResults() *MoqNoResultsFn_fnRecorder

func (*MoqNoResultsFn_fnRecorder) Seq 

func (r *MoqNoResultsFn_fnRecorder) Seq() *MoqNoResultsFn_fnRecorder

type MoqNoResultsFn_mock 

type MoqNoResultsFn_mock struct {
	Moq *MoqNoResultsFn
}

MoqNoResultsFn_mock isolates the mock interface of the NoResultsFn type

func (*MoqNoResultsFn_mock) Fn 

func (m *MoqNoResultsFn_mock) Fn(sParam string, bParam bool)

type MoqNoResultsFn_params 

type MoqNoResultsFn_params struct {
	SParam string
	BParam bool
}

MoqNoResultsFn_params holds the params of the NoResultsFn type

type MoqNoResultsFn_paramsKey 

type MoqNoResultsFn_paramsKey struct {
	Params struct {
		SParam string
		BParam bool
	}
	Hashes struct {
		SParam hash.Hash
		BParam hash.Hash
	}
}

MoqNoResultsFn_paramsKey holds the map key params of the NoResultsFn type

type MoqNoResultsFn_results 

type MoqNoResultsFn_results struct {
	Params  MoqNoResultsFn_params
	Results []struct {
		Values     *struct{}
		Sequence   uint32
		DoFn       MoqNoResultsFn_doFn
		DoReturnFn MoqNoResultsFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqNoResultsFn_results holds the results of the NoResultsFn type

type MoqNoResultsFn_resultsByParams 

type MoqNoResultsFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqNoResultsFn_paramsKey]*MoqNoResultsFn_results
}

MoqNoResultsFn_resultsByParams contains the results for a given set of parameters for the NoResultsFn type

type MoqNothingFn 

type MoqNothingFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqNothingFn_mock

	ResultsByParams []MoqNothingFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct{}
	}
}

MoqNothingFn holds the state of a moq of the NothingFn type

func NewMoqNothingFn 

func NewMoqNothingFn(scene *moq.Scene, config *moq.Config) *MoqNothingFn

NewMoqNothingFn creates a new moq of the NothingFn type

func (*MoqNothingFn) AssertExpectationsMet 

func (m *MoqNothingFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqNothingFn) Mock 

func (m *MoqNothingFn) Mock() testmoqs.NothingFn

Mock returns the moq implementation of the NothingFn type

func (*MoqNothingFn) OnCall 

func (m *MoqNothingFn) OnCall() *MoqNothingFn_fnRecorder

func (*MoqNothingFn) ParamsKey 

func (m *MoqNothingFn) ParamsKey(params MoqNothingFn_params, anyParams uint64) MoqNothingFn_paramsKey

func (*MoqNothingFn) PrettyParams 

func (m *MoqNothingFn) PrettyParams(params MoqNothingFn_params) string

func (*MoqNothingFn) Reset 

func (m *MoqNothingFn) Reset()

Reset resets the state of the moq

type MoqNothingFn_anyParams 

type MoqNothingFn_anyParams struct {
	Recorder *MoqNothingFn_fnRecorder
}

MoqNothingFn_anyParams isolates the any params functions of the NothingFn type

type MoqNothingFn_doFn 

type MoqNothingFn_doFn func()

MoqNothingFn_doFn defines the type of function needed when calling AndDo for the NothingFn type

type MoqNothingFn_doReturnFn 

type MoqNothingFn_doReturnFn func()

MoqNothingFn_doReturnFn defines the type of function needed when calling DoReturnResults for the NothingFn type

type MoqNothingFn_fnRecorder 

type MoqNothingFn_fnRecorder struct {
	Params    MoqNothingFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqNothingFn_results
	Moq       *MoqNothingFn
}

MoqNothingFn_fnRecorder routes recorded function calls to the MoqNothingFn moq

func (*MoqNothingFn_fnRecorder) AndDo 

func (r *MoqNothingFn_fnRecorder) AndDo(fn MoqNothingFn_doFn) *MoqNothingFn_fnRecorder

func (*MoqNothingFn_fnRecorder) Any 

func (r *MoqNothingFn_fnRecorder) Any() *MoqNothingFn_anyParams

func (*MoqNothingFn_fnRecorder) DoReturnResults 

func (r *MoqNothingFn_fnRecorder) DoReturnResults(fn MoqNothingFn_doReturnFn) *MoqNothingFn_fnRecorder

func (*MoqNothingFn_fnRecorder) FindResults 

func (r *MoqNothingFn_fnRecorder) FindResults()

func (*MoqNothingFn_fnRecorder) NoSeq 

func (r *MoqNothingFn_fnRecorder) NoSeq() *MoqNothingFn_fnRecorder

func (*MoqNothingFn_fnRecorder) Repeat 

func (r *MoqNothingFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqNothingFn_fnRecorder

func (*MoqNothingFn_fnRecorder) ReturnResults 

func (r *MoqNothingFn_fnRecorder) ReturnResults() *MoqNothingFn_fnRecorder

func (*MoqNothingFn_fnRecorder) Seq 

func (r *MoqNothingFn_fnRecorder) Seq() *MoqNothingFn_fnRecorder

type MoqNothingFn_mock 

type MoqNothingFn_mock struct {
	Moq *MoqNothingFn
}

MoqNothingFn_mock isolates the mock interface of the NothingFn type

func (*MoqNothingFn_mock) Fn 

func (m *MoqNothingFn_mock) Fn()

type MoqNothingFn_params 

type MoqNothingFn_params struct{}

MoqNothingFn_params holds the params of the NothingFn type

type MoqNothingFn_paramsKey 

type MoqNothingFn_paramsKey struct {
	Params struct{}
	Hashes struct{}
}

MoqNothingFn_paramsKey holds the map key params of the NothingFn type

type MoqNothingFn_results 

type MoqNothingFn_results struct {
	Params  MoqNothingFn_params
	Results []struct {
		Values     *struct{}
		Sequence   uint32
		DoFn       MoqNothingFn_doFn
		DoReturnFn MoqNothingFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqNothingFn_results holds the results of the NothingFn type

type MoqNothingFn_resultsByParams 

type MoqNothingFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqNothingFn_paramsKey]*MoqNothingFn_results
}

MoqNothingFn_resultsByParams contains the results for a given set of parameters for the NothingFn type

type MoqPassByReferenceFn 

type MoqPassByReferenceFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqPassByReferenceFn_mock

	ResultsByParams []MoqPassByReferenceFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct {
			P moq.ParamIndexing
		}
	}
}

MoqPassByReferenceFn holds the state of a moq of the PassByReferenceFn type

func NewMoqPassByReferenceFn 

func NewMoqPassByReferenceFn(scene *moq.Scene, config *moq.Config) *MoqPassByReferenceFn

NewMoqPassByReferenceFn creates a new moq of the PassByReferenceFn type

func (*MoqPassByReferenceFn) AssertExpectationsMet 

func (m *MoqPassByReferenceFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqPassByReferenceFn) Mock 

func (m *MoqPassByReferenceFn) Mock() testmoqs.PassByReferenceFn

Mock returns the moq implementation of the PassByReferenceFn type

func (*MoqPassByReferenceFn) OnCall 

func (m *MoqPassByReferenceFn) OnCall(p *testmoqs.PassByReferenceParams) *MoqPassByReferenceFn_fnRecorder

func (*MoqPassByReferenceFn) ParamsKey 

func (m *MoqPassByReferenceFn) ParamsKey(params MoqPassByReferenceFn_params, anyParams uint64) MoqPassByReferenceFn_paramsKey

func (*MoqPassByReferenceFn) PrettyParams 

func (m *MoqPassByReferenceFn) PrettyParams(params MoqPassByReferenceFn_params) string

func (*MoqPassByReferenceFn) Reset 

func (m *MoqPassByReferenceFn) Reset()

Reset resets the state of the moq

type MoqPassByReferenceFn_anyParams 

type MoqPassByReferenceFn_anyParams struct {
	Recorder *MoqPassByReferenceFn_fnRecorder
}

MoqPassByReferenceFn_anyParams isolates the any params functions of the PassByReferenceFn type

func (*MoqPassByReferenceFn_anyParams) P 

func (a *MoqPassByReferenceFn_anyParams) P() *MoqPassByReferenceFn_fnRecorder

type MoqPassByReferenceFn_doFn 

type MoqPassByReferenceFn_doFn func(p *testmoqs.PassByReferenceParams)

MoqPassByReferenceFn_doFn defines the type of function needed when calling AndDo for the PassByReferenceFn type

type MoqPassByReferenceFn_doReturnFn 

type MoqPassByReferenceFn_doReturnFn func(p *testmoqs.PassByReferenceParams) (sResult string, err error)

MoqPassByReferenceFn_doReturnFn defines the type of function needed when calling DoReturnResults for the PassByReferenceFn type

type MoqPassByReferenceFn_fnRecorder 

type MoqPassByReferenceFn_fnRecorder struct {
	Params    MoqPassByReferenceFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqPassByReferenceFn_results
	Moq       *MoqPassByReferenceFn
}

MoqPassByReferenceFn_fnRecorder routes recorded function calls to the MoqPassByReferenceFn moq

func (*MoqPassByReferenceFn_fnRecorder) AndDo 

func (r *MoqPassByReferenceFn_fnRecorder) AndDo(fn MoqPassByReferenceFn_doFn) *MoqPassByReferenceFn_fnRecorder

func (*MoqPassByReferenceFn_fnRecorder) Any 

func (r *MoqPassByReferenceFn_fnRecorder) Any() *MoqPassByReferenceFn_anyParams

func (*MoqPassByReferenceFn_fnRecorder) DoReturnResults 

func (r *MoqPassByReferenceFn_fnRecorder) DoReturnResults(fn MoqPassByReferenceFn_doReturnFn) *MoqPassByReferenceFn_fnRecorder

func (*MoqPassByReferenceFn_fnRecorder) FindResults 

func (r *MoqPassByReferenceFn_fnRecorder) FindResults()

func (*MoqPassByReferenceFn_fnRecorder) NoSeq 

func (r *MoqPassByReferenceFn_fnRecorder) NoSeq() *MoqPassByReferenceFn_fnRecorder

func (*MoqPassByReferenceFn_fnRecorder) Repeat 

func (r *MoqPassByReferenceFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqPassByReferenceFn_fnRecorder

func (*MoqPassByReferenceFn_fnRecorder) ReturnResults 

func (r *MoqPassByReferenceFn_fnRecorder) ReturnResults(sResult string, err error) *MoqPassByReferenceFn_fnRecorder

func (*MoqPassByReferenceFn_fnRecorder) Seq 

func (r *MoqPassByReferenceFn_fnRecorder) Seq() *MoqPassByReferenceFn_fnRecorder

type MoqPassByReferenceFn_mock 

type MoqPassByReferenceFn_mock struct {
	Moq *MoqPassByReferenceFn
}

MoqPassByReferenceFn_mock isolates the mock interface of the PassByReferenceFn type

func (*MoqPassByReferenceFn_mock) Fn 

func (m *MoqPassByReferenceFn_mock) Fn(p *testmoqs.PassByReferenceParams) (sResult string, err error)

type MoqPassByReferenceFn_params 

type MoqPassByReferenceFn_params struct {
	P *testmoqs.PassByReferenceParams
}

MoqPassByReferenceFn_params holds the params of the PassByReferenceFn type

type MoqPassByReferenceFn_paramsKey 

type MoqPassByReferenceFn_paramsKey struct {
	Params struct {
		P *testmoqs.PassByReferenceParams
	}
	Hashes struct{ P hash.Hash }
}

MoqPassByReferenceFn_paramsKey holds the map key params of the PassByReferenceFn type

type MoqPassByReferenceFn_results 

type MoqPassByReferenceFn_results struct {
	Params  MoqPassByReferenceFn_params
	Results []struct {
		Values *struct {
			SResult string
			Err     error
		}
		Sequence   uint32
		DoFn       MoqPassByReferenceFn_doFn
		DoReturnFn MoqPassByReferenceFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqPassByReferenceFn_results holds the results of the PassByReferenceFn type

type MoqPassByReferenceFn_resultsByParams 

type MoqPassByReferenceFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqPassByReferenceFn_paramsKey]*MoqPassByReferenceFn_results
}

MoqPassByReferenceFn_resultsByParams contains the results for a given set of parameters for the PassByReferenceFn type

type MoqRepeatedIdsFn 

type MoqRepeatedIdsFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqRepeatedIdsFn_mock

	ResultsByParams []MoqRepeatedIdsFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct {
			SParam1 moq.ParamIndexing
			SParam2 moq.ParamIndexing
			BParam  moq.ParamIndexing
		}
	}
}

MoqRepeatedIdsFn holds the state of a moq of the RepeatedIdsFn type

func NewMoqRepeatedIdsFn 

func NewMoqRepeatedIdsFn(scene *moq.Scene, config *moq.Config) *MoqRepeatedIdsFn

NewMoqRepeatedIdsFn creates a new moq of the RepeatedIdsFn type

func (*MoqRepeatedIdsFn) AssertExpectationsMet 

func (m *MoqRepeatedIdsFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqRepeatedIdsFn) Mock 

func (m *MoqRepeatedIdsFn) Mock() testmoqs.RepeatedIdsFn

Mock returns the moq implementation of the RepeatedIdsFn type

func (*MoqRepeatedIdsFn) OnCall 

func (m *MoqRepeatedIdsFn) OnCall(sParam1, sParam2 string, bParam bool) *MoqRepeatedIdsFn_fnRecorder

func (*MoqRepeatedIdsFn) ParamsKey 

func (m *MoqRepeatedIdsFn) ParamsKey(params MoqRepeatedIdsFn_params, anyParams uint64) MoqRepeatedIdsFn_paramsKey

func (*MoqRepeatedIdsFn) PrettyParams 

func (m *MoqRepeatedIdsFn) PrettyParams(params MoqRepeatedIdsFn_params) string

func (*MoqRepeatedIdsFn) Reset 

func (m *MoqRepeatedIdsFn) Reset()

Reset resets the state of the moq

type MoqRepeatedIdsFn_anyParams 

type MoqRepeatedIdsFn_anyParams struct {
	Recorder *MoqRepeatedIdsFn_fnRecorder
}

MoqRepeatedIdsFn_anyParams isolates the any params functions of the RepeatedIdsFn type

func (*MoqRepeatedIdsFn_anyParams) BParam 

func (a *MoqRepeatedIdsFn_anyParams) BParam() *MoqRepeatedIdsFn_fnRecorder

func (*MoqRepeatedIdsFn_anyParams) SParam1 

func (a *MoqRepeatedIdsFn_anyParams) SParam1() *MoqRepeatedIdsFn_fnRecorder

func (*MoqRepeatedIdsFn_anyParams) SParam2 

func (a *MoqRepeatedIdsFn_anyParams) SParam2() *MoqRepeatedIdsFn_fnRecorder

type MoqRepeatedIdsFn_doFn 

type MoqRepeatedIdsFn_doFn func(sParam1, sParam2 string, bParam bool)

MoqRepeatedIdsFn_doFn defines the type of function needed when calling AndDo for the RepeatedIdsFn type

type MoqRepeatedIdsFn_doReturnFn 

type MoqRepeatedIdsFn_doReturnFn func(sParam1, sParam2 string, bParam bool) (sResult1, sResult2 string, err error)

MoqRepeatedIdsFn_doReturnFn defines the type of function needed when calling DoReturnResults for the RepeatedIdsFn type

type MoqRepeatedIdsFn_fnRecorder 

type MoqRepeatedIdsFn_fnRecorder struct {
	Params    MoqRepeatedIdsFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqRepeatedIdsFn_results
	Moq       *MoqRepeatedIdsFn
}

MoqRepeatedIdsFn_fnRecorder routes recorded function calls to the MoqRepeatedIdsFn moq

func (*MoqRepeatedIdsFn_fnRecorder) AndDo 

func (r *MoqRepeatedIdsFn_fnRecorder) AndDo(fn MoqRepeatedIdsFn_doFn) *MoqRepeatedIdsFn_fnRecorder

func (*MoqRepeatedIdsFn_fnRecorder) Any 

func (r *MoqRepeatedIdsFn_fnRecorder) Any() *MoqRepeatedIdsFn_anyParams

func (*MoqRepeatedIdsFn_fnRecorder) DoReturnResults 

func (r *MoqRepeatedIdsFn_fnRecorder) DoReturnResults(fn MoqRepeatedIdsFn_doReturnFn) *MoqRepeatedIdsFn_fnRecorder

func (*MoqRepeatedIdsFn_fnRecorder) FindResults 

func (r *MoqRepeatedIdsFn_fnRecorder) FindResults()

func (*MoqRepeatedIdsFn_fnRecorder) NoSeq 

func (r *MoqRepeatedIdsFn_fnRecorder) NoSeq() *MoqRepeatedIdsFn_fnRecorder

func (*MoqRepeatedIdsFn_fnRecorder) Repeat 

func (r *MoqRepeatedIdsFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqRepeatedIdsFn_fnRecorder

func (*MoqRepeatedIdsFn_fnRecorder) ReturnResults 

func (r *MoqRepeatedIdsFn_fnRecorder) ReturnResults(sResult1, sResult2 string, err error) *MoqRepeatedIdsFn_fnRecorder

func (*MoqRepeatedIdsFn_fnRecorder) Seq 

func (r *MoqRepeatedIdsFn_fnRecorder) Seq() *MoqRepeatedIdsFn_fnRecorder

type MoqRepeatedIdsFn_mock 

type MoqRepeatedIdsFn_mock struct {
	Moq *MoqRepeatedIdsFn
}

MoqRepeatedIdsFn_mock isolates the mock interface of the RepeatedIdsFn type

func (*MoqRepeatedIdsFn_mock) Fn 

func (m *MoqRepeatedIdsFn_mock) Fn(sParam1, sParam2 string, bParam bool) (sResult1, sResult2 string, err error)

type MoqRepeatedIdsFn_params 

type MoqRepeatedIdsFn_params struct {
	SParam1, SParam2 string
	BParam           bool
}

MoqRepeatedIdsFn_params holds the params of the RepeatedIdsFn type

type MoqRepeatedIdsFn_paramsKey 

type MoqRepeatedIdsFn_paramsKey struct {
	Params struct {
		SParam1, SParam2 string
		BParam           bool
	}
	Hashes struct {
		SParam1, SParam2 hash.Hash
		BParam           hash.Hash
	}
}

MoqRepeatedIdsFn_paramsKey holds the map key params of the RepeatedIdsFn type

type MoqRepeatedIdsFn_results 

type MoqRepeatedIdsFn_results struct {
	Params  MoqRepeatedIdsFn_params
	Results []struct {
		Values *struct {
			SResult1, SResult2 string
			Err                error
		}
		Sequence   uint32
		DoFn       MoqRepeatedIdsFn_doFn
		DoReturnFn MoqRepeatedIdsFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqRepeatedIdsFn_results holds the results of the RepeatedIdsFn type

type MoqRepeatedIdsFn_resultsByParams 

type MoqRepeatedIdsFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqRepeatedIdsFn_paramsKey]*MoqRepeatedIdsFn_results
}

MoqRepeatedIdsFn_resultsByParams contains the results for a given set of parameters for the RepeatedIdsFn type

type MoqTimesFn 

type MoqTimesFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqTimesFn_mock

	ResultsByParams []MoqTimesFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct {
			Times  moq.ParamIndexing
			BParam moq.ParamIndexing
		}
	}
}

MoqTimesFn holds the state of a moq of the TimesFn type

func NewMoqTimesFn 

func NewMoqTimesFn(scene *moq.Scene, config *moq.Config) *MoqTimesFn

NewMoqTimesFn creates a new moq of the TimesFn type

func (*MoqTimesFn) AssertExpectationsMet 

func (m *MoqTimesFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqTimesFn) Mock 

func (m *MoqTimesFn) Mock() testmoqs.TimesFn

Mock returns the moq implementation of the TimesFn type

func (*MoqTimesFn) OnCall 

func (m *MoqTimesFn) OnCall(times string, bParam bool) *MoqTimesFn_fnRecorder

func (*MoqTimesFn) ParamsKey 

func (m *MoqTimesFn) ParamsKey(params MoqTimesFn_params, anyParams uint64) MoqTimesFn_paramsKey

func (*MoqTimesFn) PrettyParams 

func (m *MoqTimesFn) PrettyParams(params MoqTimesFn_params) string

func (*MoqTimesFn) Reset 

func (m *MoqTimesFn) Reset()

Reset resets the state of the moq

type MoqTimesFn_anyParams 

type MoqTimesFn_anyParams struct {
	Recorder *MoqTimesFn_fnRecorder
}

MoqTimesFn_anyParams isolates the any params functions of the TimesFn type

func (*MoqTimesFn_anyParams) BParam 

func (a *MoqTimesFn_anyParams) BParam() *MoqTimesFn_fnRecorder

func (*MoqTimesFn_anyParams) Times 

func (a *MoqTimesFn_anyParams) Times() *MoqTimesFn_fnRecorder

type MoqTimesFn_doFn 

type MoqTimesFn_doFn func(times string, bParam bool)

MoqTimesFn_doFn defines the type of function needed when calling AndDo for the TimesFn type

type MoqTimesFn_doReturnFn 

type MoqTimesFn_doReturnFn func(times string, bParam bool) (sResult string, err error)

MoqTimesFn_doReturnFn defines the type of function needed when calling DoReturnResults for the TimesFn type

type MoqTimesFn_fnRecorder 

type MoqTimesFn_fnRecorder struct {
	Params    MoqTimesFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqTimesFn_results
	Moq       *MoqTimesFn
}

MoqTimesFn_fnRecorder routes recorded function calls to the MoqTimesFn moq

func (*MoqTimesFn_fnRecorder) AndDo 

func (r *MoqTimesFn_fnRecorder) AndDo(fn MoqTimesFn_doFn) *MoqTimesFn_fnRecorder

func (*MoqTimesFn_fnRecorder) Any 

func (r *MoqTimesFn_fnRecorder) Any() *MoqTimesFn_anyParams

func (*MoqTimesFn_fnRecorder) DoReturnResults 

func (r *MoqTimesFn_fnRecorder) DoReturnResults(fn MoqTimesFn_doReturnFn) *MoqTimesFn_fnRecorder

func (*MoqTimesFn_fnRecorder) FindResults 

func (r *MoqTimesFn_fnRecorder) FindResults()

func (*MoqTimesFn_fnRecorder) NoSeq 

func (r *MoqTimesFn_fnRecorder) NoSeq() *MoqTimesFn_fnRecorder

func (*MoqTimesFn_fnRecorder) Repeat 

func (r *MoqTimesFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqTimesFn_fnRecorder

func (*MoqTimesFn_fnRecorder) ReturnResults 

func (r *MoqTimesFn_fnRecorder) ReturnResults(sResult string, err error) *MoqTimesFn_fnRecorder

func (*MoqTimesFn_fnRecorder) Seq 

func (r *MoqTimesFn_fnRecorder) Seq() *MoqTimesFn_fnRecorder

type MoqTimesFn_mock 

type MoqTimesFn_mock struct {
	Moq *MoqTimesFn
}

MoqTimesFn_mock isolates the mock interface of the TimesFn type

func (*MoqTimesFn_mock) Fn 

func (m *MoqTimesFn_mock) Fn(times string, bParam bool) (sResult string, err error)

type MoqTimesFn_params 

type MoqTimesFn_params struct {
	Times  string
	BParam bool
}

MoqTimesFn_params holds the params of the TimesFn type

type MoqTimesFn_paramsKey 

type MoqTimesFn_paramsKey struct {
	Params struct {
		Times  string
		BParam bool
	}
	Hashes struct {
		Times  hash.Hash
		BParam hash.Hash
	}
}

MoqTimesFn_paramsKey holds the map key params of the TimesFn type

type MoqTimesFn_results 

type MoqTimesFn_results struct {
	Params  MoqTimesFn_params
	Results []struct {
		Values *struct {
			SResult string
			Err     error
		}
		Sequence   uint32
		DoFn       MoqTimesFn_doFn
		DoReturnFn MoqTimesFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqTimesFn_results holds the results of the TimesFn type

type MoqTimesFn_resultsByParams 

type MoqTimesFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqTimesFn_paramsKey]*MoqTimesFn_results
}

MoqTimesFn_resultsByParams contains the results for a given set of parameters for the TimesFn type

type MoqUsual 

type MoqUsual struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqUsual_mock

	ResultsByParams_Usual                []MoqUsual_Usual_resultsByParams
	ResultsByParams_NoNames              []MoqUsual_NoNames_resultsByParams
	ResultsByParams_NoResults            []MoqUsual_NoResults_resultsByParams
	ResultsByParams_NoParams             []MoqUsual_NoParams_resultsByParams
	ResultsByParams_Nothing              []MoqUsual_Nothing_resultsByParams
	ResultsByParams_Variadic             []MoqUsual_Variadic_resultsByParams
	ResultsByParams_RepeatedIds          []MoqUsual_RepeatedIds_resultsByParams
	ResultsByParams_Times                []MoqUsual_Times_resultsByParams
	ResultsByParams_DifficultParamNames  []MoqUsual_DifficultParamNames_resultsByParams
	ResultsByParams_DifficultResultNames []MoqUsual_DifficultResultNames_resultsByParams
	ResultsByParams_PassByReference      []MoqUsual_PassByReference_resultsByParams
	ResultsByParams_InterfaceParam       []MoqUsual_InterfaceParam_resultsByParams
	ResultsByParams_InterfaceResult      []MoqUsual_InterfaceResult_resultsByParams
	ResultsByParams_FnParam              []MoqUsual_FnParam_resultsByParams

	Runtime struct {
		ParameterIndexing struct {
			Usual struct {
				SParam moq.ParamIndexing
				BParam moq.ParamIndexing
			}
			NoNames struct {
				Param1 moq.ParamIndexing
				Param2 moq.ParamIndexing
			}
			NoResults struct {
				SParam moq.ParamIndexing
				BParam moq.ParamIndexing
			}
			NoParams struct{}
			Nothing  struct{}
			Variadic struct {
				Other moq.ParamIndexing
				Args  moq.ParamIndexing
			}
			RepeatedIds struct {
				SParam1 moq.ParamIndexing
				SParam2 moq.ParamIndexing
				BParam  moq.ParamIndexing
			}
			Times struct {
				SParam moq.ParamIndexing
				Times  moq.ParamIndexing
			}
			DifficultParamNames struct {
				Param1 moq.ParamIndexing
				Param2 moq.ParamIndexing
				Param3 moq.ParamIndexing
				Param  moq.ParamIndexing
				Param5 moq.ParamIndexing
				Param6 moq.ParamIndexing
				Param7 moq.ParamIndexing
				Param8 moq.ParamIndexing
				Param9 moq.ParamIndexing
			}
			DifficultResultNames struct{}
			PassByReference      struct {
				P moq.ParamIndexing
			}
			InterfaceParam struct {
				W moq.ParamIndexing
			}
			InterfaceResult struct {
				SParam moq.ParamIndexing
				BParam moq.ParamIndexing
			}
			FnParam struct {
				Fn moq.ParamIndexing
			}
		}
	}
}

MoqUsual holds the state of a moq of the Usual type

func NewMoqUsual 

func NewMoqUsual(scene *moq.Scene, config *moq.Config) *MoqUsual

NewMoqUsual creates a new moq of the Usual type

func (*MoqUsual) AssertExpectationsMet 

func (m *MoqUsual) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqUsual) Mock 

func (m *MoqUsual) Mock() *MoqUsual_mock

Mock returns the mock implementation of the Usual type

func (*MoqUsual) OnCall 

func (m *MoqUsual) OnCall() *MoqUsual_recorder

OnCall returns the recorder implementation of the Usual type

func (*MoqUsual) ParamsKey_DifficultParamNames 

func (m *MoqUsual) ParamsKey_DifficultParamNames(params MoqUsual_DifficultParamNames_params, anyParams uint64) MoqUsual_DifficultParamNames_paramsKey

func (*MoqUsual) ParamsKey_DifficultResultNames 

func (m *MoqUsual) ParamsKey_DifficultResultNames(params MoqUsual_DifficultResultNames_params, anyParams uint64) MoqUsual_DifficultResultNames_paramsKey

func (*MoqUsual) ParamsKey_FnParam added in v0.25.0 

func (m *MoqUsual) ParamsKey_FnParam(params MoqUsual_FnParam_params, anyParams uint64) MoqUsual_FnParam_paramsKey

func (*MoqUsual) ParamsKey_InterfaceParam 

func (m *MoqUsual) ParamsKey_InterfaceParam(params MoqUsual_InterfaceParam_params, anyParams uint64) MoqUsual_InterfaceParam_paramsKey

func (*MoqUsual) ParamsKey_InterfaceResult 

func (m *MoqUsual) ParamsKey_InterfaceResult(params MoqUsual_InterfaceResult_params, anyParams uint64) MoqUsual_InterfaceResult_paramsKey

func (*MoqUsual) ParamsKey_NoNames 

func (m *MoqUsual) ParamsKey_NoNames(params MoqUsual_NoNames_params, anyParams uint64) MoqUsual_NoNames_paramsKey

func (*MoqUsual) ParamsKey_NoParams 

func (m *MoqUsual) ParamsKey_NoParams(params MoqUsual_NoParams_params, anyParams uint64) MoqUsual_NoParams_paramsKey

func (*MoqUsual) ParamsKey_NoResults 

func (m *MoqUsual) ParamsKey_NoResults(params MoqUsual_NoResults_params, anyParams uint64) MoqUsual_NoResults_paramsKey

func (*MoqUsual) ParamsKey_Nothing 

func (m *MoqUsual) ParamsKey_Nothing(params MoqUsual_Nothing_params, anyParams uint64) MoqUsual_Nothing_paramsKey

func (*MoqUsual) ParamsKey_PassByReference 

func (m *MoqUsual) ParamsKey_PassByReference(params MoqUsual_PassByReference_params, anyParams uint64) MoqUsual_PassByReference_paramsKey

func (*MoqUsual) ParamsKey_RepeatedIds 

func (m *MoqUsual) ParamsKey_RepeatedIds(params MoqUsual_RepeatedIds_params, anyParams uint64) MoqUsual_RepeatedIds_paramsKey

func (*MoqUsual) ParamsKey_Times 

func (m *MoqUsual) ParamsKey_Times(params MoqUsual_Times_params, anyParams uint64) MoqUsual_Times_paramsKey

func (*MoqUsual) ParamsKey_Usual 

func (m *MoqUsual) ParamsKey_Usual(params MoqUsual_Usual_params, anyParams uint64) MoqUsual_Usual_paramsKey

func (*MoqUsual) ParamsKey_Variadic 

func (m *MoqUsual) ParamsKey_Variadic(params MoqUsual_Variadic_params, anyParams uint64) MoqUsual_Variadic_paramsKey

func (*MoqUsual) PrettyParams_DifficultParamNames 

func (m *MoqUsual) PrettyParams_DifficultParamNames(params MoqUsual_DifficultParamNames_params) string

func (*MoqUsual) PrettyParams_DifficultResultNames 

func (m *MoqUsual) PrettyParams_DifficultResultNames(params MoqUsual_DifficultResultNames_params) string

func (*MoqUsual) PrettyParams_FnParam added in v0.25.0 

func (m *MoqUsual) PrettyParams_FnParam(params MoqUsual_FnParam_params) string

func (*MoqUsual) PrettyParams_InterfaceParam 

func (m *MoqUsual) PrettyParams_InterfaceParam(params MoqUsual_InterfaceParam_params) string

func (*MoqUsual) PrettyParams_InterfaceResult 

func (m *MoqUsual) PrettyParams_InterfaceResult(params MoqUsual_InterfaceResult_params) string

func (*MoqUsual) PrettyParams_NoNames 

func (m *MoqUsual) PrettyParams_NoNames(params MoqUsual_NoNames_params) string

func (*MoqUsual) PrettyParams_NoParams 

func (m *MoqUsual) PrettyParams_NoParams(params MoqUsual_NoParams_params) string

func (*MoqUsual) PrettyParams_NoResults 

func (m *MoqUsual) PrettyParams_NoResults(params MoqUsual_NoResults_params) string

func (*MoqUsual) PrettyParams_Nothing 

func (m *MoqUsual) PrettyParams_Nothing(params MoqUsual_Nothing_params) string

func (*MoqUsual) PrettyParams_PassByReference 

func (m *MoqUsual) PrettyParams_PassByReference(params MoqUsual_PassByReference_params) string

func (*MoqUsual) PrettyParams_RepeatedIds 

func (m *MoqUsual) PrettyParams_RepeatedIds(params MoqUsual_RepeatedIds_params) string

func (*MoqUsual) PrettyParams_Times 

func (m *MoqUsual) PrettyParams_Times(params MoqUsual_Times_params) string

func (*MoqUsual) PrettyParams_Usual 

func (m *MoqUsual) PrettyParams_Usual(params MoqUsual_Usual_params) string

func (*MoqUsual) PrettyParams_Variadic 

func (m *MoqUsual) PrettyParams_Variadic(params MoqUsual_Variadic_params) string

func (*MoqUsual) Reset 

func (m *MoqUsual) Reset()

Reset resets the state of the moq

type MoqUsualFn 

type MoqUsualFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqUsualFn_mock

	ResultsByParams []MoqUsualFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct {
			SParam moq.ParamIndexing
			BParam moq.ParamIndexing
		}
	}
}

MoqUsualFn holds the state of a moq of the UsualFn type

func NewMoqUsualFn 

func NewMoqUsualFn(scene *moq.Scene, config *moq.Config) *MoqUsualFn

NewMoqUsualFn creates a new moq of the UsualFn type

func (*MoqUsualFn) AssertExpectationsMet 

func (m *MoqUsualFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqUsualFn) Mock 

func (m *MoqUsualFn) Mock() testmoqs.UsualFn

Mock returns the moq implementation of the UsualFn type

func (*MoqUsualFn) OnCall 

func (m *MoqUsualFn) OnCall(sParam string, bParam bool) *MoqUsualFn_fnRecorder

func (*MoqUsualFn) ParamsKey 

func (m *MoqUsualFn) ParamsKey(params MoqUsualFn_params, anyParams uint64) MoqUsualFn_paramsKey

func (*MoqUsualFn) PrettyParams 

func (m *MoqUsualFn) PrettyParams(params MoqUsualFn_params) string

func (*MoqUsualFn) Reset 

func (m *MoqUsualFn) Reset()

Reset resets the state of the moq

type MoqUsualFn_anyParams 

type MoqUsualFn_anyParams struct {
	Recorder *MoqUsualFn_fnRecorder
}

MoqUsualFn_anyParams isolates the any params functions of the UsualFn type

func (*MoqUsualFn_anyParams) BParam 

func (a *MoqUsualFn_anyParams) BParam() *MoqUsualFn_fnRecorder

func (*MoqUsualFn_anyParams) SParam 

func (a *MoqUsualFn_anyParams) SParam() *MoqUsualFn_fnRecorder

type MoqUsualFn_doFn 

type MoqUsualFn_doFn func(sParam string, bParam bool)

MoqUsualFn_doFn defines the type of function needed when calling AndDo for the UsualFn type

type MoqUsualFn_doReturnFn 

type MoqUsualFn_doReturnFn func(sParam string, bParam bool) (sResult string, err error)

MoqUsualFn_doReturnFn defines the type of function needed when calling DoReturnResults for the UsualFn type

type MoqUsualFn_fnRecorder 

type MoqUsualFn_fnRecorder struct {
	Params    MoqUsualFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsualFn_results
	Moq       *MoqUsualFn
}

MoqUsualFn_fnRecorder routes recorded function calls to the MoqUsualFn moq

func (*MoqUsualFn_fnRecorder) AndDo 

func (r *MoqUsualFn_fnRecorder) AndDo(fn MoqUsualFn_doFn) *MoqUsualFn_fnRecorder

func (*MoqUsualFn_fnRecorder) Any 

func (r *MoqUsualFn_fnRecorder) Any() *MoqUsualFn_anyParams

func (*MoqUsualFn_fnRecorder) DoReturnResults 

func (r *MoqUsualFn_fnRecorder) DoReturnResults(fn MoqUsualFn_doReturnFn) *MoqUsualFn_fnRecorder

func (*MoqUsualFn_fnRecorder) FindResults 

func (r *MoqUsualFn_fnRecorder) FindResults()

func (*MoqUsualFn_fnRecorder) NoSeq 

func (r *MoqUsualFn_fnRecorder) NoSeq() *MoqUsualFn_fnRecorder

func (*MoqUsualFn_fnRecorder) Repeat 

func (r *MoqUsualFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsualFn_fnRecorder

func (*MoqUsualFn_fnRecorder) ReturnResults 

func (r *MoqUsualFn_fnRecorder) ReturnResults(sResult string, err error) *MoqUsualFn_fnRecorder

func (*MoqUsualFn_fnRecorder) Seq 

func (r *MoqUsualFn_fnRecorder) Seq() *MoqUsualFn_fnRecorder

type MoqUsualFn_mock 

type MoqUsualFn_mock struct {
	Moq *MoqUsualFn
}

MoqUsualFn_mock isolates the mock interface of the UsualFn type

func (*MoqUsualFn_mock) Fn 

func (m *MoqUsualFn_mock) Fn(sParam string, bParam bool) (sResult string, err error)

type MoqUsualFn_params 

type MoqUsualFn_params struct {
	SParam string
	BParam bool
}

MoqUsualFn_params holds the params of the UsualFn type

type MoqUsualFn_paramsKey 

type MoqUsualFn_paramsKey struct {
	Params struct {
		SParam string
		BParam bool
	}
	Hashes struct {
		SParam hash.Hash
		BParam hash.Hash
	}
}

MoqUsualFn_paramsKey holds the map key params of the UsualFn type

type MoqUsualFn_results 

type MoqUsualFn_results struct {
	Params  MoqUsualFn_params
	Results []struct {
		Values *struct {
			SResult string
			Err     error
		}
		Sequence   uint32
		DoFn       MoqUsualFn_doFn
		DoReturnFn MoqUsualFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsualFn_results holds the results of the UsualFn type

type MoqUsualFn_resultsByParams 

type MoqUsualFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsualFn_paramsKey]*MoqUsualFn_results
}

MoqUsualFn_resultsByParams contains the results for a given set of parameters for the UsualFn type

type MoqUsual_DifficultParamNames_anyParams 

type MoqUsual_DifficultParamNames_anyParams struct {
	Recorder *MoqUsual_DifficultParamNames_fnRecorder
}

MoqUsual_DifficultParamNames_anyParams isolates the any params functions of the Usual type

func (*MoqUsual_DifficultParamNames_anyParams) Param 

func (a *MoqUsual_DifficultParamNames_anyParams) Param() *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_anyParams) Param1 

func (a *MoqUsual_DifficultParamNames_anyParams) Param1() *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_anyParams) Param2 

func (a *MoqUsual_DifficultParamNames_anyParams) Param2() *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_anyParams) Param3 

func (a *MoqUsual_DifficultParamNames_anyParams) Param3() *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_anyParams) Param5 

func (a *MoqUsual_DifficultParamNames_anyParams) Param5() *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_anyParams) Param6 

func (a *MoqUsual_DifficultParamNames_anyParams) Param6() *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_anyParams) Param7 

func (a *MoqUsual_DifficultParamNames_anyParams) Param7() *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_anyParams) Param8 

func (a *MoqUsual_DifficultParamNames_anyParams) Param8() *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_anyParams) Param9 

func (a *MoqUsual_DifficultParamNames_anyParams) Param9() *MoqUsual_DifficultParamNames_fnRecorder

type MoqUsual_DifficultParamNames_doFn 

type MoqUsual_DifficultParamNames_doFn func(m, r bool, sequence string, param, params, i int, result, results, _ float32)

MoqUsual_DifficultParamNames_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_DifficultParamNames_doReturnFn 

type MoqUsual_DifficultParamNames_doReturnFn func(m, r bool, sequence string, param, params, i int, result, results, _ float32)

MoqUsual_DifficultParamNames_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_DifficultParamNames_fnRecorder 

type MoqUsual_DifficultParamNames_fnRecorder struct {
	Params    MoqUsual_DifficultParamNames_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_DifficultParamNames_results
	Moq       *MoqUsual
}

MoqUsual_DifficultParamNames_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_DifficultParamNames_fnRecorder) AndDo 

func (r *MoqUsual_DifficultParamNames_fnRecorder) AndDo(fn MoqUsual_DifficultParamNames_doFn) *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_fnRecorder) Any 

func (r *MoqUsual_DifficultParamNames_fnRecorder) Any() *MoqUsual_DifficultParamNames_anyParams

func (*MoqUsual_DifficultParamNames_fnRecorder) DoReturnResults 

func (r *MoqUsual_DifficultParamNames_fnRecorder) DoReturnResults(fn MoqUsual_DifficultParamNames_doReturnFn) *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_fnRecorder) FindResults 

func (r *MoqUsual_DifficultParamNames_fnRecorder) FindResults()

func (*MoqUsual_DifficultParamNames_fnRecorder) NoSeq 

func (r *MoqUsual_DifficultParamNames_fnRecorder) NoSeq() *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_fnRecorder) Repeat 

func (r *MoqUsual_DifficultParamNames_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_fnRecorder) ReturnResults 

func (r *MoqUsual_DifficultParamNames_fnRecorder) ReturnResults() *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_DifficultParamNames_fnRecorder) Seq 

func (r *MoqUsual_DifficultParamNames_fnRecorder) Seq() *MoqUsual_DifficultParamNames_fnRecorder

type MoqUsual_DifficultParamNames_params 

type MoqUsual_DifficultParamNames_params struct {
	Param1, Param2         bool
	Param3                 string
	Param, Param5, Param6  int
	Param7, Param8, Param9 float32
}

MoqUsual_DifficultParamNames_params holds the params of the Usual type

type MoqUsual_DifficultParamNames_paramsKey 

type MoqUsual_DifficultParamNames_paramsKey struct {
	Params struct {
		Param1, Param2         bool
		Param3                 string
		Param, Param5, Param6  int
		Param7, Param8, Param9 float32
	}
	Hashes struct {
		Param1, Param2         hash.Hash
		Param3                 hash.Hash
		Param, Param5, Param6  hash.Hash
		Param7, Param8, Param9 hash.Hash
	}
}

MoqUsual_DifficultParamNames_paramsKey holds the map key params of the Usual type

type MoqUsual_DifficultParamNames_results 

type MoqUsual_DifficultParamNames_results struct {
	Params  MoqUsual_DifficultParamNames_params
	Results []struct {
		Values     *struct{}
		Sequence   uint32
		DoFn       MoqUsual_DifficultParamNames_doFn
		DoReturnFn MoqUsual_DifficultParamNames_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_DifficultParamNames_results holds the results of the Usual type

type MoqUsual_DifficultParamNames_resultsByParams 

type MoqUsual_DifficultParamNames_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_DifficultParamNames_paramsKey]*MoqUsual_DifficultParamNames_results
}

MoqUsual_DifficultParamNames_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_DifficultResultNames_anyParams 

type MoqUsual_DifficultResultNames_anyParams struct {
	Recorder *MoqUsual_DifficultResultNames_fnRecorder
}

MoqUsual_DifficultResultNames_anyParams isolates the any params functions of the Usual type

type MoqUsual_DifficultResultNames_doFn 

type MoqUsual_DifficultResultNames_doFn func()

MoqUsual_DifficultResultNames_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_DifficultResultNames_doReturnFn 

type MoqUsual_DifficultResultNames_doReturnFn func() (m, r string, sequence error, param, params, i int, result, results, _ float32)

MoqUsual_DifficultResultNames_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_DifficultResultNames_fnRecorder 

type MoqUsual_DifficultResultNames_fnRecorder struct {
	Params    MoqUsual_DifficultResultNames_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_DifficultResultNames_results
	Moq       *MoqUsual
}

MoqUsual_DifficultResultNames_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_DifficultResultNames_fnRecorder) AndDo 

func (r *MoqUsual_DifficultResultNames_fnRecorder) AndDo(fn MoqUsual_DifficultResultNames_doFn) *MoqUsual_DifficultResultNames_fnRecorder

func (*MoqUsual_DifficultResultNames_fnRecorder) Any 

func (r *MoqUsual_DifficultResultNames_fnRecorder) Any() *MoqUsual_DifficultResultNames_anyParams

func (*MoqUsual_DifficultResultNames_fnRecorder) DoReturnResults 

func (r *MoqUsual_DifficultResultNames_fnRecorder) DoReturnResults(fn MoqUsual_DifficultResultNames_doReturnFn) *MoqUsual_DifficultResultNames_fnRecorder

func (*MoqUsual_DifficultResultNames_fnRecorder) FindResults 

func (r *MoqUsual_DifficultResultNames_fnRecorder) FindResults()

func (*MoqUsual_DifficultResultNames_fnRecorder) NoSeq 

func (r *MoqUsual_DifficultResultNames_fnRecorder) NoSeq() *MoqUsual_DifficultResultNames_fnRecorder

func (*MoqUsual_DifficultResultNames_fnRecorder) Repeat 

func (r *MoqUsual_DifficultResultNames_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_DifficultResultNames_fnRecorder

func (*MoqUsual_DifficultResultNames_fnRecorder) ReturnResults 

func (r *MoqUsual_DifficultResultNames_fnRecorder) ReturnResults(result1, result2 string, result3 error, param, result5, result6 int, result7, result8, result9 float32) *MoqUsual_DifficultResultNames_fnRecorder

func (*MoqUsual_DifficultResultNames_fnRecorder) Seq 

func (r *MoqUsual_DifficultResultNames_fnRecorder) Seq() *MoqUsual_DifficultResultNames_fnRecorder

type MoqUsual_DifficultResultNames_params 

type MoqUsual_DifficultResultNames_params struct{}

MoqUsual_DifficultResultNames_params holds the params of the Usual type

type MoqUsual_DifficultResultNames_paramsKey 

type MoqUsual_DifficultResultNames_paramsKey struct {
	Params struct{}
	Hashes struct{}
}

MoqUsual_DifficultResultNames_paramsKey holds the map key params of the Usual type

type MoqUsual_DifficultResultNames_results 

type MoqUsual_DifficultResultNames_results struct {
	Params  MoqUsual_DifficultResultNames_params
	Results []struct {
		Values *struct {
			Result1, Result2          string
			Result3                   error
			Param, Result5, Result6   int
			Result7, Result8, Result9 float32
		}
		Sequence   uint32
		DoFn       MoqUsual_DifficultResultNames_doFn
		DoReturnFn MoqUsual_DifficultResultNames_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_DifficultResultNames_results holds the results of the Usual type

type MoqUsual_DifficultResultNames_resultsByParams 

type MoqUsual_DifficultResultNames_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_DifficultResultNames_paramsKey]*MoqUsual_DifficultResultNames_results
}

MoqUsual_DifficultResultNames_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_FnParam_anyParams added in v0.25.0 

type MoqUsual_FnParam_anyParams struct {
	Recorder *MoqUsual_FnParam_fnRecorder
}

MoqUsual_FnParam_anyParams isolates the any params functions of the Usual type

func (*MoqUsual_FnParam_anyParams) Fn added in v0.25.0 

func (a *MoqUsual_FnParam_anyParams) Fn() *MoqUsual_FnParam_fnRecorder

type MoqUsual_FnParam_doFn added in v0.25.0 

type MoqUsual_FnParam_doFn func(fn func())

MoqUsual_FnParam_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_FnParam_doReturnFn added in v0.25.0 

type MoqUsual_FnParam_doReturnFn func(fn func())

MoqUsual_FnParam_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_FnParam_fnRecorder added in v0.25.0 

type MoqUsual_FnParam_fnRecorder struct {
	Params    MoqUsual_FnParam_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_FnParam_results
	Moq       *MoqUsual
}

MoqUsual_FnParam_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_FnParam_fnRecorder) AndDo added in v0.25.0 

func (r *MoqUsual_FnParam_fnRecorder) AndDo(fn MoqUsual_FnParam_doFn) *MoqUsual_FnParam_fnRecorder

func (*MoqUsual_FnParam_fnRecorder) Any added in v0.25.0 

func (r *MoqUsual_FnParam_fnRecorder) Any() *MoqUsual_FnParam_anyParams

func (*MoqUsual_FnParam_fnRecorder) DoReturnResults added in v0.25.0 

func (r *MoqUsual_FnParam_fnRecorder) DoReturnResults(fn MoqUsual_FnParam_doReturnFn) *MoqUsual_FnParam_fnRecorder

func (*MoqUsual_FnParam_fnRecorder) FindResults added in v0.25.0 

func (r *MoqUsual_FnParam_fnRecorder) FindResults()

func (*MoqUsual_FnParam_fnRecorder) NoSeq added in v0.25.0 

func (r *MoqUsual_FnParam_fnRecorder) NoSeq() *MoqUsual_FnParam_fnRecorder

func (*MoqUsual_FnParam_fnRecorder) Repeat added in v0.25.0 

func (r *MoqUsual_FnParam_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_FnParam_fnRecorder

func (*MoqUsual_FnParam_fnRecorder) ReturnResults added in v0.25.0 

func (r *MoqUsual_FnParam_fnRecorder) ReturnResults() *MoqUsual_FnParam_fnRecorder

func (*MoqUsual_FnParam_fnRecorder) Seq added in v0.25.0 

func (r *MoqUsual_FnParam_fnRecorder) Seq() *MoqUsual_FnParam_fnRecorder

type MoqUsual_FnParam_params added in v0.25.0 

type MoqUsual_FnParam_params struct{ Fn func() }

MoqUsual_FnParam_params holds the params of the Usual type

type MoqUsual_FnParam_paramsKey added in v0.25.0 

type MoqUsual_FnParam_paramsKey struct {
	Params struct{}
	Hashes struct{ Fn hash.Hash }
}

MoqUsual_FnParam_paramsKey holds the map key params of the Usual type

type MoqUsual_FnParam_results added in v0.25.0 

type MoqUsual_FnParam_results struct {
	Params  MoqUsual_FnParam_params
	Results []struct {
		Values     *struct{}
		Sequence   uint32
		DoFn       MoqUsual_FnParam_doFn
		DoReturnFn MoqUsual_FnParam_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_FnParam_results holds the results of the Usual type

type MoqUsual_FnParam_resultsByParams added in v0.25.0 

type MoqUsual_FnParam_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_FnParam_paramsKey]*MoqUsual_FnParam_results
}

MoqUsual_FnParam_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_InterfaceParam_anyParams 

type MoqUsual_InterfaceParam_anyParams struct {
	Recorder *MoqUsual_InterfaceParam_fnRecorder
}

MoqUsual_InterfaceParam_anyParams isolates the any params functions of the Usual type

func (*MoqUsual_InterfaceParam_anyParams) W 

func (a *MoqUsual_InterfaceParam_anyParams) W() *MoqUsual_InterfaceParam_fnRecorder

type MoqUsual_InterfaceParam_doFn 

type MoqUsual_InterfaceParam_doFn func(w io.Writer)

MoqUsual_InterfaceParam_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_InterfaceParam_doReturnFn 

type MoqUsual_InterfaceParam_doReturnFn func(w io.Writer) (sResult string, err error)

MoqUsual_InterfaceParam_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_InterfaceParam_fnRecorder 

type MoqUsual_InterfaceParam_fnRecorder struct {
	Params    MoqUsual_InterfaceParam_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_InterfaceParam_results
	Moq       *MoqUsual
}

MoqUsual_InterfaceParam_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_InterfaceParam_fnRecorder) AndDo 

func (r *MoqUsual_InterfaceParam_fnRecorder) AndDo(fn MoqUsual_InterfaceParam_doFn) *MoqUsual_InterfaceParam_fnRecorder

func (*MoqUsual_InterfaceParam_fnRecorder) Any 

func (r *MoqUsual_InterfaceParam_fnRecorder) Any() *MoqUsual_InterfaceParam_anyParams

func (*MoqUsual_InterfaceParam_fnRecorder) DoReturnResults 

func (r *MoqUsual_InterfaceParam_fnRecorder) DoReturnResults(fn MoqUsual_InterfaceParam_doReturnFn) *MoqUsual_InterfaceParam_fnRecorder

func (*MoqUsual_InterfaceParam_fnRecorder) FindResults 

func (r *MoqUsual_InterfaceParam_fnRecorder) FindResults()

func (*MoqUsual_InterfaceParam_fnRecorder) NoSeq 

func (r *MoqUsual_InterfaceParam_fnRecorder) NoSeq() *MoqUsual_InterfaceParam_fnRecorder

func (*MoqUsual_InterfaceParam_fnRecorder) Repeat 

func (r *MoqUsual_InterfaceParam_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_InterfaceParam_fnRecorder

func (*MoqUsual_InterfaceParam_fnRecorder) ReturnResults 

func (r *MoqUsual_InterfaceParam_fnRecorder) ReturnResults(sResult string, err error) *MoqUsual_InterfaceParam_fnRecorder

func (*MoqUsual_InterfaceParam_fnRecorder) Seq 

func (r *MoqUsual_InterfaceParam_fnRecorder) Seq() *MoqUsual_InterfaceParam_fnRecorder

type MoqUsual_InterfaceParam_params 

type MoqUsual_InterfaceParam_params struct{ W io.Writer }

MoqUsual_InterfaceParam_params holds the params of the Usual type

type MoqUsual_InterfaceParam_paramsKey 

type MoqUsual_InterfaceParam_paramsKey struct {
	Params struct{ W io.Writer }
	Hashes struct{ W hash.Hash }
}

MoqUsual_InterfaceParam_paramsKey holds the map key params of the Usual type

type MoqUsual_InterfaceParam_results 

type MoqUsual_InterfaceParam_results struct {
	Params  MoqUsual_InterfaceParam_params
	Results []struct {
		Values *struct {
			SResult string
			Err     error
		}
		Sequence   uint32
		DoFn       MoqUsual_InterfaceParam_doFn
		DoReturnFn MoqUsual_InterfaceParam_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_InterfaceParam_results holds the results of the Usual type

type MoqUsual_InterfaceParam_resultsByParams 

type MoqUsual_InterfaceParam_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_InterfaceParam_paramsKey]*MoqUsual_InterfaceParam_results
}

MoqUsual_InterfaceParam_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_InterfaceResult_anyParams 

type MoqUsual_InterfaceResult_anyParams struct {
	Recorder *MoqUsual_InterfaceResult_fnRecorder
}

MoqUsual_InterfaceResult_anyParams isolates the any params functions of the Usual type

func (*MoqUsual_InterfaceResult_anyParams) BParam 

func (a *MoqUsual_InterfaceResult_anyParams) BParam() *MoqUsual_InterfaceResult_fnRecorder

func (*MoqUsual_InterfaceResult_anyParams) SParam 

func (a *MoqUsual_InterfaceResult_anyParams) SParam() *MoqUsual_InterfaceResult_fnRecorder

type MoqUsual_InterfaceResult_doFn 

type MoqUsual_InterfaceResult_doFn func(sParam string, bParam bool)

MoqUsual_InterfaceResult_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_InterfaceResult_doReturnFn 

type MoqUsual_InterfaceResult_doReturnFn func(sParam string, bParam bool) (r io.Reader)

MoqUsual_InterfaceResult_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_InterfaceResult_fnRecorder 

type MoqUsual_InterfaceResult_fnRecorder struct {
	Params    MoqUsual_InterfaceResult_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_InterfaceResult_results
	Moq       *MoqUsual
}

MoqUsual_InterfaceResult_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_InterfaceResult_fnRecorder) AndDo 

func (r *MoqUsual_InterfaceResult_fnRecorder) AndDo(fn MoqUsual_InterfaceResult_doFn) *MoqUsual_InterfaceResult_fnRecorder

func (*MoqUsual_InterfaceResult_fnRecorder) Any 

func (r *MoqUsual_InterfaceResult_fnRecorder) Any() *MoqUsual_InterfaceResult_anyParams

func (*MoqUsual_InterfaceResult_fnRecorder) DoReturnResults 

func (r *MoqUsual_InterfaceResult_fnRecorder) DoReturnResults(fn MoqUsual_InterfaceResult_doReturnFn) *MoqUsual_InterfaceResult_fnRecorder

func (*MoqUsual_InterfaceResult_fnRecorder) FindResults 

func (r *MoqUsual_InterfaceResult_fnRecorder) FindResults()

func (*MoqUsual_InterfaceResult_fnRecorder) NoSeq 

func (r *MoqUsual_InterfaceResult_fnRecorder) NoSeq() *MoqUsual_InterfaceResult_fnRecorder

func (*MoqUsual_InterfaceResult_fnRecorder) Repeat 

func (r *MoqUsual_InterfaceResult_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_InterfaceResult_fnRecorder

func (*MoqUsual_InterfaceResult_fnRecorder) ReturnResults 

func (r *MoqUsual_InterfaceResult_fnRecorder) ReturnResults(result1 io.Reader) *MoqUsual_InterfaceResult_fnRecorder

func (*MoqUsual_InterfaceResult_fnRecorder) Seq 

func (r *MoqUsual_InterfaceResult_fnRecorder) Seq() *MoqUsual_InterfaceResult_fnRecorder

type MoqUsual_InterfaceResult_params 

type MoqUsual_InterfaceResult_params struct {
	SParam string
	BParam bool
}

MoqUsual_InterfaceResult_params holds the params of the Usual type

type MoqUsual_InterfaceResult_paramsKey 

type MoqUsual_InterfaceResult_paramsKey struct {
	Params struct {
		SParam string
		BParam bool
	}
	Hashes struct {
		SParam hash.Hash
		BParam hash.Hash
	}
}

MoqUsual_InterfaceResult_paramsKey holds the map key params of the Usual type

type MoqUsual_InterfaceResult_results 

type MoqUsual_InterfaceResult_results struct {
	Params  MoqUsual_InterfaceResult_params
	Results []struct {
		Values     *struct{ Result1 io.Reader }
		Sequence   uint32
		DoFn       MoqUsual_InterfaceResult_doFn
		DoReturnFn MoqUsual_InterfaceResult_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_InterfaceResult_results holds the results of the Usual type

type MoqUsual_InterfaceResult_resultsByParams 

type MoqUsual_InterfaceResult_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_InterfaceResult_paramsKey]*MoqUsual_InterfaceResult_results
}

MoqUsual_InterfaceResult_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_NoNames_anyParams 

type MoqUsual_NoNames_anyParams struct {
	Recorder *MoqUsual_NoNames_fnRecorder
}

MoqUsual_NoNames_anyParams isolates the any params functions of the Usual type

func (*MoqUsual_NoNames_anyParams) Param1 

func (a *MoqUsual_NoNames_anyParams) Param1() *MoqUsual_NoNames_fnRecorder

func (*MoqUsual_NoNames_anyParams) Param2 

func (a *MoqUsual_NoNames_anyParams) Param2() *MoqUsual_NoNames_fnRecorder

type MoqUsual_NoNames_doFn 

type MoqUsual_NoNames_doFn func(string, bool)

MoqUsual_NoNames_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_NoNames_doReturnFn 

type MoqUsual_NoNames_doReturnFn func(string, bool) (string, error)

MoqUsual_NoNames_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_NoNames_fnRecorder 

type MoqUsual_NoNames_fnRecorder struct {
	Params    MoqUsual_NoNames_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_NoNames_results
	Moq       *MoqUsual
}

MoqUsual_NoNames_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_NoNames_fnRecorder) AndDo 

func (r *MoqUsual_NoNames_fnRecorder) AndDo(fn MoqUsual_NoNames_doFn) *MoqUsual_NoNames_fnRecorder

func (*MoqUsual_NoNames_fnRecorder) Any 

func (r *MoqUsual_NoNames_fnRecorder) Any() *MoqUsual_NoNames_anyParams

func (*MoqUsual_NoNames_fnRecorder) DoReturnResults 

func (r *MoqUsual_NoNames_fnRecorder) DoReturnResults(fn MoqUsual_NoNames_doReturnFn) *MoqUsual_NoNames_fnRecorder

func (*MoqUsual_NoNames_fnRecorder) FindResults 

func (r *MoqUsual_NoNames_fnRecorder) FindResults()

func (*MoqUsual_NoNames_fnRecorder) NoSeq 

func (r *MoqUsual_NoNames_fnRecorder) NoSeq() *MoqUsual_NoNames_fnRecorder

func (*MoqUsual_NoNames_fnRecorder) Repeat 

func (r *MoqUsual_NoNames_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_NoNames_fnRecorder

func (*MoqUsual_NoNames_fnRecorder) ReturnResults 

func (r *MoqUsual_NoNames_fnRecorder) ReturnResults(result1 string, result2 error) *MoqUsual_NoNames_fnRecorder

func (*MoqUsual_NoNames_fnRecorder) Seq 

func (r *MoqUsual_NoNames_fnRecorder) Seq() *MoqUsual_NoNames_fnRecorder

type MoqUsual_NoNames_params 

type MoqUsual_NoNames_params struct {
	Param1 string
	Param2 bool
}

MoqUsual_NoNames_params holds the params of the Usual type

type MoqUsual_NoNames_paramsKey 

type MoqUsual_NoNames_paramsKey struct {
	Params struct {
		Param1 string
		Param2 bool
	}
	Hashes struct {
		Param1 hash.Hash
		Param2 hash.Hash
	}
}

MoqUsual_NoNames_paramsKey holds the map key params of the Usual type

type MoqUsual_NoNames_results 

type MoqUsual_NoNames_results struct {
	Params  MoqUsual_NoNames_params
	Results []struct {
		Values *struct {
			Result1 string
			Result2 error
		}
		Sequence   uint32
		DoFn       MoqUsual_NoNames_doFn
		DoReturnFn MoqUsual_NoNames_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_NoNames_results holds the results of the Usual type

type MoqUsual_NoNames_resultsByParams 

type MoqUsual_NoNames_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_NoNames_paramsKey]*MoqUsual_NoNames_results
}

MoqUsual_NoNames_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_NoParams_anyParams 

type MoqUsual_NoParams_anyParams struct {
	Recorder *MoqUsual_NoParams_fnRecorder
}

MoqUsual_NoParams_anyParams isolates the any params functions of the Usual type

type MoqUsual_NoParams_doFn 

type MoqUsual_NoParams_doFn func()

MoqUsual_NoParams_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_NoParams_doReturnFn 

type MoqUsual_NoParams_doReturnFn func() (sResult string, err error)

MoqUsual_NoParams_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_NoParams_fnRecorder 

type MoqUsual_NoParams_fnRecorder struct {
	Params    MoqUsual_NoParams_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_NoParams_results
	Moq       *MoqUsual
}

MoqUsual_NoParams_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_NoParams_fnRecorder) AndDo 

func (r *MoqUsual_NoParams_fnRecorder) AndDo(fn MoqUsual_NoParams_doFn) *MoqUsual_NoParams_fnRecorder

func (*MoqUsual_NoParams_fnRecorder) Any 

func (r *MoqUsual_NoParams_fnRecorder) Any() *MoqUsual_NoParams_anyParams

func (*MoqUsual_NoParams_fnRecorder) DoReturnResults 

func (r *MoqUsual_NoParams_fnRecorder) DoReturnResults(fn MoqUsual_NoParams_doReturnFn) *MoqUsual_NoParams_fnRecorder

func (*MoqUsual_NoParams_fnRecorder) FindResults 

func (r *MoqUsual_NoParams_fnRecorder) FindResults()

func (*MoqUsual_NoParams_fnRecorder) NoSeq 

func (r *MoqUsual_NoParams_fnRecorder) NoSeq() *MoqUsual_NoParams_fnRecorder

func (*MoqUsual_NoParams_fnRecorder) Repeat 

func (r *MoqUsual_NoParams_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_NoParams_fnRecorder

func (*MoqUsual_NoParams_fnRecorder) ReturnResults 

func (r *MoqUsual_NoParams_fnRecorder) ReturnResults(sResult string, err error) *MoqUsual_NoParams_fnRecorder

func (*MoqUsual_NoParams_fnRecorder) Seq 

func (r *MoqUsual_NoParams_fnRecorder) Seq() *MoqUsual_NoParams_fnRecorder

type MoqUsual_NoParams_params 

type MoqUsual_NoParams_params struct{}

MoqUsual_NoParams_params holds the params of the Usual type

type MoqUsual_NoParams_paramsKey 

type MoqUsual_NoParams_paramsKey struct {
	Params struct{}
	Hashes struct{}
}

MoqUsual_NoParams_paramsKey holds the map key params of the Usual type

type MoqUsual_NoParams_results 

type MoqUsual_NoParams_results struct {
	Params  MoqUsual_NoParams_params
	Results []struct {
		Values *struct {
			SResult string
			Err     error
		}
		Sequence   uint32
		DoFn       MoqUsual_NoParams_doFn
		DoReturnFn MoqUsual_NoParams_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_NoParams_results holds the results of the Usual type

type MoqUsual_NoParams_resultsByParams 

type MoqUsual_NoParams_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_NoParams_paramsKey]*MoqUsual_NoParams_results
}

MoqUsual_NoParams_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_NoResults_anyParams 

type MoqUsual_NoResults_anyParams struct {
	Recorder *MoqUsual_NoResults_fnRecorder
}

MoqUsual_NoResults_anyParams isolates the any params functions of the Usual type

func (*MoqUsual_NoResults_anyParams) BParam 

func (a *MoqUsual_NoResults_anyParams) BParam() *MoqUsual_NoResults_fnRecorder

func (*MoqUsual_NoResults_anyParams) SParam 

func (a *MoqUsual_NoResults_anyParams) SParam() *MoqUsual_NoResults_fnRecorder

type MoqUsual_NoResults_doFn 

type MoqUsual_NoResults_doFn func(sParam string, bParam bool)

MoqUsual_NoResults_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_NoResults_doReturnFn 

type MoqUsual_NoResults_doReturnFn func(sParam string, bParam bool)

MoqUsual_NoResults_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_NoResults_fnRecorder 

type MoqUsual_NoResults_fnRecorder struct {
	Params    MoqUsual_NoResults_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_NoResults_results
	Moq       *MoqUsual
}

MoqUsual_NoResults_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_NoResults_fnRecorder) AndDo 

func (r *MoqUsual_NoResults_fnRecorder) AndDo(fn MoqUsual_NoResults_doFn) *MoqUsual_NoResults_fnRecorder

func (*MoqUsual_NoResults_fnRecorder) Any 

func (r *MoqUsual_NoResults_fnRecorder) Any() *MoqUsual_NoResults_anyParams

func (*MoqUsual_NoResults_fnRecorder) DoReturnResults 

func (r *MoqUsual_NoResults_fnRecorder) DoReturnResults(fn MoqUsual_NoResults_doReturnFn) *MoqUsual_NoResults_fnRecorder

func (*MoqUsual_NoResults_fnRecorder) FindResults 

func (r *MoqUsual_NoResults_fnRecorder) FindResults()

func (*MoqUsual_NoResults_fnRecorder) NoSeq 

func (r *MoqUsual_NoResults_fnRecorder) NoSeq() *MoqUsual_NoResults_fnRecorder

func (*MoqUsual_NoResults_fnRecorder) Repeat 

func (r *MoqUsual_NoResults_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_NoResults_fnRecorder

func (*MoqUsual_NoResults_fnRecorder) ReturnResults 

func (r *MoqUsual_NoResults_fnRecorder) ReturnResults() *MoqUsual_NoResults_fnRecorder

func (*MoqUsual_NoResults_fnRecorder) Seq 

func (r *MoqUsual_NoResults_fnRecorder) Seq() *MoqUsual_NoResults_fnRecorder

type MoqUsual_NoResults_params 

type MoqUsual_NoResults_params struct {
	SParam string
	BParam bool
}

MoqUsual_NoResults_params holds the params of the Usual type

type MoqUsual_NoResults_paramsKey 

type MoqUsual_NoResults_paramsKey struct {
	Params struct {
		SParam string
		BParam bool
	}
	Hashes struct {
		SParam hash.Hash
		BParam hash.Hash
	}
}

MoqUsual_NoResults_paramsKey holds the map key params of the Usual type

type MoqUsual_NoResults_results 

type MoqUsual_NoResults_results struct {
	Params  MoqUsual_NoResults_params
	Results []struct {
		Values     *struct{}
		Sequence   uint32
		DoFn       MoqUsual_NoResults_doFn
		DoReturnFn MoqUsual_NoResults_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_NoResults_results holds the results of the Usual type

type MoqUsual_NoResults_resultsByParams 

type MoqUsual_NoResults_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_NoResults_paramsKey]*MoqUsual_NoResults_results
}

MoqUsual_NoResults_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_Nothing_anyParams 

type MoqUsual_Nothing_anyParams struct {
	Recorder *MoqUsual_Nothing_fnRecorder
}

MoqUsual_Nothing_anyParams isolates the any params functions of the Usual type

type MoqUsual_Nothing_doFn 

type MoqUsual_Nothing_doFn func()

MoqUsual_Nothing_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_Nothing_doReturnFn 

type MoqUsual_Nothing_doReturnFn func()

MoqUsual_Nothing_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_Nothing_fnRecorder 

type MoqUsual_Nothing_fnRecorder struct {
	Params    MoqUsual_Nothing_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_Nothing_results
	Moq       *MoqUsual
}

MoqUsual_Nothing_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_Nothing_fnRecorder) AndDo 

func (r *MoqUsual_Nothing_fnRecorder) AndDo(fn MoqUsual_Nothing_doFn) *MoqUsual_Nothing_fnRecorder

func (*MoqUsual_Nothing_fnRecorder) Any 

func (r *MoqUsual_Nothing_fnRecorder) Any() *MoqUsual_Nothing_anyParams

func (*MoqUsual_Nothing_fnRecorder) DoReturnResults 

func (r *MoqUsual_Nothing_fnRecorder) DoReturnResults(fn MoqUsual_Nothing_doReturnFn) *MoqUsual_Nothing_fnRecorder

func (*MoqUsual_Nothing_fnRecorder) FindResults 

func (r *MoqUsual_Nothing_fnRecorder) FindResults()

func (*MoqUsual_Nothing_fnRecorder) NoSeq 

func (r *MoqUsual_Nothing_fnRecorder) NoSeq() *MoqUsual_Nothing_fnRecorder

func (*MoqUsual_Nothing_fnRecorder) Repeat 

func (r *MoqUsual_Nothing_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_Nothing_fnRecorder

func (*MoqUsual_Nothing_fnRecorder) ReturnResults 

func (r *MoqUsual_Nothing_fnRecorder) ReturnResults() *MoqUsual_Nothing_fnRecorder

func (*MoqUsual_Nothing_fnRecorder) Seq 

func (r *MoqUsual_Nothing_fnRecorder) Seq() *MoqUsual_Nothing_fnRecorder

type MoqUsual_Nothing_params 

type MoqUsual_Nothing_params struct{}

MoqUsual_Nothing_params holds the params of the Usual type

type MoqUsual_Nothing_paramsKey 

type MoqUsual_Nothing_paramsKey struct {
	Params struct{}
	Hashes struct{}
}

MoqUsual_Nothing_paramsKey holds the map key params of the Usual type

type MoqUsual_Nothing_results 

type MoqUsual_Nothing_results struct {
	Params  MoqUsual_Nothing_params
	Results []struct {
		Values     *struct{}
		Sequence   uint32
		DoFn       MoqUsual_Nothing_doFn
		DoReturnFn MoqUsual_Nothing_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_Nothing_results holds the results of the Usual type

type MoqUsual_Nothing_resultsByParams 

type MoqUsual_Nothing_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_Nothing_paramsKey]*MoqUsual_Nothing_results
}

MoqUsual_Nothing_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_PassByReference_anyParams 

type MoqUsual_PassByReference_anyParams struct {
	Recorder *MoqUsual_PassByReference_fnRecorder
}

MoqUsual_PassByReference_anyParams isolates the any params functions of the Usual type

func (*MoqUsual_PassByReference_anyParams) P 

func (a *MoqUsual_PassByReference_anyParams) P() *MoqUsual_PassByReference_fnRecorder

type MoqUsual_PassByReference_doFn 

type MoqUsual_PassByReference_doFn func(p *testmoqs.PassByReferenceParams)

MoqUsual_PassByReference_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_PassByReference_doReturnFn 

type MoqUsual_PassByReference_doReturnFn func(p *testmoqs.PassByReferenceParams) (sResult string, err error)

MoqUsual_PassByReference_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_PassByReference_fnRecorder 

type MoqUsual_PassByReference_fnRecorder struct {
	Params    MoqUsual_PassByReference_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_PassByReference_results
	Moq       *MoqUsual
}

MoqUsual_PassByReference_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_PassByReference_fnRecorder) AndDo 

func (r *MoqUsual_PassByReference_fnRecorder) AndDo(fn MoqUsual_PassByReference_doFn) *MoqUsual_PassByReference_fnRecorder

func (*MoqUsual_PassByReference_fnRecorder) Any 

func (r *MoqUsual_PassByReference_fnRecorder) Any() *MoqUsual_PassByReference_anyParams

func (*MoqUsual_PassByReference_fnRecorder) DoReturnResults 

func (r *MoqUsual_PassByReference_fnRecorder) DoReturnResults(fn MoqUsual_PassByReference_doReturnFn) *MoqUsual_PassByReference_fnRecorder

func (*MoqUsual_PassByReference_fnRecorder) FindResults 

func (r *MoqUsual_PassByReference_fnRecorder) FindResults()

func (*MoqUsual_PassByReference_fnRecorder) NoSeq 

func (r *MoqUsual_PassByReference_fnRecorder) NoSeq() *MoqUsual_PassByReference_fnRecorder

func (*MoqUsual_PassByReference_fnRecorder) Repeat 

func (r *MoqUsual_PassByReference_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_PassByReference_fnRecorder

func (*MoqUsual_PassByReference_fnRecorder) ReturnResults 

func (r *MoqUsual_PassByReference_fnRecorder) ReturnResults(sResult string, err error) *MoqUsual_PassByReference_fnRecorder

func (*MoqUsual_PassByReference_fnRecorder) Seq 

func (r *MoqUsual_PassByReference_fnRecorder) Seq() *MoqUsual_PassByReference_fnRecorder

type MoqUsual_PassByReference_params 

type MoqUsual_PassByReference_params struct {
	P *testmoqs.PassByReferenceParams
}

MoqUsual_PassByReference_params holds the params of the Usual type

type MoqUsual_PassByReference_paramsKey 

type MoqUsual_PassByReference_paramsKey struct {
	Params struct {
		P *testmoqs.PassByReferenceParams
	}
	Hashes struct{ P hash.Hash }
}

MoqUsual_PassByReference_paramsKey holds the map key params of the Usual type

type MoqUsual_PassByReference_results 

type MoqUsual_PassByReference_results struct {
	Params  MoqUsual_PassByReference_params
	Results []struct {
		Values *struct {
			SResult string
			Err     error
		}
		Sequence   uint32
		DoFn       MoqUsual_PassByReference_doFn
		DoReturnFn MoqUsual_PassByReference_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_PassByReference_results holds the results of the Usual type

type MoqUsual_PassByReference_resultsByParams 

type MoqUsual_PassByReference_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_PassByReference_paramsKey]*MoqUsual_PassByReference_results
}

MoqUsual_PassByReference_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_RepeatedIds_anyParams 

type MoqUsual_RepeatedIds_anyParams struct {
	Recorder *MoqUsual_RepeatedIds_fnRecorder
}

MoqUsual_RepeatedIds_anyParams isolates the any params functions of the Usual type

func (*MoqUsual_RepeatedIds_anyParams) BParam 

func (a *MoqUsual_RepeatedIds_anyParams) BParam() *MoqUsual_RepeatedIds_fnRecorder

func (*MoqUsual_RepeatedIds_anyParams) SParam1 

func (a *MoqUsual_RepeatedIds_anyParams) SParam1() *MoqUsual_RepeatedIds_fnRecorder

func (*MoqUsual_RepeatedIds_anyParams) SParam2 

func (a *MoqUsual_RepeatedIds_anyParams) SParam2() *MoqUsual_RepeatedIds_fnRecorder

type MoqUsual_RepeatedIds_doFn 

type MoqUsual_RepeatedIds_doFn func(sParam1, sParam2 string, bParam bool)

MoqUsual_RepeatedIds_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_RepeatedIds_doReturnFn 

type MoqUsual_RepeatedIds_doReturnFn func(sParam1, sParam2 string, bParam bool) (sResult1, sResult2 string, err error)

MoqUsual_RepeatedIds_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_RepeatedIds_fnRecorder 

type MoqUsual_RepeatedIds_fnRecorder struct {
	Params    MoqUsual_RepeatedIds_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_RepeatedIds_results
	Moq       *MoqUsual
}

MoqUsual_RepeatedIds_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_RepeatedIds_fnRecorder) AndDo 

func (r *MoqUsual_RepeatedIds_fnRecorder) AndDo(fn MoqUsual_RepeatedIds_doFn) *MoqUsual_RepeatedIds_fnRecorder

func (*MoqUsual_RepeatedIds_fnRecorder) Any 

func (r *MoqUsual_RepeatedIds_fnRecorder) Any() *MoqUsual_RepeatedIds_anyParams

func (*MoqUsual_RepeatedIds_fnRecorder) DoReturnResults 

func (r *MoqUsual_RepeatedIds_fnRecorder) DoReturnResults(fn MoqUsual_RepeatedIds_doReturnFn) *MoqUsual_RepeatedIds_fnRecorder

func (*MoqUsual_RepeatedIds_fnRecorder) FindResults 

func (r *MoqUsual_RepeatedIds_fnRecorder) FindResults()

func (*MoqUsual_RepeatedIds_fnRecorder) NoSeq 

func (r *MoqUsual_RepeatedIds_fnRecorder) NoSeq() *MoqUsual_RepeatedIds_fnRecorder

func (*MoqUsual_RepeatedIds_fnRecorder) Repeat 

func (r *MoqUsual_RepeatedIds_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_RepeatedIds_fnRecorder

func (*MoqUsual_RepeatedIds_fnRecorder) ReturnResults 

func (r *MoqUsual_RepeatedIds_fnRecorder) ReturnResults(sResult1, sResult2 string, err error) *MoqUsual_RepeatedIds_fnRecorder

func (*MoqUsual_RepeatedIds_fnRecorder) Seq 

func (r *MoqUsual_RepeatedIds_fnRecorder) Seq() *MoqUsual_RepeatedIds_fnRecorder

type MoqUsual_RepeatedIds_params 

type MoqUsual_RepeatedIds_params struct {
	SParam1, SParam2 string
	BParam           bool
}

MoqUsual_RepeatedIds_params holds the params of the Usual type

type MoqUsual_RepeatedIds_paramsKey 

type MoqUsual_RepeatedIds_paramsKey struct {
	Params struct {
		SParam1, SParam2 string
		BParam           bool
	}
	Hashes struct {
		SParam1, SParam2 hash.Hash
		BParam           hash.Hash
	}
}

MoqUsual_RepeatedIds_paramsKey holds the map key params of the Usual type

type MoqUsual_RepeatedIds_results 

type MoqUsual_RepeatedIds_results struct {
	Params  MoqUsual_RepeatedIds_params
	Results []struct {
		Values *struct {
			SResult1, SResult2 string
			Err                error
		}
		Sequence   uint32
		DoFn       MoqUsual_RepeatedIds_doFn
		DoReturnFn MoqUsual_RepeatedIds_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_RepeatedIds_results holds the results of the Usual type

type MoqUsual_RepeatedIds_resultsByParams 

type MoqUsual_RepeatedIds_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_RepeatedIds_paramsKey]*MoqUsual_RepeatedIds_results
}

MoqUsual_RepeatedIds_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_Times_anyParams 

type MoqUsual_Times_anyParams struct {
	Recorder *MoqUsual_Times_fnRecorder
}

MoqUsual_Times_anyParams isolates the any params functions of the Usual type

func (*MoqUsual_Times_anyParams) SParam 

func (a *MoqUsual_Times_anyParams) SParam() *MoqUsual_Times_fnRecorder

func (*MoqUsual_Times_anyParams) Times 

func (a *MoqUsual_Times_anyParams) Times() *MoqUsual_Times_fnRecorder

type MoqUsual_Times_doFn 

type MoqUsual_Times_doFn func(sParam string, times bool)

MoqUsual_Times_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_Times_doReturnFn 

type MoqUsual_Times_doReturnFn func(sParam string, times bool) (sResult string, err error)

MoqUsual_Times_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_Times_fnRecorder 

type MoqUsual_Times_fnRecorder struct {
	Params    MoqUsual_Times_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_Times_results
	Moq       *MoqUsual
}

MoqUsual_Times_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_Times_fnRecorder) AndDo 

func (r *MoqUsual_Times_fnRecorder) AndDo(fn MoqUsual_Times_doFn) *MoqUsual_Times_fnRecorder

func (*MoqUsual_Times_fnRecorder) Any 

func (r *MoqUsual_Times_fnRecorder) Any() *MoqUsual_Times_anyParams

func (*MoqUsual_Times_fnRecorder) DoReturnResults 

func (r *MoqUsual_Times_fnRecorder) DoReturnResults(fn MoqUsual_Times_doReturnFn) *MoqUsual_Times_fnRecorder

func (*MoqUsual_Times_fnRecorder) FindResults 

func (r *MoqUsual_Times_fnRecorder) FindResults()

func (*MoqUsual_Times_fnRecorder) NoSeq 

func (r *MoqUsual_Times_fnRecorder) NoSeq() *MoqUsual_Times_fnRecorder

func (*MoqUsual_Times_fnRecorder) Repeat 

func (r *MoqUsual_Times_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_Times_fnRecorder

func (*MoqUsual_Times_fnRecorder) ReturnResults 

func (r *MoqUsual_Times_fnRecorder) ReturnResults(sResult string, err error) *MoqUsual_Times_fnRecorder

func (*MoqUsual_Times_fnRecorder) Seq 

func (r *MoqUsual_Times_fnRecorder) Seq() *MoqUsual_Times_fnRecorder

type MoqUsual_Times_params 

type MoqUsual_Times_params struct {
	SParam string
	Times  bool
}

MoqUsual_Times_params holds the params of the Usual type

type MoqUsual_Times_paramsKey 

type MoqUsual_Times_paramsKey struct {
	Params struct {
		SParam string
		Times  bool
	}
	Hashes struct {
		SParam hash.Hash
		Times  hash.Hash
	}
}

MoqUsual_Times_paramsKey holds the map key params of the Usual type

type MoqUsual_Times_results 

type MoqUsual_Times_results struct {
	Params  MoqUsual_Times_params
	Results []struct {
		Values *struct {
			SResult string
			Err     error
		}
		Sequence   uint32
		DoFn       MoqUsual_Times_doFn
		DoReturnFn MoqUsual_Times_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_Times_results holds the results of the Usual type

type MoqUsual_Times_resultsByParams 

type MoqUsual_Times_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_Times_paramsKey]*MoqUsual_Times_results
}

MoqUsual_Times_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_Usual_anyParams 

type MoqUsual_Usual_anyParams struct {
	Recorder *MoqUsual_Usual_fnRecorder
}

MoqUsual_Usual_anyParams isolates the any params functions of the Usual type

func (*MoqUsual_Usual_anyParams) BParam 

func (a *MoqUsual_Usual_anyParams) BParam() *MoqUsual_Usual_fnRecorder

func (*MoqUsual_Usual_anyParams) SParam 

func (a *MoqUsual_Usual_anyParams) SParam() *MoqUsual_Usual_fnRecorder

type MoqUsual_Usual_doFn 

type MoqUsual_Usual_doFn func(sParam string, bParam bool)

MoqUsual_Usual_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_Usual_doReturnFn 

type MoqUsual_Usual_doReturnFn func(sParam string, bParam bool) (sResult string, err error)

MoqUsual_Usual_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_Usual_fnRecorder 

type MoqUsual_Usual_fnRecorder struct {
	Params    MoqUsual_Usual_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_Usual_results
	Moq       *MoqUsual
}

MoqUsual_Usual_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_Usual_fnRecorder) AndDo 

func (r *MoqUsual_Usual_fnRecorder) AndDo(fn MoqUsual_Usual_doFn) *MoqUsual_Usual_fnRecorder

func (*MoqUsual_Usual_fnRecorder) Any 

func (r *MoqUsual_Usual_fnRecorder) Any() *MoqUsual_Usual_anyParams

func (*MoqUsual_Usual_fnRecorder) DoReturnResults 

func (r *MoqUsual_Usual_fnRecorder) DoReturnResults(fn MoqUsual_Usual_doReturnFn) *MoqUsual_Usual_fnRecorder

func (*MoqUsual_Usual_fnRecorder) FindResults 

func (r *MoqUsual_Usual_fnRecorder) FindResults()

func (*MoqUsual_Usual_fnRecorder) NoSeq 

func (r *MoqUsual_Usual_fnRecorder) NoSeq() *MoqUsual_Usual_fnRecorder

func (*MoqUsual_Usual_fnRecorder) Repeat 

func (r *MoqUsual_Usual_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_Usual_fnRecorder

func (*MoqUsual_Usual_fnRecorder) ReturnResults 

func (r *MoqUsual_Usual_fnRecorder) ReturnResults(sResult string, err error) *MoqUsual_Usual_fnRecorder

func (*MoqUsual_Usual_fnRecorder) Seq 

func (r *MoqUsual_Usual_fnRecorder) Seq() *MoqUsual_Usual_fnRecorder

type MoqUsual_Usual_params 

type MoqUsual_Usual_params struct {
	SParam string
	BParam bool
}

MoqUsual_Usual_params holds the params of the Usual type

type MoqUsual_Usual_paramsKey 

type MoqUsual_Usual_paramsKey struct {
	Params struct {
		SParam string
		BParam bool
	}
	Hashes struct {
		SParam hash.Hash
		BParam hash.Hash
	}
}

MoqUsual_Usual_paramsKey holds the map key params of the Usual type

type MoqUsual_Usual_results 

type MoqUsual_Usual_results struct {
	Params  MoqUsual_Usual_params
	Results []struct {
		Values *struct {
			SResult string
			Err     error
		}
		Sequence   uint32
		DoFn       MoqUsual_Usual_doFn
		DoReturnFn MoqUsual_Usual_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_Usual_results holds the results of the Usual type

type MoqUsual_Usual_resultsByParams 

type MoqUsual_Usual_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_Usual_paramsKey]*MoqUsual_Usual_results
}

MoqUsual_Usual_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_Variadic_anyParams 

type MoqUsual_Variadic_anyParams struct {
	Recorder *MoqUsual_Variadic_fnRecorder
}

MoqUsual_Variadic_anyParams isolates the any params functions of the Usual type

func (*MoqUsual_Variadic_anyParams) Args 

func (a *MoqUsual_Variadic_anyParams) Args() *MoqUsual_Variadic_fnRecorder

func (*MoqUsual_Variadic_anyParams) Other 

func (a *MoqUsual_Variadic_anyParams) Other() *MoqUsual_Variadic_fnRecorder

type MoqUsual_Variadic_doFn 

type MoqUsual_Variadic_doFn func(other bool, args ...string)

MoqUsual_Variadic_doFn defines the type of function needed when calling AndDo for the Usual type

type MoqUsual_Variadic_doReturnFn 

type MoqUsual_Variadic_doReturnFn func(other bool, args ...string) (sResult string, err error)

MoqUsual_Variadic_doReturnFn defines the type of function needed when calling DoReturnResults for the Usual type

type MoqUsual_Variadic_fnRecorder 

type MoqUsual_Variadic_fnRecorder struct {
	Params    MoqUsual_Variadic_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqUsual_Variadic_results
	Moq       *MoqUsual
}

MoqUsual_Variadic_fnRecorder routes recorded function calls to the MoqUsual moq

func (*MoqUsual_Variadic_fnRecorder) AndDo 

func (r *MoqUsual_Variadic_fnRecorder) AndDo(fn MoqUsual_Variadic_doFn) *MoqUsual_Variadic_fnRecorder

func (*MoqUsual_Variadic_fnRecorder) Any 

func (r *MoqUsual_Variadic_fnRecorder) Any() *MoqUsual_Variadic_anyParams

func (*MoqUsual_Variadic_fnRecorder) DoReturnResults 

func (r *MoqUsual_Variadic_fnRecorder) DoReturnResults(fn MoqUsual_Variadic_doReturnFn) *MoqUsual_Variadic_fnRecorder

func (*MoqUsual_Variadic_fnRecorder) FindResults 

func (r *MoqUsual_Variadic_fnRecorder) FindResults()

func (*MoqUsual_Variadic_fnRecorder) NoSeq 

func (r *MoqUsual_Variadic_fnRecorder) NoSeq() *MoqUsual_Variadic_fnRecorder

func (*MoqUsual_Variadic_fnRecorder) Repeat 

func (r *MoqUsual_Variadic_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqUsual_Variadic_fnRecorder

func (*MoqUsual_Variadic_fnRecorder) ReturnResults 

func (r *MoqUsual_Variadic_fnRecorder) ReturnResults(sResult string, err error) *MoqUsual_Variadic_fnRecorder

func (*MoqUsual_Variadic_fnRecorder) Seq 

func (r *MoqUsual_Variadic_fnRecorder) Seq() *MoqUsual_Variadic_fnRecorder

type MoqUsual_Variadic_params 

type MoqUsual_Variadic_params struct {
	Other bool
	Args  []string
}

MoqUsual_Variadic_params holds the params of the Usual type

type MoqUsual_Variadic_paramsKey 

type MoqUsual_Variadic_paramsKey struct {
	Params struct{ Other bool }
	Hashes struct {
		Other hash.Hash
		Args  hash.Hash
	}
}

MoqUsual_Variadic_paramsKey holds the map key params of the Usual type

type MoqUsual_Variadic_results 

type MoqUsual_Variadic_results struct {
	Params  MoqUsual_Variadic_params
	Results []struct {
		Values *struct {
			SResult string
			Err     error
		}
		Sequence   uint32
		DoFn       MoqUsual_Variadic_doFn
		DoReturnFn MoqUsual_Variadic_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqUsual_Variadic_results holds the results of the Usual type

type MoqUsual_Variadic_resultsByParams 

type MoqUsual_Variadic_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqUsual_Variadic_paramsKey]*MoqUsual_Variadic_results
}

MoqUsual_Variadic_resultsByParams contains the results for a given set of parameters for the Usual type

type MoqUsual_mock 

type MoqUsual_mock struct {
	Moq *MoqUsual
}

func (*MoqUsual_mock) DifficultParamNames 

func (m *MoqUsual_mock) DifficultParamNames(param1, param2 bool, param3 string, param, param5, param6 int, param7, param8, param9 float32)

func (*MoqUsual_mock) DifficultResultNames 

func (m *MoqUsual_mock) DifficultResultNames() (result1, result2 string, result3 error, param, result5, result6 int, result7, result8, result9 float32)

func (*MoqUsual_mock) FnParam added in v0.25.0 

func (m *MoqUsual_mock) FnParam(fn func())

func (*MoqUsual_mock) InterfaceParam 

func (m *MoqUsual_mock) InterfaceParam(w io.Writer) (sResult string, err error)

func (*MoqUsual_mock) InterfaceResult 

func (m *MoqUsual_mock) InterfaceResult(sParam string, bParam bool) (result1 io.Reader)

func (*MoqUsual_mock) NoNames 

func (m *MoqUsual_mock) NoNames(param1 string, param2 bool) (result1 string, result2 error)

func (*MoqUsual_mock) NoParams 

func (m *MoqUsual_mock) NoParams() (sResult string, err error)

func (*MoqUsual_mock) NoResults 

func (m *MoqUsual_mock) NoResults(sParam string, bParam bool)

func (*MoqUsual_mock) Nothing 

func (m *MoqUsual_mock) Nothing()

func (*MoqUsual_mock) PassByReference 

func (m *MoqUsual_mock) PassByReference(p *testmoqs.PassByReferenceParams) (sResult string, err error)

func (*MoqUsual_mock) RepeatedIds 

func (m *MoqUsual_mock) RepeatedIds(sParam1, sParam2 string, bParam bool) (sResult1, sResult2 string, err error)

func (*MoqUsual_mock) Times 

func (m *MoqUsual_mock) Times(sParam string, times bool) (sResult string, err error)

func (*MoqUsual_mock) Usual 

func (m *MoqUsual_mock) Usual(sParam string, bParam bool) (sResult string, err error)

func (*MoqUsual_mock) Variadic 

func (m *MoqUsual_mock) Variadic(other bool, args ...string) (sResult string, err error)

type MoqUsual_recorder 

type MoqUsual_recorder struct {
	Moq *MoqUsual
}

MoqUsual_recorder isolates the recorder interface of the Usual type

func (*MoqUsual_recorder) DifficultParamNames 

func (m *MoqUsual_recorder) DifficultParamNames(param1, param2 bool, param3 string, param, param5, param6 int, param7, param8, param9 float32) *MoqUsual_DifficultParamNames_fnRecorder

func (*MoqUsual_recorder) DifficultResultNames 

func (m *MoqUsual_recorder) DifficultResultNames() *MoqUsual_DifficultResultNames_fnRecorder

func (*MoqUsual_recorder) FnParam added in v0.25.0 

func (m *MoqUsual_recorder) FnParam(fn func()) *MoqUsual_FnParam_fnRecorder

func (*MoqUsual_recorder) InterfaceParam 

func (m *MoqUsual_recorder) InterfaceParam(w io.Writer) *MoqUsual_InterfaceParam_fnRecorder

func (*MoqUsual_recorder) InterfaceResult 

func (m *MoqUsual_recorder) InterfaceResult(sParam string, bParam bool) *MoqUsual_InterfaceResult_fnRecorder

func (*MoqUsual_recorder) NoNames 

func (m *MoqUsual_recorder) NoNames(param1 string, param2 bool) *MoqUsual_NoNames_fnRecorder

func (*MoqUsual_recorder) NoParams 

func (m *MoqUsual_recorder) NoParams() *MoqUsual_NoParams_fnRecorder

func (*MoqUsual_recorder) NoResults 

func (m *MoqUsual_recorder) NoResults(sParam string, bParam bool) *MoqUsual_NoResults_fnRecorder

func (*MoqUsual_recorder) Nothing 

func (m *MoqUsual_recorder) Nothing() *MoqUsual_Nothing_fnRecorder

func (*MoqUsual_recorder) PassByReference 

func (m *MoqUsual_recorder) PassByReference(p *testmoqs.PassByReferenceParams) *MoqUsual_PassByReference_fnRecorder

func (*MoqUsual_recorder) RepeatedIds 

func (m *MoqUsual_recorder) RepeatedIds(sParam1, sParam2 string, bParam bool) *MoqUsual_RepeatedIds_fnRecorder

func (*MoqUsual_recorder) Times 

func (m *MoqUsual_recorder) Times(sParam string, times bool) *MoqUsual_Times_fnRecorder

func (*MoqUsual_recorder) Usual 

func (m *MoqUsual_recorder) Usual(sParam string, bParam bool) *MoqUsual_Usual_fnRecorder

func (*MoqUsual_recorder) Variadic 

func (m *MoqUsual_recorder) Variadic(other bool, args ...string) *MoqUsual_Variadic_fnRecorder

type MoqVariadicFn 

type MoqVariadicFn struct {
	Scene  *moq.Scene
	Config moq.Config
	Moq    *MoqVariadicFn_mock

	ResultsByParams []MoqVariadicFn_resultsByParams

	Runtime struct {
		ParameterIndexing struct {
			Other moq.ParamIndexing
			Args  moq.ParamIndexing
		}
	}
}

MoqVariadicFn holds the state of a moq of the VariadicFn type

func NewMoqVariadicFn 

func NewMoqVariadicFn(scene *moq.Scene, config *moq.Config) *MoqVariadicFn

NewMoqVariadicFn creates a new moq of the VariadicFn type

func (*MoqVariadicFn) AssertExpectationsMet 

func (m *MoqVariadicFn) AssertExpectationsMet()

AssertExpectationsMet asserts that all expectations have been met

func (*MoqVariadicFn) Mock 

func (m *MoqVariadicFn) Mock() testmoqs.VariadicFn

Mock returns the moq implementation of the VariadicFn type

func (*MoqVariadicFn) OnCall 

func (m *MoqVariadicFn) OnCall(other bool, args ...string) *MoqVariadicFn_fnRecorder

func (*MoqVariadicFn) ParamsKey 

func (m *MoqVariadicFn) ParamsKey(params MoqVariadicFn_params, anyParams uint64) MoqVariadicFn_paramsKey

func (*MoqVariadicFn) PrettyParams 

func (m *MoqVariadicFn) PrettyParams(params MoqVariadicFn_params) string

func (*MoqVariadicFn) Reset 

func (m *MoqVariadicFn) Reset()

Reset resets the state of the moq

type MoqVariadicFn_anyParams 

type MoqVariadicFn_anyParams struct {
	Recorder *MoqVariadicFn_fnRecorder
}

MoqVariadicFn_anyParams isolates the any params functions of the VariadicFn type

func (*MoqVariadicFn_anyParams) Args 

func (a *MoqVariadicFn_anyParams) Args() *MoqVariadicFn_fnRecorder

func (*MoqVariadicFn_anyParams) Other 

func (a *MoqVariadicFn_anyParams) Other() *MoqVariadicFn_fnRecorder

type MoqVariadicFn_doFn 

type MoqVariadicFn_doFn func(other bool, args ...string)

MoqVariadicFn_doFn defines the type of function needed when calling AndDo for the VariadicFn type

type MoqVariadicFn_doReturnFn 

type MoqVariadicFn_doReturnFn func(other bool, args ...string) (sResult string, err error)

MoqVariadicFn_doReturnFn defines the type of function needed when calling DoReturnResults for the VariadicFn type

type MoqVariadicFn_fnRecorder 

type MoqVariadicFn_fnRecorder struct {
	Params    MoqVariadicFn_params
	AnyParams uint64
	Sequence  bool
	Results   *MoqVariadicFn_results
	Moq       *MoqVariadicFn
}

MoqVariadicFn_fnRecorder routes recorded function calls to the MoqVariadicFn moq

func (*MoqVariadicFn_fnRecorder) AndDo 

func (r *MoqVariadicFn_fnRecorder) AndDo(fn MoqVariadicFn_doFn) *MoqVariadicFn_fnRecorder

func (*MoqVariadicFn_fnRecorder) Any 

func (r *MoqVariadicFn_fnRecorder) Any() *MoqVariadicFn_anyParams

func (*MoqVariadicFn_fnRecorder) DoReturnResults 

func (r *MoqVariadicFn_fnRecorder) DoReturnResults(fn MoqVariadicFn_doReturnFn) *MoqVariadicFn_fnRecorder

func (*MoqVariadicFn_fnRecorder) FindResults 

func (r *MoqVariadicFn_fnRecorder) FindResults()

func (*MoqVariadicFn_fnRecorder) NoSeq 

func (r *MoqVariadicFn_fnRecorder) NoSeq() *MoqVariadicFn_fnRecorder

func (*MoqVariadicFn_fnRecorder) Repeat 

func (r *MoqVariadicFn_fnRecorder) Repeat(repeaters ...moq.Repeater) *MoqVariadicFn_fnRecorder

func (*MoqVariadicFn_fnRecorder) ReturnResults 

func (r *MoqVariadicFn_fnRecorder) ReturnResults(sResult string, err error) *MoqVariadicFn_fnRecorder

func (*MoqVariadicFn_fnRecorder) Seq 

func (r *MoqVariadicFn_fnRecorder) Seq() *MoqVariadicFn_fnRecorder

type MoqVariadicFn_mock 

type MoqVariadicFn_mock struct {
	Moq *MoqVariadicFn
}

MoqVariadicFn_mock isolates the mock interface of the VariadicFn type

func (*MoqVariadicFn_mock) Fn 

func (m *MoqVariadicFn_mock) Fn(other bool, args ...string) (sResult string, err error)

type MoqVariadicFn_params 

type MoqVariadicFn_params struct {
	Other bool
	Args  []string
}

MoqVariadicFn_params holds the params of the VariadicFn type

type MoqVariadicFn_paramsKey 

type MoqVariadicFn_paramsKey struct {
	Params struct{ Other bool }
	Hashes struct {
		Other hash.Hash
		Args  hash.Hash
	}
}

MoqVariadicFn_paramsKey holds the map key params of the VariadicFn type

type MoqVariadicFn_results 

type MoqVariadicFn_results struct {
	Params  MoqVariadicFn_params
	Results []struct {
		Values *struct {
			SResult string
			Err     error
		}
		Sequence   uint32
		DoFn       MoqVariadicFn_doFn
		DoReturnFn MoqVariadicFn_doReturnFn
	}
	Index  uint32
	Repeat *moq.RepeatVal
}

MoqVariadicFn_results holds the results of the VariadicFn type

type MoqVariadicFn_resultsByParams 

type MoqVariadicFn_resultsByParams struct {
	AnyCount  int
	AnyParams uint64
	Results   map[MoqVariadicFn_paramsKey]*MoqVariadicFn_results
}

MoqVariadicFn_resultsByParams contains the results for a given set of parameters for the VariadicFn type

Source Files

View all Source files

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.