forked from matryer/moq
-
Notifications
You must be signed in to change notification settings - Fork 0
/
generated.go
141 lines (127 loc) · 3.5 KB
/
generated.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
// Code generated by moq; DO NOT EDIT.
// github.com/matryer/moq
package generate
import (
"sync"
)
var (
lockMyInterfaceMockOne sync.RWMutex
lockMyInterfaceMockThree sync.RWMutex
lockMyInterfaceMockTwo sync.RWMutex
)
// Ensure, that MyInterfaceMock does implement MyInterface.
// If this is not the case, regenerate this file with moq.
var _ MyInterface = &MyInterfaceMock{}
// MyInterfaceMock is a mock implementation of MyInterface.
//
// func TestSomethingThatUsesMyInterface(t *testing.T) {
//
// // make and configure a mocked MyInterface
// mockedMyInterface := &MyInterfaceMock{
// OneFunc: func() bool {
// panic("mock out the One method")
// },
// ThreeFunc: func() string {
// panic("mock out the Three method")
// },
// TwoFunc: func() int {
// panic("mock out the Two method")
// },
// }
//
// // use mockedMyInterface in code that requires MyInterface
// // and then make assertions.
//
// }
type MyInterfaceMock struct {
// OneFunc mocks the One method.
OneFunc func() bool
// ThreeFunc mocks the Three method.
ThreeFunc func() string
// TwoFunc mocks the Two method.
TwoFunc func() int
// calls tracks calls to the methods.
calls struct {
// One holds details about calls to the One method.
One []struct {
}
// Three holds details about calls to the Three method.
Three []struct {
}
// Two holds details about calls to the Two method.
Two []struct {
}
}
}
// One calls OneFunc.
func (mock *MyInterfaceMock) One() bool {
if mock.OneFunc == nil {
panic("MyInterfaceMock.OneFunc: method is nil but MyInterface.One was just called")
}
callInfo := struct {
}{}
lockMyInterfaceMockOne.Lock()
mock.calls.One = append(mock.calls.One, callInfo)
lockMyInterfaceMockOne.Unlock()
return mock.OneFunc()
}
// OneCalls gets all the calls that were made to One.
// Check the length with:
// len(mockedMyInterface.OneCalls())
func (mock *MyInterfaceMock) OneCalls() []struct {
} {
var calls []struct {
}
lockMyInterfaceMockOne.RLock()
calls = mock.calls.One
lockMyInterfaceMockOne.RUnlock()
return calls
}
// Three calls ThreeFunc.
func (mock *MyInterfaceMock) Three() string {
if mock.ThreeFunc == nil {
panic("MyInterfaceMock.ThreeFunc: method is nil but MyInterface.Three was just called")
}
callInfo := struct {
}{}
lockMyInterfaceMockThree.Lock()
mock.calls.Three = append(mock.calls.Three, callInfo)
lockMyInterfaceMockThree.Unlock()
return mock.ThreeFunc()
}
// ThreeCalls gets all the calls that were made to Three.
// Check the length with:
// len(mockedMyInterface.ThreeCalls())
func (mock *MyInterfaceMock) ThreeCalls() []struct {
} {
var calls []struct {
}
lockMyInterfaceMockThree.RLock()
calls = mock.calls.Three
lockMyInterfaceMockThree.RUnlock()
return calls
}
// Two calls TwoFunc.
func (mock *MyInterfaceMock) Two() int {
if mock.TwoFunc == nil {
panic("MyInterfaceMock.TwoFunc: method is nil but MyInterface.Two was just called")
}
callInfo := struct {
}{}
lockMyInterfaceMockTwo.Lock()
mock.calls.Two = append(mock.calls.Two, callInfo)
lockMyInterfaceMockTwo.Unlock()
return mock.TwoFunc()
}
// TwoCalls gets all the calls that were made to Two.
// Check the length with:
// len(mockedMyInterface.TwoCalls())
func (mock *MyInterfaceMock) TwoCalls() []struct {
} {
var calls []struct {
}
lockMyInterfaceMockTwo.RLock()
calls = mock.calls.Two
lockMyInterfaceMockTwo.RUnlock()
return calls
}