github.com/true-sqn/fabric@v2.1.1+incompatible/core/ledger/mock/state_listener.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package mock 3 4 import ( 5 "sync" 6 7 "github.com/hyperledger/fabric/core/ledger" 8 ) 9 10 type StateListener struct { 11 HandleStateUpdatesStub func(*ledger.StateUpdateTrigger) error 12 handleStateUpdatesMutex sync.RWMutex 13 handleStateUpdatesArgsForCall []struct { 14 arg1 *ledger.StateUpdateTrigger 15 } 16 handleStateUpdatesReturns struct { 17 result1 error 18 } 19 handleStateUpdatesReturnsOnCall map[int]struct { 20 result1 error 21 } 22 InitializeStub func(string, ledger.SimpleQueryExecutor) error 23 initializeMutex sync.RWMutex 24 initializeArgsForCall []struct { 25 arg1 string 26 arg2 ledger.SimpleQueryExecutor 27 } 28 initializeReturns struct { 29 result1 error 30 } 31 initializeReturnsOnCall map[int]struct { 32 result1 error 33 } 34 InterestedInNamespacesStub func() []string 35 interestedInNamespacesMutex sync.RWMutex 36 interestedInNamespacesArgsForCall []struct { 37 } 38 interestedInNamespacesReturns struct { 39 result1 []string 40 } 41 interestedInNamespacesReturnsOnCall map[int]struct { 42 result1 []string 43 } 44 StateCommitDoneStub func(string) 45 stateCommitDoneMutex sync.RWMutex 46 stateCommitDoneArgsForCall []struct { 47 arg1 string 48 } 49 invocations map[string][][]interface{} 50 invocationsMutex sync.RWMutex 51 } 52 53 func (fake *StateListener) HandleStateUpdates(arg1 *ledger.StateUpdateTrigger) error { 54 fake.handleStateUpdatesMutex.Lock() 55 ret, specificReturn := fake.handleStateUpdatesReturnsOnCall[len(fake.handleStateUpdatesArgsForCall)] 56 fake.handleStateUpdatesArgsForCall = append(fake.handleStateUpdatesArgsForCall, struct { 57 arg1 *ledger.StateUpdateTrigger 58 }{arg1}) 59 fake.recordInvocation("HandleStateUpdates", []interface{}{arg1}) 60 fake.handleStateUpdatesMutex.Unlock() 61 if fake.HandleStateUpdatesStub != nil { 62 return fake.HandleStateUpdatesStub(arg1) 63 } 64 if specificReturn { 65 return ret.result1 66 } 67 fakeReturns := fake.handleStateUpdatesReturns 68 return fakeReturns.result1 69 } 70 71 func (fake *StateListener) HandleStateUpdatesCallCount() int { 72 fake.handleStateUpdatesMutex.RLock() 73 defer fake.handleStateUpdatesMutex.RUnlock() 74 return len(fake.handleStateUpdatesArgsForCall) 75 } 76 77 func (fake *StateListener) HandleStateUpdatesCalls(stub func(*ledger.StateUpdateTrigger) error) { 78 fake.handleStateUpdatesMutex.Lock() 79 defer fake.handleStateUpdatesMutex.Unlock() 80 fake.HandleStateUpdatesStub = stub 81 } 82 83 func (fake *StateListener) HandleStateUpdatesArgsForCall(i int) *ledger.StateUpdateTrigger { 84 fake.handleStateUpdatesMutex.RLock() 85 defer fake.handleStateUpdatesMutex.RUnlock() 86 argsForCall := fake.handleStateUpdatesArgsForCall[i] 87 return argsForCall.arg1 88 } 89 90 func (fake *StateListener) HandleStateUpdatesReturns(result1 error) { 91 fake.handleStateUpdatesMutex.Lock() 92 defer fake.handleStateUpdatesMutex.Unlock() 93 fake.HandleStateUpdatesStub = nil 94 fake.handleStateUpdatesReturns = struct { 95 result1 error 96 }{result1} 97 } 98 99 func (fake *StateListener) HandleStateUpdatesReturnsOnCall(i int, result1 error) { 100 fake.handleStateUpdatesMutex.Lock() 101 defer fake.handleStateUpdatesMutex.Unlock() 102 fake.HandleStateUpdatesStub = nil 103 if fake.handleStateUpdatesReturnsOnCall == nil { 104 fake.handleStateUpdatesReturnsOnCall = make(map[int]struct { 105 result1 error 106 }) 107 } 108 fake.handleStateUpdatesReturnsOnCall[i] = struct { 109 result1 error 110 }{result1} 111 } 112 113 func (fake *StateListener) Initialize(arg1 string, arg2 ledger.SimpleQueryExecutor) error { 114 fake.initializeMutex.Lock() 115 ret, specificReturn := fake.initializeReturnsOnCall[len(fake.initializeArgsForCall)] 116 fake.initializeArgsForCall = append(fake.initializeArgsForCall, struct { 117 arg1 string 118 arg2 ledger.SimpleQueryExecutor 119 }{arg1, arg2}) 120 fake.recordInvocation("Initialize", []interface{}{arg1, arg2}) 121 fake.initializeMutex.Unlock() 122 if fake.InitializeStub != nil { 123 return fake.InitializeStub(arg1, arg2) 124 } 125 if specificReturn { 126 return ret.result1 127 } 128 fakeReturns := fake.initializeReturns 129 return fakeReturns.result1 130 } 131 132 func (fake *StateListener) InitializeCallCount() int { 133 fake.initializeMutex.RLock() 134 defer fake.initializeMutex.RUnlock() 135 return len(fake.initializeArgsForCall) 136 } 137 138 func (fake *StateListener) InitializeCalls(stub func(string, ledger.SimpleQueryExecutor) error) { 139 fake.initializeMutex.Lock() 140 defer fake.initializeMutex.Unlock() 141 fake.InitializeStub = stub 142 } 143 144 func (fake *StateListener) InitializeArgsForCall(i int) (string, ledger.SimpleQueryExecutor) { 145 fake.initializeMutex.RLock() 146 defer fake.initializeMutex.RUnlock() 147 argsForCall := fake.initializeArgsForCall[i] 148 return argsForCall.arg1, argsForCall.arg2 149 } 150 151 func (fake *StateListener) InitializeReturns(result1 error) { 152 fake.initializeMutex.Lock() 153 defer fake.initializeMutex.Unlock() 154 fake.InitializeStub = nil 155 fake.initializeReturns = struct { 156 result1 error 157 }{result1} 158 } 159 160 func (fake *StateListener) InitializeReturnsOnCall(i int, result1 error) { 161 fake.initializeMutex.Lock() 162 defer fake.initializeMutex.Unlock() 163 fake.InitializeStub = nil 164 if fake.initializeReturnsOnCall == nil { 165 fake.initializeReturnsOnCall = make(map[int]struct { 166 result1 error 167 }) 168 } 169 fake.initializeReturnsOnCall[i] = struct { 170 result1 error 171 }{result1} 172 } 173 174 func (fake *StateListener) InterestedInNamespaces() []string { 175 fake.interestedInNamespacesMutex.Lock() 176 ret, specificReturn := fake.interestedInNamespacesReturnsOnCall[len(fake.interestedInNamespacesArgsForCall)] 177 fake.interestedInNamespacesArgsForCall = append(fake.interestedInNamespacesArgsForCall, struct { 178 }{}) 179 fake.recordInvocation("InterestedInNamespaces", []interface{}{}) 180 fake.interestedInNamespacesMutex.Unlock() 181 if fake.InterestedInNamespacesStub != nil { 182 return fake.InterestedInNamespacesStub() 183 } 184 if specificReturn { 185 return ret.result1 186 } 187 fakeReturns := fake.interestedInNamespacesReturns 188 return fakeReturns.result1 189 } 190 191 func (fake *StateListener) InterestedInNamespacesCallCount() int { 192 fake.interestedInNamespacesMutex.RLock() 193 defer fake.interestedInNamespacesMutex.RUnlock() 194 return len(fake.interestedInNamespacesArgsForCall) 195 } 196 197 func (fake *StateListener) InterestedInNamespacesCalls(stub func() []string) { 198 fake.interestedInNamespacesMutex.Lock() 199 defer fake.interestedInNamespacesMutex.Unlock() 200 fake.InterestedInNamespacesStub = stub 201 } 202 203 func (fake *StateListener) InterestedInNamespacesReturns(result1 []string) { 204 fake.interestedInNamespacesMutex.Lock() 205 defer fake.interestedInNamespacesMutex.Unlock() 206 fake.InterestedInNamespacesStub = nil 207 fake.interestedInNamespacesReturns = struct { 208 result1 []string 209 }{result1} 210 } 211 212 func (fake *StateListener) InterestedInNamespacesReturnsOnCall(i int, result1 []string) { 213 fake.interestedInNamespacesMutex.Lock() 214 defer fake.interestedInNamespacesMutex.Unlock() 215 fake.InterestedInNamespacesStub = nil 216 if fake.interestedInNamespacesReturnsOnCall == nil { 217 fake.interestedInNamespacesReturnsOnCall = make(map[int]struct { 218 result1 []string 219 }) 220 } 221 fake.interestedInNamespacesReturnsOnCall[i] = struct { 222 result1 []string 223 }{result1} 224 } 225 226 func (fake *StateListener) StateCommitDone(arg1 string) { 227 fake.stateCommitDoneMutex.Lock() 228 fake.stateCommitDoneArgsForCall = append(fake.stateCommitDoneArgsForCall, struct { 229 arg1 string 230 }{arg1}) 231 fake.recordInvocation("StateCommitDone", []interface{}{arg1}) 232 fake.stateCommitDoneMutex.Unlock() 233 if fake.StateCommitDoneStub != nil { 234 fake.StateCommitDoneStub(arg1) 235 } 236 } 237 238 func (fake *StateListener) StateCommitDoneCallCount() int { 239 fake.stateCommitDoneMutex.RLock() 240 defer fake.stateCommitDoneMutex.RUnlock() 241 return len(fake.stateCommitDoneArgsForCall) 242 } 243 244 func (fake *StateListener) StateCommitDoneCalls(stub func(string)) { 245 fake.stateCommitDoneMutex.Lock() 246 defer fake.stateCommitDoneMutex.Unlock() 247 fake.StateCommitDoneStub = stub 248 } 249 250 func (fake *StateListener) StateCommitDoneArgsForCall(i int) string { 251 fake.stateCommitDoneMutex.RLock() 252 defer fake.stateCommitDoneMutex.RUnlock() 253 argsForCall := fake.stateCommitDoneArgsForCall[i] 254 return argsForCall.arg1 255 } 256 257 func (fake *StateListener) Invocations() map[string][][]interface{} { 258 fake.invocationsMutex.RLock() 259 defer fake.invocationsMutex.RUnlock() 260 fake.handleStateUpdatesMutex.RLock() 261 defer fake.handleStateUpdatesMutex.RUnlock() 262 fake.initializeMutex.RLock() 263 defer fake.initializeMutex.RUnlock() 264 fake.interestedInNamespacesMutex.RLock() 265 defer fake.interestedInNamespacesMutex.RUnlock() 266 fake.stateCommitDoneMutex.RLock() 267 defer fake.stateCommitDoneMutex.RUnlock() 268 copiedInvocations := map[string][][]interface{}{} 269 for key, value := range fake.invocations { 270 copiedInvocations[key] = value 271 } 272 return copiedInvocations 273 } 274 275 func (fake *StateListener) recordInvocation(key string, args []interface{}) { 276 fake.invocationsMutex.Lock() 277 defer fake.invocationsMutex.Unlock() 278 if fake.invocations == nil { 279 fake.invocations = map[string][][]interface{}{} 280 } 281 if fake.invocations[key] == nil { 282 fake.invocations[key] = [][]interface{}{} 283 } 284 fake.invocations[key] = append(fake.invocations[key], args) 285 } 286 287 var _ ledger.StateListener = new(StateListener)