diff --git a/internal/registry/var.go b/internal/registry/var.go index abb0d53..081a17c 100644 --- a/internal/registry/var.go +++ b/internal/registry/var.go @@ -49,7 +49,12 @@ func varName(vr *types.Var, suffix string) string { switch name { case "mock", "callInfo", "break", "default", "func", "interface", "select", "case", "defer", "go", "map", "struct", "chan", "else", "goto", "package", "switch", "const", "fallthrough", "if", "range", "type", "continue", "for", - "import", "return", "var": + "import", "return", "var", + // avoid shadowing basic types + "string", "bool", "byte", "rune", "uintptr", + "int", "int8", "int16", "int32", "int64", + "uint", "uint8", "uint16", "uint32", "uint64", + "float32", "float64", "complex64", "complex128": name += "MoqParam" } diff --git a/pkg/moq/moq_test.go b/pkg/moq/moq_test.go index e3b1a1b..8dbe3db 100644 --- a/pkg/moq/moq_test.go +++ b/pkg/moq/moq_test.go @@ -377,6 +377,12 @@ func TestMockGolden(t *testing.T) { interfaces: []string{"Example"}, goldenFile: filepath.Join("testpackages/anonimport", "iface_moq.golden.go"), }, + { + name: "ShadowTypes", + cfg: Config{SrcDir: "testpackages/shadowtypes"}, + interfaces: []string{"ShadowTypes"}, + goldenFile: filepath.Join("testpackages/shadowtypes", "shadowtypes_moq.golden.go"), + }, } for _, tc := range cases { t.Run(tc.name, func(t *testing.T) { diff --git a/pkg/moq/testpackages/shadowtypes/shadowtypes.go b/pkg/moq/testpackages/shadowtypes/shadowtypes.go new file mode 100644 index 0000000..3c0e104 --- /dev/null +++ b/pkg/moq/testpackages/shadowtypes/shadowtypes.go @@ -0,0 +1,35 @@ +package shadowtypes + +import ( + "github.com/matryer/moq/pkg/moq/testpackages/shadowtypes/types" +) + +type ShadowTypes interface { + ShadowString(string, types.String) + + ShadowInt(int, types.Int) + ShadowInt8(int8, types.Int8) + ShadowInt16(int16, types.Int16) + ShadowInt32(int32, types.Int32) + ShadowInt64(int64, types.Int64) + + ShadowUint(uint, types.Uint) + ShadowUint8(uint8, types.Uint8) + ShadowUint16(uint16, types.Uint16) + ShadowUint32(uint32, types.Uint32) + ShadowUint64(uint64, types.Uint64) + + ShadowFloat32(float32, types.Float32) + ShadowFloat64(float64, types.Float64) + + ShadowByte(byte, types.Byte) + + ShadowRune(rune, types.Rune) + + ShadowBool(bool, types.Bool) + + ShadowComplex64(complex64, types.Complex64) + ShadowComplex128(complex128, types.Complex128) + + ShadowUintptr(uintptr, types.Uintptr) +} diff --git a/pkg/moq/testpackages/shadowtypes/shadowtypes_moq.golden.go b/pkg/moq/testpackages/shadowtypes/shadowtypes_moq.golden.go new file mode 100644 index 0000000..dc9d5d8 --- /dev/null +++ b/pkg/moq/testpackages/shadowtypes/shadowtypes_moq.golden.go @@ -0,0 +1,962 @@ +// Code generated by moq; DO NOT EDIT. +// github.com/matryer/moq + +package shadowtypes + +import ( + "github.com/matryer/moq/pkg/moq/testpackages/shadowtypes/types" + "sync" +) + +// Ensure, that ShadowTypesMock does implement ShadowTypes. +// If this is not the case, regenerate this file with moq. +var _ ShadowTypes = &ShadowTypesMock{} + +// ShadowTypesMock is a mock implementation of ShadowTypes. +// +// func TestSomethingThatUsesShadowTypes(t *testing.T) { +// +// // make and configure a mocked ShadowTypes +// mockedShadowTypes := &ShadowTypesMock{ +// ShadowBoolFunc: func(b bool, boolMoqParam types.Bool) { +// panic("mock out the ShadowBool method") +// }, +// ShadowByteFunc: func(v byte, byteMoqParam types.Byte) { +// panic("mock out the ShadowByte method") +// }, +// ShadowComplex128Func: func(v complex128, complex128MoqParam types.Complex128) { +// panic("mock out the ShadowComplex128 method") +// }, +// ShadowComplex64Func: func(v complex64, complex64MoqParam types.Complex64) { +// panic("mock out the ShadowComplex64 method") +// }, +// ShadowFloat32Func: func(f float32, float32MoqParam types.Float32) { +// panic("mock out the ShadowFloat32 method") +// }, +// ShadowFloat64Func: func(f float64, float64MoqParam types.Float64) { +// panic("mock out the ShadowFloat64 method") +// }, +// ShadowIntFunc: func(n int, intMoqParam types.Int) { +// panic("mock out the ShadowInt method") +// }, +// ShadowInt16Func: func(n int16, int16MoqParam types.Int16) { +// panic("mock out the ShadowInt16 method") +// }, +// ShadowInt32Func: func(n int32, int32MoqParam types.Int32) { +// panic("mock out the ShadowInt32 method") +// }, +// ShadowInt64Func: func(n int64, int64MoqParam types.Int64) { +// panic("mock out the ShadowInt64 method") +// }, +// ShadowInt8Func: func(n int8, int8MoqParam types.Int8) { +// panic("mock out the ShadowInt8 method") +// }, +// ShadowRuneFunc: func(n rune, runeMoqParam types.Rune) { +// panic("mock out the ShadowRune method") +// }, +// ShadowStringFunc: func(s string, stringMoqParam types.String) { +// panic("mock out the ShadowString method") +// }, +// ShadowUintFunc: func(v uint, uintMoqParam types.Uint) { +// panic("mock out the ShadowUint method") +// }, +// ShadowUint16Func: func(v uint16, uint16MoqParam types.Uint16) { +// panic("mock out the ShadowUint16 method") +// }, +// ShadowUint32Func: func(v uint32, uint32MoqParam types.Uint32) { +// panic("mock out the ShadowUint32 method") +// }, +// ShadowUint64Func: func(v uint64, uint64MoqParam types.Uint64) { +// panic("mock out the ShadowUint64 method") +// }, +// ShadowUint8Func: func(v uint8, uint8MoqParam types.Uint8) { +// panic("mock out the ShadowUint8 method") +// }, +// ShadowUintptrFunc: func(v uintptr, uintptrMoqParam types.Uintptr) { +// panic("mock out the ShadowUintptr method") +// }, +// } +// +// // use mockedShadowTypes in code that requires ShadowTypes +// // and then make assertions. +// +// } +type ShadowTypesMock struct { + // ShadowBoolFunc mocks the ShadowBool method. + ShadowBoolFunc func(b bool, boolMoqParam types.Bool) + + // ShadowByteFunc mocks the ShadowByte method. + ShadowByteFunc func(v byte, byteMoqParam types.Byte) + + // ShadowComplex128Func mocks the ShadowComplex128 method. + ShadowComplex128Func func(v complex128, complex128MoqParam types.Complex128) + + // ShadowComplex64Func mocks the ShadowComplex64 method. + ShadowComplex64Func func(v complex64, complex64MoqParam types.Complex64) + + // ShadowFloat32Func mocks the ShadowFloat32 method. + ShadowFloat32Func func(f float32, float32MoqParam types.Float32) + + // ShadowFloat64Func mocks the ShadowFloat64 method. + ShadowFloat64Func func(f float64, float64MoqParam types.Float64) + + // ShadowIntFunc mocks the ShadowInt method. + ShadowIntFunc func(n int, intMoqParam types.Int) + + // ShadowInt16Func mocks the ShadowInt16 method. + ShadowInt16Func func(n int16, int16MoqParam types.Int16) + + // ShadowInt32Func mocks the ShadowInt32 method. + ShadowInt32Func func(n int32, int32MoqParam types.Int32) + + // ShadowInt64Func mocks the ShadowInt64 method. + ShadowInt64Func func(n int64, int64MoqParam types.Int64) + + // ShadowInt8Func mocks the ShadowInt8 method. + ShadowInt8Func func(n int8, int8MoqParam types.Int8) + + // ShadowRuneFunc mocks the ShadowRune method. + ShadowRuneFunc func(n rune, runeMoqParam types.Rune) + + // ShadowStringFunc mocks the ShadowString method. + ShadowStringFunc func(s string, stringMoqParam types.String) + + // ShadowUintFunc mocks the ShadowUint method. + ShadowUintFunc func(v uint, uintMoqParam types.Uint) + + // ShadowUint16Func mocks the ShadowUint16 method. + ShadowUint16Func func(v uint16, uint16MoqParam types.Uint16) + + // ShadowUint32Func mocks the ShadowUint32 method. + ShadowUint32Func func(v uint32, uint32MoqParam types.Uint32) + + // ShadowUint64Func mocks the ShadowUint64 method. + ShadowUint64Func func(v uint64, uint64MoqParam types.Uint64) + + // ShadowUint8Func mocks the ShadowUint8 method. + ShadowUint8Func func(v uint8, uint8MoqParam types.Uint8) + + // ShadowUintptrFunc mocks the ShadowUintptr method. + ShadowUintptrFunc func(v uintptr, uintptrMoqParam types.Uintptr) + + // calls tracks calls to the methods. + calls struct { + // ShadowBool holds details about calls to the ShadowBool method. + ShadowBool []struct { + // B is the b argument value. + B bool + // BoolMoqParam is the boolMoqParam argument value. + BoolMoqParam types.Bool + } + // ShadowByte holds details about calls to the ShadowByte method. + ShadowByte []struct { + // V is the v argument value. + V byte + // ByteMoqParam is the byteMoqParam argument value. + ByteMoqParam types.Byte + } + // ShadowComplex128 holds details about calls to the ShadowComplex128 method. + ShadowComplex128 []struct { + // V is the v argument value. + V complex128 + // Complex128MoqParam is the complex128MoqParam argument value. + Complex128MoqParam types.Complex128 + } + // ShadowComplex64 holds details about calls to the ShadowComplex64 method. + ShadowComplex64 []struct { + // V is the v argument value. + V complex64 + // Complex64MoqParam is the complex64MoqParam argument value. + Complex64MoqParam types.Complex64 + } + // ShadowFloat32 holds details about calls to the ShadowFloat32 method. + ShadowFloat32 []struct { + // F is the f argument value. + F float32 + // Float32MoqParam is the float32MoqParam argument value. + Float32MoqParam types.Float32 + } + // ShadowFloat64 holds details about calls to the ShadowFloat64 method. + ShadowFloat64 []struct { + // F is the f argument value. + F float64 + // Float64MoqParam is the float64MoqParam argument value. + Float64MoqParam types.Float64 + } + // ShadowInt holds details about calls to the ShadowInt method. + ShadowInt []struct { + // N is the n argument value. + N int + // IntMoqParam is the intMoqParam argument value. + IntMoqParam types.Int + } + // ShadowInt16 holds details about calls to the ShadowInt16 method. + ShadowInt16 []struct { + // N is the n argument value. + N int16 + // Int16MoqParam is the int16MoqParam argument value. + Int16MoqParam types.Int16 + } + // ShadowInt32 holds details about calls to the ShadowInt32 method. + ShadowInt32 []struct { + // N is the n argument value. + N int32 + // Int32MoqParam is the int32MoqParam argument value. + Int32MoqParam types.Int32 + } + // ShadowInt64 holds details about calls to the ShadowInt64 method. + ShadowInt64 []struct { + // N is the n argument value. + N int64 + // Int64MoqParam is the int64MoqParam argument value. + Int64MoqParam types.Int64 + } + // ShadowInt8 holds details about calls to the ShadowInt8 method. + ShadowInt8 []struct { + // N is the n argument value. + N int8 + // Int8MoqParam is the int8MoqParam argument value. + Int8MoqParam types.Int8 + } + // ShadowRune holds details about calls to the ShadowRune method. + ShadowRune []struct { + // N is the n argument value. + N rune + // RuneMoqParam is the runeMoqParam argument value. + RuneMoqParam types.Rune + } + // ShadowString holds details about calls to the ShadowString method. + ShadowString []struct { + // S is the s argument value. + S string + // StringMoqParam is the stringMoqParam argument value. + StringMoqParam types.String + } + // ShadowUint holds details about calls to the ShadowUint method. + ShadowUint []struct { + // V is the v argument value. + V uint + // UintMoqParam is the uintMoqParam argument value. + UintMoqParam types.Uint + } + // ShadowUint16 holds details about calls to the ShadowUint16 method. + ShadowUint16 []struct { + // V is the v argument value. + V uint16 + // Uint16MoqParam is the uint16MoqParam argument value. + Uint16MoqParam types.Uint16 + } + // ShadowUint32 holds details about calls to the ShadowUint32 method. + ShadowUint32 []struct { + // V is the v argument value. + V uint32 + // Uint32MoqParam is the uint32MoqParam argument value. + Uint32MoqParam types.Uint32 + } + // ShadowUint64 holds details about calls to the ShadowUint64 method. + ShadowUint64 []struct { + // V is the v argument value. + V uint64 + // Uint64MoqParam is the uint64MoqParam argument value. + Uint64MoqParam types.Uint64 + } + // ShadowUint8 holds details about calls to the ShadowUint8 method. + ShadowUint8 []struct { + // V is the v argument value. + V uint8 + // Uint8MoqParam is the uint8MoqParam argument value. + Uint8MoqParam types.Uint8 + } + // ShadowUintptr holds details about calls to the ShadowUintptr method. + ShadowUintptr []struct { + // V is the v argument value. + V uintptr + // UintptrMoqParam is the uintptrMoqParam argument value. + UintptrMoqParam types.Uintptr + } + } + lockShadowBool sync.RWMutex + lockShadowByte sync.RWMutex + lockShadowComplex128 sync.RWMutex + lockShadowComplex64 sync.RWMutex + lockShadowFloat32 sync.RWMutex + lockShadowFloat64 sync.RWMutex + lockShadowInt sync.RWMutex + lockShadowInt16 sync.RWMutex + lockShadowInt32 sync.RWMutex + lockShadowInt64 sync.RWMutex + lockShadowInt8 sync.RWMutex + lockShadowRune sync.RWMutex + lockShadowString sync.RWMutex + lockShadowUint sync.RWMutex + lockShadowUint16 sync.RWMutex + lockShadowUint32 sync.RWMutex + lockShadowUint64 sync.RWMutex + lockShadowUint8 sync.RWMutex + lockShadowUintptr sync.RWMutex +} + +// ShadowBool calls ShadowBoolFunc. +func (mock *ShadowTypesMock) ShadowBool(b bool, boolMoqParam types.Bool) { + if mock.ShadowBoolFunc == nil { + panic("ShadowTypesMock.ShadowBoolFunc: method is nil but ShadowTypes.ShadowBool was just called") + } + callInfo := struct { + B bool + BoolMoqParam types.Bool + }{ + B: b, + BoolMoqParam: boolMoqParam, + } + mock.lockShadowBool.Lock() + mock.calls.ShadowBool = append(mock.calls.ShadowBool, callInfo) + mock.lockShadowBool.Unlock() + mock.ShadowBoolFunc(b, boolMoqParam) +} + +// ShadowBoolCalls gets all the calls that were made to ShadowBool. +// Check the length with: +// len(mockedShadowTypes.ShadowBoolCalls()) +func (mock *ShadowTypesMock) ShadowBoolCalls() []struct { + B bool + BoolMoqParam types.Bool +} { + var calls []struct { + B bool + BoolMoqParam types.Bool + } + mock.lockShadowBool.RLock() + calls = mock.calls.ShadowBool + mock.lockShadowBool.RUnlock() + return calls +} + +// ShadowByte calls ShadowByteFunc. +func (mock *ShadowTypesMock) ShadowByte(v byte, byteMoqParam types.Byte) { + if mock.ShadowByteFunc == nil { + panic("ShadowTypesMock.ShadowByteFunc: method is nil but ShadowTypes.ShadowByte was just called") + } + callInfo := struct { + V byte + ByteMoqParam types.Byte + }{ + V: v, + ByteMoqParam: byteMoqParam, + } + mock.lockShadowByte.Lock() + mock.calls.ShadowByte = append(mock.calls.ShadowByte, callInfo) + mock.lockShadowByte.Unlock() + mock.ShadowByteFunc(v, byteMoqParam) +} + +// ShadowByteCalls gets all the calls that were made to ShadowByte. +// Check the length with: +// len(mockedShadowTypes.ShadowByteCalls()) +func (mock *ShadowTypesMock) ShadowByteCalls() []struct { + V byte + ByteMoqParam types.Byte +} { + var calls []struct { + V byte + ByteMoqParam types.Byte + } + mock.lockShadowByte.RLock() + calls = mock.calls.ShadowByte + mock.lockShadowByte.RUnlock() + return calls +} + +// ShadowComplex128 calls ShadowComplex128Func. +func (mock *ShadowTypesMock) ShadowComplex128(v complex128, complex128MoqParam types.Complex128) { + if mock.ShadowComplex128Func == nil { + panic("ShadowTypesMock.ShadowComplex128Func: method is nil but ShadowTypes.ShadowComplex128 was just called") + } + callInfo := struct { + V complex128 + Complex128MoqParam types.Complex128 + }{ + V: v, + Complex128MoqParam: complex128MoqParam, + } + mock.lockShadowComplex128.Lock() + mock.calls.ShadowComplex128 = append(mock.calls.ShadowComplex128, callInfo) + mock.lockShadowComplex128.Unlock() + mock.ShadowComplex128Func(v, complex128MoqParam) +} + +// ShadowComplex128Calls gets all the calls that were made to ShadowComplex128. +// Check the length with: +// len(mockedShadowTypes.ShadowComplex128Calls()) +func (mock *ShadowTypesMock) ShadowComplex128Calls() []struct { + V complex128 + Complex128MoqParam types.Complex128 +} { + var calls []struct { + V complex128 + Complex128MoqParam types.Complex128 + } + mock.lockShadowComplex128.RLock() + calls = mock.calls.ShadowComplex128 + mock.lockShadowComplex128.RUnlock() + return calls +} + +// ShadowComplex64 calls ShadowComplex64Func. +func (mock *ShadowTypesMock) ShadowComplex64(v complex64, complex64MoqParam types.Complex64) { + if mock.ShadowComplex64Func == nil { + panic("ShadowTypesMock.ShadowComplex64Func: method is nil but ShadowTypes.ShadowComplex64 was just called") + } + callInfo := struct { + V complex64 + Complex64MoqParam types.Complex64 + }{ + V: v, + Complex64MoqParam: complex64MoqParam, + } + mock.lockShadowComplex64.Lock() + mock.calls.ShadowComplex64 = append(mock.calls.ShadowComplex64, callInfo) + mock.lockShadowComplex64.Unlock() + mock.ShadowComplex64Func(v, complex64MoqParam) +} + +// ShadowComplex64Calls gets all the calls that were made to ShadowComplex64. +// Check the length with: +// len(mockedShadowTypes.ShadowComplex64Calls()) +func (mock *ShadowTypesMock) ShadowComplex64Calls() []struct { + V complex64 + Complex64MoqParam types.Complex64 +} { + var calls []struct { + V complex64 + Complex64MoqParam types.Complex64 + } + mock.lockShadowComplex64.RLock() + calls = mock.calls.ShadowComplex64 + mock.lockShadowComplex64.RUnlock() + return calls +} + +// ShadowFloat32 calls ShadowFloat32Func. +func (mock *ShadowTypesMock) ShadowFloat32(f float32, float32MoqParam types.Float32) { + if mock.ShadowFloat32Func == nil { + panic("ShadowTypesMock.ShadowFloat32Func: method is nil but ShadowTypes.ShadowFloat32 was just called") + } + callInfo := struct { + F float32 + Float32MoqParam types.Float32 + }{ + F: f, + Float32MoqParam: float32MoqParam, + } + mock.lockShadowFloat32.Lock() + mock.calls.ShadowFloat32 = append(mock.calls.ShadowFloat32, callInfo) + mock.lockShadowFloat32.Unlock() + mock.ShadowFloat32Func(f, float32MoqParam) +} + +// ShadowFloat32Calls gets all the calls that were made to ShadowFloat32. +// Check the length with: +// len(mockedShadowTypes.ShadowFloat32Calls()) +func (mock *ShadowTypesMock) ShadowFloat32Calls() []struct { + F float32 + Float32MoqParam types.Float32 +} { + var calls []struct { + F float32 + Float32MoqParam types.Float32 + } + mock.lockShadowFloat32.RLock() + calls = mock.calls.ShadowFloat32 + mock.lockShadowFloat32.RUnlock() + return calls +} + +// ShadowFloat64 calls ShadowFloat64Func. +func (mock *ShadowTypesMock) ShadowFloat64(f float64, float64MoqParam types.Float64) { + if mock.ShadowFloat64Func == nil { + panic("ShadowTypesMock.ShadowFloat64Func: method is nil but ShadowTypes.ShadowFloat64 was just called") + } + callInfo := struct { + F float64 + Float64MoqParam types.Float64 + }{ + F: f, + Float64MoqParam: float64MoqParam, + } + mock.lockShadowFloat64.Lock() + mock.calls.ShadowFloat64 = append(mock.calls.ShadowFloat64, callInfo) + mock.lockShadowFloat64.Unlock() + mock.ShadowFloat64Func(f, float64MoqParam) +} + +// ShadowFloat64Calls gets all the calls that were made to ShadowFloat64. +// Check the length with: +// len(mockedShadowTypes.ShadowFloat64Calls()) +func (mock *ShadowTypesMock) ShadowFloat64Calls() []struct { + F float64 + Float64MoqParam types.Float64 +} { + var calls []struct { + F float64 + Float64MoqParam types.Float64 + } + mock.lockShadowFloat64.RLock() + calls = mock.calls.ShadowFloat64 + mock.lockShadowFloat64.RUnlock() + return calls +} + +// ShadowInt calls ShadowIntFunc. +func (mock *ShadowTypesMock) ShadowInt(n int, intMoqParam types.Int) { + if mock.ShadowIntFunc == nil { + panic("ShadowTypesMock.ShadowIntFunc: method is nil but ShadowTypes.ShadowInt was just called") + } + callInfo := struct { + N int + IntMoqParam types.Int + }{ + N: n, + IntMoqParam: intMoqParam, + } + mock.lockShadowInt.Lock() + mock.calls.ShadowInt = append(mock.calls.ShadowInt, callInfo) + mock.lockShadowInt.Unlock() + mock.ShadowIntFunc(n, intMoqParam) +} + +// ShadowIntCalls gets all the calls that were made to ShadowInt. +// Check the length with: +// len(mockedShadowTypes.ShadowIntCalls()) +func (mock *ShadowTypesMock) ShadowIntCalls() []struct { + N int + IntMoqParam types.Int +} { + var calls []struct { + N int + IntMoqParam types.Int + } + mock.lockShadowInt.RLock() + calls = mock.calls.ShadowInt + mock.lockShadowInt.RUnlock() + return calls +} + +// ShadowInt16 calls ShadowInt16Func. +func (mock *ShadowTypesMock) ShadowInt16(n int16, int16MoqParam types.Int16) { + if mock.ShadowInt16Func == nil { + panic("ShadowTypesMock.ShadowInt16Func: method is nil but ShadowTypes.ShadowInt16 was just called") + } + callInfo := struct { + N int16 + Int16MoqParam types.Int16 + }{ + N: n, + Int16MoqParam: int16MoqParam, + } + mock.lockShadowInt16.Lock() + mock.calls.ShadowInt16 = append(mock.calls.ShadowInt16, callInfo) + mock.lockShadowInt16.Unlock() + mock.ShadowInt16Func(n, int16MoqParam) +} + +// ShadowInt16Calls gets all the calls that were made to ShadowInt16. +// Check the length with: +// len(mockedShadowTypes.ShadowInt16Calls()) +func (mock *ShadowTypesMock) ShadowInt16Calls() []struct { + N int16 + Int16MoqParam types.Int16 +} { + var calls []struct { + N int16 + Int16MoqParam types.Int16 + } + mock.lockShadowInt16.RLock() + calls = mock.calls.ShadowInt16 + mock.lockShadowInt16.RUnlock() + return calls +} + +// ShadowInt32 calls ShadowInt32Func. +func (mock *ShadowTypesMock) ShadowInt32(n int32, int32MoqParam types.Int32) { + if mock.ShadowInt32Func == nil { + panic("ShadowTypesMock.ShadowInt32Func: method is nil but ShadowTypes.ShadowInt32 was just called") + } + callInfo := struct { + N int32 + Int32MoqParam types.Int32 + }{ + N: n, + Int32MoqParam: int32MoqParam, + } + mock.lockShadowInt32.Lock() + mock.calls.ShadowInt32 = append(mock.calls.ShadowInt32, callInfo) + mock.lockShadowInt32.Unlock() + mock.ShadowInt32Func(n, int32MoqParam) +} + +// ShadowInt32Calls gets all the calls that were made to ShadowInt32. +// Check the length with: +// len(mockedShadowTypes.ShadowInt32Calls()) +func (mock *ShadowTypesMock) ShadowInt32Calls() []struct { + N int32 + Int32MoqParam types.Int32 +} { + var calls []struct { + N int32 + Int32MoqParam types.Int32 + } + mock.lockShadowInt32.RLock() + calls = mock.calls.ShadowInt32 + mock.lockShadowInt32.RUnlock() + return calls +} + +// ShadowInt64 calls ShadowInt64Func. +func (mock *ShadowTypesMock) ShadowInt64(n int64, int64MoqParam types.Int64) { + if mock.ShadowInt64Func == nil { + panic("ShadowTypesMock.ShadowInt64Func: method is nil but ShadowTypes.ShadowInt64 was just called") + } + callInfo := struct { + N int64 + Int64MoqParam types.Int64 + }{ + N: n, + Int64MoqParam: int64MoqParam, + } + mock.lockShadowInt64.Lock() + mock.calls.ShadowInt64 = append(mock.calls.ShadowInt64, callInfo) + mock.lockShadowInt64.Unlock() + mock.ShadowInt64Func(n, int64MoqParam) +} + +// ShadowInt64Calls gets all the calls that were made to ShadowInt64. +// Check the length with: +// len(mockedShadowTypes.ShadowInt64Calls()) +func (mock *ShadowTypesMock) ShadowInt64Calls() []struct { + N int64 + Int64MoqParam types.Int64 +} { + var calls []struct { + N int64 + Int64MoqParam types.Int64 + } + mock.lockShadowInt64.RLock() + calls = mock.calls.ShadowInt64 + mock.lockShadowInt64.RUnlock() + return calls +} + +// ShadowInt8 calls ShadowInt8Func. +func (mock *ShadowTypesMock) ShadowInt8(n int8, int8MoqParam types.Int8) { + if mock.ShadowInt8Func == nil { + panic("ShadowTypesMock.ShadowInt8Func: method is nil but ShadowTypes.ShadowInt8 was just called") + } + callInfo := struct { + N int8 + Int8MoqParam types.Int8 + }{ + N: n, + Int8MoqParam: int8MoqParam, + } + mock.lockShadowInt8.Lock() + mock.calls.ShadowInt8 = append(mock.calls.ShadowInt8, callInfo) + mock.lockShadowInt8.Unlock() + mock.ShadowInt8Func(n, int8MoqParam) +} + +// ShadowInt8Calls gets all the calls that were made to ShadowInt8. +// Check the length with: +// len(mockedShadowTypes.ShadowInt8Calls()) +func (mock *ShadowTypesMock) ShadowInt8Calls() []struct { + N int8 + Int8MoqParam types.Int8 +} { + var calls []struct { + N int8 + Int8MoqParam types.Int8 + } + mock.lockShadowInt8.RLock() + calls = mock.calls.ShadowInt8 + mock.lockShadowInt8.RUnlock() + return calls +} + +// ShadowRune calls ShadowRuneFunc. +func (mock *ShadowTypesMock) ShadowRune(n rune, runeMoqParam types.Rune) { + if mock.ShadowRuneFunc == nil { + panic("ShadowTypesMock.ShadowRuneFunc: method is nil but ShadowTypes.ShadowRune was just called") + } + callInfo := struct { + N rune + RuneMoqParam types.Rune + }{ + N: n, + RuneMoqParam: runeMoqParam, + } + mock.lockShadowRune.Lock() + mock.calls.ShadowRune = append(mock.calls.ShadowRune, callInfo) + mock.lockShadowRune.Unlock() + mock.ShadowRuneFunc(n, runeMoqParam) +} + +// ShadowRuneCalls gets all the calls that were made to ShadowRune. +// Check the length with: +// len(mockedShadowTypes.ShadowRuneCalls()) +func (mock *ShadowTypesMock) ShadowRuneCalls() []struct { + N rune + RuneMoqParam types.Rune +} { + var calls []struct { + N rune + RuneMoqParam types.Rune + } + mock.lockShadowRune.RLock() + calls = mock.calls.ShadowRune + mock.lockShadowRune.RUnlock() + return calls +} + +// ShadowString calls ShadowStringFunc. +func (mock *ShadowTypesMock) ShadowString(s string, stringMoqParam types.String) { + if mock.ShadowStringFunc == nil { + panic("ShadowTypesMock.ShadowStringFunc: method is nil but ShadowTypes.ShadowString was just called") + } + callInfo := struct { + S string + StringMoqParam types.String + }{ + S: s, + StringMoqParam: stringMoqParam, + } + mock.lockShadowString.Lock() + mock.calls.ShadowString = append(mock.calls.ShadowString, callInfo) + mock.lockShadowString.Unlock() + mock.ShadowStringFunc(s, stringMoqParam) +} + +// ShadowStringCalls gets all the calls that were made to ShadowString. +// Check the length with: +// len(mockedShadowTypes.ShadowStringCalls()) +func (mock *ShadowTypesMock) ShadowStringCalls() []struct { + S string + StringMoqParam types.String +} { + var calls []struct { + S string + StringMoqParam types.String + } + mock.lockShadowString.RLock() + calls = mock.calls.ShadowString + mock.lockShadowString.RUnlock() + return calls +} + +// ShadowUint calls ShadowUintFunc. +func (mock *ShadowTypesMock) ShadowUint(v uint, uintMoqParam types.Uint) { + if mock.ShadowUintFunc == nil { + panic("ShadowTypesMock.ShadowUintFunc: method is nil but ShadowTypes.ShadowUint was just called") + } + callInfo := struct { + V uint + UintMoqParam types.Uint + }{ + V: v, + UintMoqParam: uintMoqParam, + } + mock.lockShadowUint.Lock() + mock.calls.ShadowUint = append(mock.calls.ShadowUint, callInfo) + mock.lockShadowUint.Unlock() + mock.ShadowUintFunc(v, uintMoqParam) +} + +// ShadowUintCalls gets all the calls that were made to ShadowUint. +// Check the length with: +// len(mockedShadowTypes.ShadowUintCalls()) +func (mock *ShadowTypesMock) ShadowUintCalls() []struct { + V uint + UintMoqParam types.Uint +} { + var calls []struct { + V uint + UintMoqParam types.Uint + } + mock.lockShadowUint.RLock() + calls = mock.calls.ShadowUint + mock.lockShadowUint.RUnlock() + return calls +} + +// ShadowUint16 calls ShadowUint16Func. +func (mock *ShadowTypesMock) ShadowUint16(v uint16, uint16MoqParam types.Uint16) { + if mock.ShadowUint16Func == nil { + panic("ShadowTypesMock.ShadowUint16Func: method is nil but ShadowTypes.ShadowUint16 was just called") + } + callInfo := struct { + V uint16 + Uint16MoqParam types.Uint16 + }{ + V: v, + Uint16MoqParam: uint16MoqParam, + } + mock.lockShadowUint16.Lock() + mock.calls.ShadowUint16 = append(mock.calls.ShadowUint16, callInfo) + mock.lockShadowUint16.Unlock() + mock.ShadowUint16Func(v, uint16MoqParam) +} + +// ShadowUint16Calls gets all the calls that were made to ShadowUint16. +// Check the length with: +// len(mockedShadowTypes.ShadowUint16Calls()) +func (mock *ShadowTypesMock) ShadowUint16Calls() []struct { + V uint16 + Uint16MoqParam types.Uint16 +} { + var calls []struct { + V uint16 + Uint16MoqParam types.Uint16 + } + mock.lockShadowUint16.RLock() + calls = mock.calls.ShadowUint16 + mock.lockShadowUint16.RUnlock() + return calls +} + +// ShadowUint32 calls ShadowUint32Func. +func (mock *ShadowTypesMock) ShadowUint32(v uint32, uint32MoqParam types.Uint32) { + if mock.ShadowUint32Func == nil { + panic("ShadowTypesMock.ShadowUint32Func: method is nil but ShadowTypes.ShadowUint32 was just called") + } + callInfo := struct { + V uint32 + Uint32MoqParam types.Uint32 + }{ + V: v, + Uint32MoqParam: uint32MoqParam, + } + mock.lockShadowUint32.Lock() + mock.calls.ShadowUint32 = append(mock.calls.ShadowUint32, callInfo) + mock.lockShadowUint32.Unlock() + mock.ShadowUint32Func(v, uint32MoqParam) +} + +// ShadowUint32Calls gets all the calls that were made to ShadowUint32. +// Check the length with: +// len(mockedShadowTypes.ShadowUint32Calls()) +func (mock *ShadowTypesMock) ShadowUint32Calls() []struct { + V uint32 + Uint32MoqParam types.Uint32 +} { + var calls []struct { + V uint32 + Uint32MoqParam types.Uint32 + } + mock.lockShadowUint32.RLock() + calls = mock.calls.ShadowUint32 + mock.lockShadowUint32.RUnlock() + return calls +} + +// ShadowUint64 calls ShadowUint64Func. +func (mock *ShadowTypesMock) ShadowUint64(v uint64, uint64MoqParam types.Uint64) { + if mock.ShadowUint64Func == nil { + panic("ShadowTypesMock.ShadowUint64Func: method is nil but ShadowTypes.ShadowUint64 was just called") + } + callInfo := struct { + V uint64 + Uint64MoqParam types.Uint64 + }{ + V: v, + Uint64MoqParam: uint64MoqParam, + } + mock.lockShadowUint64.Lock() + mock.calls.ShadowUint64 = append(mock.calls.ShadowUint64, callInfo) + mock.lockShadowUint64.Unlock() + mock.ShadowUint64Func(v, uint64MoqParam) +} + +// ShadowUint64Calls gets all the calls that were made to ShadowUint64. +// Check the length with: +// len(mockedShadowTypes.ShadowUint64Calls()) +func (mock *ShadowTypesMock) ShadowUint64Calls() []struct { + V uint64 + Uint64MoqParam types.Uint64 +} { + var calls []struct { + V uint64 + Uint64MoqParam types.Uint64 + } + mock.lockShadowUint64.RLock() + calls = mock.calls.ShadowUint64 + mock.lockShadowUint64.RUnlock() + return calls +} + +// ShadowUint8 calls ShadowUint8Func. +func (mock *ShadowTypesMock) ShadowUint8(v uint8, uint8MoqParam types.Uint8) { + if mock.ShadowUint8Func == nil { + panic("ShadowTypesMock.ShadowUint8Func: method is nil but ShadowTypes.ShadowUint8 was just called") + } + callInfo := struct { + V uint8 + Uint8MoqParam types.Uint8 + }{ + V: v, + Uint8MoqParam: uint8MoqParam, + } + mock.lockShadowUint8.Lock() + mock.calls.ShadowUint8 = append(mock.calls.ShadowUint8, callInfo) + mock.lockShadowUint8.Unlock() + mock.ShadowUint8Func(v, uint8MoqParam) +} + +// ShadowUint8Calls gets all the calls that were made to ShadowUint8. +// Check the length with: +// len(mockedShadowTypes.ShadowUint8Calls()) +func (mock *ShadowTypesMock) ShadowUint8Calls() []struct { + V uint8 + Uint8MoqParam types.Uint8 +} { + var calls []struct { + V uint8 + Uint8MoqParam types.Uint8 + } + mock.lockShadowUint8.RLock() + calls = mock.calls.ShadowUint8 + mock.lockShadowUint8.RUnlock() + return calls +} + +// ShadowUintptr calls ShadowUintptrFunc. +func (mock *ShadowTypesMock) ShadowUintptr(v uintptr, uintptrMoqParam types.Uintptr) { + if mock.ShadowUintptrFunc == nil { + panic("ShadowTypesMock.ShadowUintptrFunc: method is nil but ShadowTypes.ShadowUintptr was just called") + } + callInfo := struct { + V uintptr + UintptrMoqParam types.Uintptr + }{ + V: v, + UintptrMoqParam: uintptrMoqParam, + } + mock.lockShadowUintptr.Lock() + mock.calls.ShadowUintptr = append(mock.calls.ShadowUintptr, callInfo) + mock.lockShadowUintptr.Unlock() + mock.ShadowUintptrFunc(v, uintptrMoqParam) +} + +// ShadowUintptrCalls gets all the calls that were made to ShadowUintptr. +// Check the length with: +// len(mockedShadowTypes.ShadowUintptrCalls()) +func (mock *ShadowTypesMock) ShadowUintptrCalls() []struct { + V uintptr + UintptrMoqParam types.Uintptr +} { + var calls []struct { + V uintptr + UintptrMoqParam types.Uintptr + } + mock.lockShadowUintptr.RLock() + calls = mock.calls.ShadowUintptr + mock.lockShadowUintptr.RUnlock() + return calls +} diff --git a/pkg/moq/testpackages/shadowtypes/types/types.go b/pkg/moq/testpackages/shadowtypes/types/types.go new file mode 100644 index 0000000..66c552e --- /dev/null +++ b/pkg/moq/testpackages/shadowtypes/types/types.go @@ -0,0 +1,29 @@ +package types + +type String string + +type Int int +type Int8 int8 +type Int16 int16 +type Int32 int32 +type Int64 int64 + +type Uint uint +type Uint8 uint +type Uint16 uint +type Uint32 uint +type Uint64 uint + +type Float32 float32 +type Float64 float64 + +type Byte byte + +type Rune rune + +type Bool bool + +type Complex64 complex64 +type Complex128 complex128 + +type Uintptr uintptr