github.com/Hnampk/fabric@v2.1.1+incompatible/core/ledger/kvledger/txmgmt/queryutil/mock/query_executer.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/kvledger/txmgmt/queryutil" 8 "github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/statedb" 9 ) 10 11 type QueryExecuter struct { 12 GetPrivateDataHashStub func(string, string, string) (*statedb.VersionedValue, error) 13 getPrivateDataHashMutex sync.RWMutex 14 getPrivateDataHashArgsForCall []struct { 15 arg1 string 16 arg2 string 17 arg3 string 18 } 19 getPrivateDataHashReturns struct { 20 result1 *statedb.VersionedValue 21 result2 error 22 } 23 getPrivateDataHashReturnsOnCall map[int]struct { 24 result1 *statedb.VersionedValue 25 result2 error 26 } 27 GetStateStub func(string, string) (*statedb.VersionedValue, error) 28 getStateMutex sync.RWMutex 29 getStateArgsForCall []struct { 30 arg1 string 31 arg2 string 32 } 33 getStateReturns struct { 34 result1 *statedb.VersionedValue 35 result2 error 36 } 37 getStateReturnsOnCall map[int]struct { 38 result1 *statedb.VersionedValue 39 result2 error 40 } 41 GetStateRangeScanIteratorStub func(string, string, string) (statedb.ResultsIterator, error) 42 getStateRangeScanIteratorMutex sync.RWMutex 43 getStateRangeScanIteratorArgsForCall []struct { 44 arg1 string 45 arg2 string 46 arg3 string 47 } 48 getStateRangeScanIteratorReturns struct { 49 result1 statedb.ResultsIterator 50 result2 error 51 } 52 getStateRangeScanIteratorReturnsOnCall map[int]struct { 53 result1 statedb.ResultsIterator 54 result2 error 55 } 56 invocations map[string][][]interface{} 57 invocationsMutex sync.RWMutex 58 } 59 60 func (fake *QueryExecuter) GetPrivateDataHash(arg1 string, arg2 string, arg3 string) (*statedb.VersionedValue, error) { 61 fake.getPrivateDataHashMutex.Lock() 62 ret, specificReturn := fake.getPrivateDataHashReturnsOnCall[len(fake.getPrivateDataHashArgsForCall)] 63 fake.getPrivateDataHashArgsForCall = append(fake.getPrivateDataHashArgsForCall, struct { 64 arg1 string 65 arg2 string 66 arg3 string 67 }{arg1, arg2, arg3}) 68 fake.recordInvocation("GetPrivateDataHash", []interface{}{arg1, arg2, arg3}) 69 fake.getPrivateDataHashMutex.Unlock() 70 if fake.GetPrivateDataHashStub != nil { 71 return fake.GetPrivateDataHashStub(arg1, arg2, arg3) 72 } 73 if specificReturn { 74 return ret.result1, ret.result2 75 } 76 fakeReturns := fake.getPrivateDataHashReturns 77 return fakeReturns.result1, fakeReturns.result2 78 } 79 80 func (fake *QueryExecuter) GetPrivateDataHashCallCount() int { 81 fake.getPrivateDataHashMutex.RLock() 82 defer fake.getPrivateDataHashMutex.RUnlock() 83 return len(fake.getPrivateDataHashArgsForCall) 84 } 85 86 func (fake *QueryExecuter) GetPrivateDataHashCalls(stub func(string, string, string) (*statedb.VersionedValue, error)) { 87 fake.getPrivateDataHashMutex.Lock() 88 defer fake.getPrivateDataHashMutex.Unlock() 89 fake.GetPrivateDataHashStub = stub 90 } 91 92 func (fake *QueryExecuter) GetPrivateDataHashArgsForCall(i int) (string, string, string) { 93 fake.getPrivateDataHashMutex.RLock() 94 defer fake.getPrivateDataHashMutex.RUnlock() 95 argsForCall := fake.getPrivateDataHashArgsForCall[i] 96 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 97 } 98 99 func (fake *QueryExecuter) GetPrivateDataHashReturns(result1 *statedb.VersionedValue, result2 error) { 100 fake.getPrivateDataHashMutex.Lock() 101 defer fake.getPrivateDataHashMutex.Unlock() 102 fake.GetPrivateDataHashStub = nil 103 fake.getPrivateDataHashReturns = struct { 104 result1 *statedb.VersionedValue 105 result2 error 106 }{result1, result2} 107 } 108 109 func (fake *QueryExecuter) GetPrivateDataHashReturnsOnCall(i int, result1 *statedb.VersionedValue, result2 error) { 110 fake.getPrivateDataHashMutex.Lock() 111 defer fake.getPrivateDataHashMutex.Unlock() 112 fake.GetPrivateDataHashStub = nil 113 if fake.getPrivateDataHashReturnsOnCall == nil { 114 fake.getPrivateDataHashReturnsOnCall = make(map[int]struct { 115 result1 *statedb.VersionedValue 116 result2 error 117 }) 118 } 119 fake.getPrivateDataHashReturnsOnCall[i] = struct { 120 result1 *statedb.VersionedValue 121 result2 error 122 }{result1, result2} 123 } 124 125 func (fake *QueryExecuter) GetState(arg1 string, arg2 string) (*statedb.VersionedValue, error) { 126 fake.getStateMutex.Lock() 127 ret, specificReturn := fake.getStateReturnsOnCall[len(fake.getStateArgsForCall)] 128 fake.getStateArgsForCall = append(fake.getStateArgsForCall, struct { 129 arg1 string 130 arg2 string 131 }{arg1, arg2}) 132 fake.recordInvocation("GetState", []interface{}{arg1, arg2}) 133 fake.getStateMutex.Unlock() 134 if fake.GetStateStub != nil { 135 return fake.GetStateStub(arg1, arg2) 136 } 137 if specificReturn { 138 return ret.result1, ret.result2 139 } 140 fakeReturns := fake.getStateReturns 141 return fakeReturns.result1, fakeReturns.result2 142 } 143 144 func (fake *QueryExecuter) GetStateCallCount() int { 145 fake.getStateMutex.RLock() 146 defer fake.getStateMutex.RUnlock() 147 return len(fake.getStateArgsForCall) 148 } 149 150 func (fake *QueryExecuter) GetStateCalls(stub func(string, string) (*statedb.VersionedValue, error)) { 151 fake.getStateMutex.Lock() 152 defer fake.getStateMutex.Unlock() 153 fake.GetStateStub = stub 154 } 155 156 func (fake *QueryExecuter) GetStateArgsForCall(i int) (string, string) { 157 fake.getStateMutex.RLock() 158 defer fake.getStateMutex.RUnlock() 159 argsForCall := fake.getStateArgsForCall[i] 160 return argsForCall.arg1, argsForCall.arg2 161 } 162 163 func (fake *QueryExecuter) GetStateReturns(result1 *statedb.VersionedValue, result2 error) { 164 fake.getStateMutex.Lock() 165 defer fake.getStateMutex.Unlock() 166 fake.GetStateStub = nil 167 fake.getStateReturns = struct { 168 result1 *statedb.VersionedValue 169 result2 error 170 }{result1, result2} 171 } 172 173 func (fake *QueryExecuter) GetStateReturnsOnCall(i int, result1 *statedb.VersionedValue, result2 error) { 174 fake.getStateMutex.Lock() 175 defer fake.getStateMutex.Unlock() 176 fake.GetStateStub = nil 177 if fake.getStateReturnsOnCall == nil { 178 fake.getStateReturnsOnCall = make(map[int]struct { 179 result1 *statedb.VersionedValue 180 result2 error 181 }) 182 } 183 fake.getStateReturnsOnCall[i] = struct { 184 result1 *statedb.VersionedValue 185 result2 error 186 }{result1, result2} 187 } 188 189 func (fake *QueryExecuter) GetStateRangeScanIterator(arg1 string, arg2 string, arg3 string) (statedb.ResultsIterator, error) { 190 fake.getStateRangeScanIteratorMutex.Lock() 191 ret, specificReturn := fake.getStateRangeScanIteratorReturnsOnCall[len(fake.getStateRangeScanIteratorArgsForCall)] 192 fake.getStateRangeScanIteratorArgsForCall = append(fake.getStateRangeScanIteratorArgsForCall, struct { 193 arg1 string 194 arg2 string 195 arg3 string 196 }{arg1, arg2, arg3}) 197 fake.recordInvocation("GetStateRangeScanIterator", []interface{}{arg1, arg2, arg3}) 198 fake.getStateRangeScanIteratorMutex.Unlock() 199 if fake.GetStateRangeScanIteratorStub != nil { 200 return fake.GetStateRangeScanIteratorStub(arg1, arg2, arg3) 201 } 202 if specificReturn { 203 return ret.result1, ret.result2 204 } 205 fakeReturns := fake.getStateRangeScanIteratorReturns 206 return fakeReturns.result1, fakeReturns.result2 207 } 208 209 func (fake *QueryExecuter) GetStateRangeScanIteratorCallCount() int { 210 fake.getStateRangeScanIteratorMutex.RLock() 211 defer fake.getStateRangeScanIteratorMutex.RUnlock() 212 return len(fake.getStateRangeScanIteratorArgsForCall) 213 } 214 215 func (fake *QueryExecuter) GetStateRangeScanIteratorCalls(stub func(string, string, string) (statedb.ResultsIterator, error)) { 216 fake.getStateRangeScanIteratorMutex.Lock() 217 defer fake.getStateRangeScanIteratorMutex.Unlock() 218 fake.GetStateRangeScanIteratorStub = stub 219 } 220 221 func (fake *QueryExecuter) GetStateRangeScanIteratorArgsForCall(i int) (string, string, string) { 222 fake.getStateRangeScanIteratorMutex.RLock() 223 defer fake.getStateRangeScanIteratorMutex.RUnlock() 224 argsForCall := fake.getStateRangeScanIteratorArgsForCall[i] 225 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 226 } 227 228 func (fake *QueryExecuter) GetStateRangeScanIteratorReturns(result1 statedb.ResultsIterator, result2 error) { 229 fake.getStateRangeScanIteratorMutex.Lock() 230 defer fake.getStateRangeScanIteratorMutex.Unlock() 231 fake.GetStateRangeScanIteratorStub = nil 232 fake.getStateRangeScanIteratorReturns = struct { 233 result1 statedb.ResultsIterator 234 result2 error 235 }{result1, result2} 236 } 237 238 func (fake *QueryExecuter) GetStateRangeScanIteratorReturnsOnCall(i int, result1 statedb.ResultsIterator, result2 error) { 239 fake.getStateRangeScanIteratorMutex.Lock() 240 defer fake.getStateRangeScanIteratorMutex.Unlock() 241 fake.GetStateRangeScanIteratorStub = nil 242 if fake.getStateRangeScanIteratorReturnsOnCall == nil { 243 fake.getStateRangeScanIteratorReturnsOnCall = make(map[int]struct { 244 result1 statedb.ResultsIterator 245 result2 error 246 }) 247 } 248 fake.getStateRangeScanIteratorReturnsOnCall[i] = struct { 249 result1 statedb.ResultsIterator 250 result2 error 251 }{result1, result2} 252 } 253 254 func (fake *QueryExecuter) Invocations() map[string][][]interface{} { 255 fake.invocationsMutex.RLock() 256 defer fake.invocationsMutex.RUnlock() 257 fake.getPrivateDataHashMutex.RLock() 258 defer fake.getPrivateDataHashMutex.RUnlock() 259 fake.getStateMutex.RLock() 260 defer fake.getStateMutex.RUnlock() 261 fake.getStateRangeScanIteratorMutex.RLock() 262 defer fake.getStateRangeScanIteratorMutex.RUnlock() 263 copiedInvocations := map[string][][]interface{}{} 264 for key, value := range fake.invocations { 265 copiedInvocations[key] = value 266 } 267 return copiedInvocations 268 } 269 270 func (fake *QueryExecuter) recordInvocation(key string, args []interface{}) { 271 fake.invocationsMutex.Lock() 272 defer fake.invocationsMutex.Unlock() 273 if fake.invocations == nil { 274 fake.invocations = map[string][][]interface{}{} 275 } 276 if fake.invocations[key] == nil { 277 fake.invocations[key] = [][]interface{}{} 278 } 279 fake.invocations[key] = append(fake.invocations[key], args) 280 } 281 282 var _ queryutil.QueryExecuter = new(QueryExecuter)