github.com/renegr87/renegr87@v2.1.1+incompatible/core/ledger/kvledger/txmgmt/statedb/mock/versioned_db.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/statedb" 8 "github.com/hyperledger/fabric/core/ledger/kvledger/txmgmt/version" 9 ) 10 11 type VersionedDB struct { 12 ApplyUpdatesStub func(*statedb.UpdateBatch, *version.Height) error 13 applyUpdatesMutex sync.RWMutex 14 applyUpdatesArgsForCall []struct { 15 arg1 *statedb.UpdateBatch 16 arg2 *version.Height 17 } 18 applyUpdatesReturns struct { 19 result1 error 20 } 21 applyUpdatesReturnsOnCall map[int]struct { 22 result1 error 23 } 24 BytesKeySupportedStub func() bool 25 bytesKeySupportedMutex sync.RWMutex 26 bytesKeySupportedArgsForCall []struct { 27 } 28 bytesKeySupportedReturns struct { 29 result1 bool 30 } 31 bytesKeySupportedReturnsOnCall map[int]struct { 32 result1 bool 33 } 34 CloseStub func() 35 closeMutex sync.RWMutex 36 closeArgsForCall []struct { 37 } 38 ExecuteQueryStub func(string, string) (statedb.ResultsIterator, error) 39 executeQueryMutex sync.RWMutex 40 executeQueryArgsForCall []struct { 41 arg1 string 42 arg2 string 43 } 44 executeQueryReturns struct { 45 result1 statedb.ResultsIterator 46 result2 error 47 } 48 executeQueryReturnsOnCall map[int]struct { 49 result1 statedb.ResultsIterator 50 result2 error 51 } 52 ExecuteQueryWithMetadataStub func(string, string, map[string]interface{}) (statedb.QueryResultsIterator, error) 53 executeQueryWithMetadataMutex sync.RWMutex 54 executeQueryWithMetadataArgsForCall []struct { 55 arg1 string 56 arg2 string 57 arg3 map[string]interface{} 58 } 59 executeQueryWithMetadataReturns struct { 60 result1 statedb.QueryResultsIterator 61 result2 error 62 } 63 executeQueryWithMetadataReturnsOnCall map[int]struct { 64 result1 statedb.QueryResultsIterator 65 result2 error 66 } 67 GetLatestSavePointStub func() (*version.Height, error) 68 getLatestSavePointMutex sync.RWMutex 69 getLatestSavePointArgsForCall []struct { 70 } 71 getLatestSavePointReturns struct { 72 result1 *version.Height 73 result2 error 74 } 75 getLatestSavePointReturnsOnCall map[int]struct { 76 result1 *version.Height 77 result2 error 78 } 79 GetStateStub func(string, string) (*statedb.VersionedValue, error) 80 getStateMutex sync.RWMutex 81 getStateArgsForCall []struct { 82 arg1 string 83 arg2 string 84 } 85 getStateReturns struct { 86 result1 *statedb.VersionedValue 87 result2 error 88 } 89 getStateReturnsOnCall map[int]struct { 90 result1 *statedb.VersionedValue 91 result2 error 92 } 93 GetStateMultipleKeysStub func(string, []string) ([]*statedb.VersionedValue, error) 94 getStateMultipleKeysMutex sync.RWMutex 95 getStateMultipleKeysArgsForCall []struct { 96 arg1 string 97 arg2 []string 98 } 99 getStateMultipleKeysReturns struct { 100 result1 []*statedb.VersionedValue 101 result2 error 102 } 103 getStateMultipleKeysReturnsOnCall map[int]struct { 104 result1 []*statedb.VersionedValue 105 result2 error 106 } 107 GetStateRangeScanIteratorStub func(string, string, string) (statedb.ResultsIterator, error) 108 getStateRangeScanIteratorMutex sync.RWMutex 109 getStateRangeScanIteratorArgsForCall []struct { 110 arg1 string 111 arg2 string 112 arg3 string 113 } 114 getStateRangeScanIteratorReturns struct { 115 result1 statedb.ResultsIterator 116 result2 error 117 } 118 getStateRangeScanIteratorReturnsOnCall map[int]struct { 119 result1 statedb.ResultsIterator 120 result2 error 121 } 122 GetStateRangeScanIteratorWithMetadataStub func(string, string, string, map[string]interface{}) (statedb.QueryResultsIterator, error) 123 getStateRangeScanIteratorWithMetadataMutex sync.RWMutex 124 getStateRangeScanIteratorWithMetadataArgsForCall []struct { 125 arg1 string 126 arg2 string 127 arg3 string 128 arg4 map[string]interface{} 129 } 130 getStateRangeScanIteratorWithMetadataReturns struct { 131 result1 statedb.QueryResultsIterator 132 result2 error 133 } 134 getStateRangeScanIteratorWithMetadataReturnsOnCall map[int]struct { 135 result1 statedb.QueryResultsIterator 136 result2 error 137 } 138 GetVersionStub func(string, string) (*version.Height, error) 139 getVersionMutex sync.RWMutex 140 getVersionArgsForCall []struct { 141 arg1 string 142 arg2 string 143 } 144 getVersionReturns struct { 145 result1 *version.Height 146 result2 error 147 } 148 getVersionReturnsOnCall map[int]struct { 149 result1 *version.Height 150 result2 error 151 } 152 OpenStub func() error 153 openMutex sync.RWMutex 154 openArgsForCall []struct { 155 } 156 openReturns struct { 157 result1 error 158 } 159 openReturnsOnCall map[int]struct { 160 result1 error 161 } 162 ValidateKeyValueStub func(string, []byte) error 163 validateKeyValueMutex sync.RWMutex 164 validateKeyValueArgsForCall []struct { 165 arg1 string 166 arg2 []byte 167 } 168 validateKeyValueReturns struct { 169 result1 error 170 } 171 validateKeyValueReturnsOnCall map[int]struct { 172 result1 error 173 } 174 invocations map[string][][]interface{} 175 invocationsMutex sync.RWMutex 176 } 177 178 func (fake *VersionedDB) ApplyUpdates(arg1 *statedb.UpdateBatch, arg2 *version.Height) error { 179 fake.applyUpdatesMutex.Lock() 180 ret, specificReturn := fake.applyUpdatesReturnsOnCall[len(fake.applyUpdatesArgsForCall)] 181 fake.applyUpdatesArgsForCall = append(fake.applyUpdatesArgsForCall, struct { 182 arg1 *statedb.UpdateBatch 183 arg2 *version.Height 184 }{arg1, arg2}) 185 fake.recordInvocation("ApplyUpdates", []interface{}{arg1, arg2}) 186 fake.applyUpdatesMutex.Unlock() 187 if fake.ApplyUpdatesStub != nil { 188 return fake.ApplyUpdatesStub(arg1, arg2) 189 } 190 if specificReturn { 191 return ret.result1 192 } 193 fakeReturns := fake.applyUpdatesReturns 194 return fakeReturns.result1 195 } 196 197 func (fake *VersionedDB) ApplyUpdatesCallCount() int { 198 fake.applyUpdatesMutex.RLock() 199 defer fake.applyUpdatesMutex.RUnlock() 200 return len(fake.applyUpdatesArgsForCall) 201 } 202 203 func (fake *VersionedDB) ApplyUpdatesCalls(stub func(*statedb.UpdateBatch, *version.Height) error) { 204 fake.applyUpdatesMutex.Lock() 205 defer fake.applyUpdatesMutex.Unlock() 206 fake.ApplyUpdatesStub = stub 207 } 208 209 func (fake *VersionedDB) ApplyUpdatesArgsForCall(i int) (*statedb.UpdateBatch, *version.Height) { 210 fake.applyUpdatesMutex.RLock() 211 defer fake.applyUpdatesMutex.RUnlock() 212 argsForCall := fake.applyUpdatesArgsForCall[i] 213 return argsForCall.arg1, argsForCall.arg2 214 } 215 216 func (fake *VersionedDB) ApplyUpdatesReturns(result1 error) { 217 fake.applyUpdatesMutex.Lock() 218 defer fake.applyUpdatesMutex.Unlock() 219 fake.ApplyUpdatesStub = nil 220 fake.applyUpdatesReturns = struct { 221 result1 error 222 }{result1} 223 } 224 225 func (fake *VersionedDB) ApplyUpdatesReturnsOnCall(i int, result1 error) { 226 fake.applyUpdatesMutex.Lock() 227 defer fake.applyUpdatesMutex.Unlock() 228 fake.ApplyUpdatesStub = nil 229 if fake.applyUpdatesReturnsOnCall == nil { 230 fake.applyUpdatesReturnsOnCall = make(map[int]struct { 231 result1 error 232 }) 233 } 234 fake.applyUpdatesReturnsOnCall[i] = struct { 235 result1 error 236 }{result1} 237 } 238 239 func (fake *VersionedDB) BytesKeySupported() bool { 240 fake.bytesKeySupportedMutex.Lock() 241 ret, specificReturn := fake.bytesKeySupportedReturnsOnCall[len(fake.bytesKeySupportedArgsForCall)] 242 fake.bytesKeySupportedArgsForCall = append(fake.bytesKeySupportedArgsForCall, struct { 243 }{}) 244 fake.recordInvocation("BytesKeySupported", []interface{}{}) 245 fake.bytesKeySupportedMutex.Unlock() 246 if fake.BytesKeySupportedStub != nil { 247 return fake.BytesKeySupportedStub() 248 } 249 if specificReturn { 250 return ret.result1 251 } 252 fakeReturns := fake.bytesKeySupportedReturns 253 return fakeReturns.result1 254 } 255 256 func (fake *VersionedDB) BytesKeySupportedCallCount() int { 257 fake.bytesKeySupportedMutex.RLock() 258 defer fake.bytesKeySupportedMutex.RUnlock() 259 return len(fake.bytesKeySupportedArgsForCall) 260 } 261 262 func (fake *VersionedDB) BytesKeySupportedCalls(stub func() bool) { 263 fake.bytesKeySupportedMutex.Lock() 264 defer fake.bytesKeySupportedMutex.Unlock() 265 fake.BytesKeySupportedStub = stub 266 } 267 268 func (fake *VersionedDB) BytesKeySupportedReturns(result1 bool) { 269 fake.bytesKeySupportedMutex.Lock() 270 defer fake.bytesKeySupportedMutex.Unlock() 271 fake.BytesKeySupportedStub = nil 272 fake.bytesKeySupportedReturns = struct { 273 result1 bool 274 }{result1} 275 } 276 277 func (fake *VersionedDB) BytesKeySupportedReturnsOnCall(i int, result1 bool) { 278 fake.bytesKeySupportedMutex.Lock() 279 defer fake.bytesKeySupportedMutex.Unlock() 280 fake.BytesKeySupportedStub = nil 281 if fake.bytesKeySupportedReturnsOnCall == nil { 282 fake.bytesKeySupportedReturnsOnCall = make(map[int]struct { 283 result1 bool 284 }) 285 } 286 fake.bytesKeySupportedReturnsOnCall[i] = struct { 287 result1 bool 288 }{result1} 289 } 290 291 func (fake *VersionedDB) Close() { 292 fake.closeMutex.Lock() 293 fake.closeArgsForCall = append(fake.closeArgsForCall, struct { 294 }{}) 295 fake.recordInvocation("Close", []interface{}{}) 296 fake.closeMutex.Unlock() 297 if fake.CloseStub != nil { 298 fake.CloseStub() 299 } 300 } 301 302 func (fake *VersionedDB) CloseCallCount() int { 303 fake.closeMutex.RLock() 304 defer fake.closeMutex.RUnlock() 305 return len(fake.closeArgsForCall) 306 } 307 308 func (fake *VersionedDB) CloseCalls(stub func()) { 309 fake.closeMutex.Lock() 310 defer fake.closeMutex.Unlock() 311 fake.CloseStub = stub 312 } 313 314 func (fake *VersionedDB) ExecuteQuery(arg1 string, arg2 string) (statedb.ResultsIterator, error) { 315 fake.executeQueryMutex.Lock() 316 ret, specificReturn := fake.executeQueryReturnsOnCall[len(fake.executeQueryArgsForCall)] 317 fake.executeQueryArgsForCall = append(fake.executeQueryArgsForCall, struct { 318 arg1 string 319 arg2 string 320 }{arg1, arg2}) 321 fake.recordInvocation("ExecuteQuery", []interface{}{arg1, arg2}) 322 fake.executeQueryMutex.Unlock() 323 if fake.ExecuteQueryStub != nil { 324 return fake.ExecuteQueryStub(arg1, arg2) 325 } 326 if specificReturn { 327 return ret.result1, ret.result2 328 } 329 fakeReturns := fake.executeQueryReturns 330 return fakeReturns.result1, fakeReturns.result2 331 } 332 333 func (fake *VersionedDB) ExecuteQueryCallCount() int { 334 fake.executeQueryMutex.RLock() 335 defer fake.executeQueryMutex.RUnlock() 336 return len(fake.executeQueryArgsForCall) 337 } 338 339 func (fake *VersionedDB) ExecuteQueryCalls(stub func(string, string) (statedb.ResultsIterator, error)) { 340 fake.executeQueryMutex.Lock() 341 defer fake.executeQueryMutex.Unlock() 342 fake.ExecuteQueryStub = stub 343 } 344 345 func (fake *VersionedDB) ExecuteQueryArgsForCall(i int) (string, string) { 346 fake.executeQueryMutex.RLock() 347 defer fake.executeQueryMutex.RUnlock() 348 argsForCall := fake.executeQueryArgsForCall[i] 349 return argsForCall.arg1, argsForCall.arg2 350 } 351 352 func (fake *VersionedDB) ExecuteQueryReturns(result1 statedb.ResultsIterator, result2 error) { 353 fake.executeQueryMutex.Lock() 354 defer fake.executeQueryMutex.Unlock() 355 fake.ExecuteQueryStub = nil 356 fake.executeQueryReturns = struct { 357 result1 statedb.ResultsIterator 358 result2 error 359 }{result1, result2} 360 } 361 362 func (fake *VersionedDB) ExecuteQueryReturnsOnCall(i int, result1 statedb.ResultsIterator, result2 error) { 363 fake.executeQueryMutex.Lock() 364 defer fake.executeQueryMutex.Unlock() 365 fake.ExecuteQueryStub = nil 366 if fake.executeQueryReturnsOnCall == nil { 367 fake.executeQueryReturnsOnCall = make(map[int]struct { 368 result1 statedb.ResultsIterator 369 result2 error 370 }) 371 } 372 fake.executeQueryReturnsOnCall[i] = struct { 373 result1 statedb.ResultsIterator 374 result2 error 375 }{result1, result2} 376 } 377 378 func (fake *VersionedDB) ExecuteQueryWithMetadata(arg1 string, arg2 string, arg3 map[string]interface{}) (statedb.QueryResultsIterator, error) { 379 fake.executeQueryWithMetadataMutex.Lock() 380 ret, specificReturn := fake.executeQueryWithMetadataReturnsOnCall[len(fake.executeQueryWithMetadataArgsForCall)] 381 fake.executeQueryWithMetadataArgsForCall = append(fake.executeQueryWithMetadataArgsForCall, struct { 382 arg1 string 383 arg2 string 384 arg3 map[string]interface{} 385 }{arg1, arg2, arg3}) 386 fake.recordInvocation("ExecuteQueryWithMetadata", []interface{}{arg1, arg2, arg3}) 387 fake.executeQueryWithMetadataMutex.Unlock() 388 if fake.ExecuteQueryWithMetadataStub != nil { 389 return fake.ExecuteQueryWithMetadataStub(arg1, arg2, arg3) 390 } 391 if specificReturn { 392 return ret.result1, ret.result2 393 } 394 fakeReturns := fake.executeQueryWithMetadataReturns 395 return fakeReturns.result1, fakeReturns.result2 396 } 397 398 func (fake *VersionedDB) ExecuteQueryWithMetadataCallCount() int { 399 fake.executeQueryWithMetadataMutex.RLock() 400 defer fake.executeQueryWithMetadataMutex.RUnlock() 401 return len(fake.executeQueryWithMetadataArgsForCall) 402 } 403 404 func (fake *VersionedDB) ExecuteQueryWithMetadataCalls(stub func(string, string, map[string]interface{}) (statedb.QueryResultsIterator, error)) { 405 fake.executeQueryWithMetadataMutex.Lock() 406 defer fake.executeQueryWithMetadataMutex.Unlock() 407 fake.ExecuteQueryWithMetadataStub = stub 408 } 409 410 func (fake *VersionedDB) ExecuteQueryWithMetadataArgsForCall(i int) (string, string, map[string]interface{}) { 411 fake.executeQueryWithMetadataMutex.RLock() 412 defer fake.executeQueryWithMetadataMutex.RUnlock() 413 argsForCall := fake.executeQueryWithMetadataArgsForCall[i] 414 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 415 } 416 417 func (fake *VersionedDB) ExecuteQueryWithMetadataReturns(result1 statedb.QueryResultsIterator, result2 error) { 418 fake.executeQueryWithMetadataMutex.Lock() 419 defer fake.executeQueryWithMetadataMutex.Unlock() 420 fake.ExecuteQueryWithMetadataStub = nil 421 fake.executeQueryWithMetadataReturns = struct { 422 result1 statedb.QueryResultsIterator 423 result2 error 424 }{result1, result2} 425 } 426 427 func (fake *VersionedDB) ExecuteQueryWithMetadataReturnsOnCall(i int, result1 statedb.QueryResultsIterator, result2 error) { 428 fake.executeQueryWithMetadataMutex.Lock() 429 defer fake.executeQueryWithMetadataMutex.Unlock() 430 fake.ExecuteQueryWithMetadataStub = nil 431 if fake.executeQueryWithMetadataReturnsOnCall == nil { 432 fake.executeQueryWithMetadataReturnsOnCall = make(map[int]struct { 433 result1 statedb.QueryResultsIterator 434 result2 error 435 }) 436 } 437 fake.executeQueryWithMetadataReturnsOnCall[i] = struct { 438 result1 statedb.QueryResultsIterator 439 result2 error 440 }{result1, result2} 441 } 442 443 func (fake *VersionedDB) GetLatestSavePoint() (*version.Height, error) { 444 fake.getLatestSavePointMutex.Lock() 445 ret, specificReturn := fake.getLatestSavePointReturnsOnCall[len(fake.getLatestSavePointArgsForCall)] 446 fake.getLatestSavePointArgsForCall = append(fake.getLatestSavePointArgsForCall, struct { 447 }{}) 448 fake.recordInvocation("GetLatestSavePoint", []interface{}{}) 449 fake.getLatestSavePointMutex.Unlock() 450 if fake.GetLatestSavePointStub != nil { 451 return fake.GetLatestSavePointStub() 452 } 453 if specificReturn { 454 return ret.result1, ret.result2 455 } 456 fakeReturns := fake.getLatestSavePointReturns 457 return fakeReturns.result1, fakeReturns.result2 458 } 459 460 func (fake *VersionedDB) GetLatestSavePointCallCount() int { 461 fake.getLatestSavePointMutex.RLock() 462 defer fake.getLatestSavePointMutex.RUnlock() 463 return len(fake.getLatestSavePointArgsForCall) 464 } 465 466 func (fake *VersionedDB) GetLatestSavePointCalls(stub func() (*version.Height, error)) { 467 fake.getLatestSavePointMutex.Lock() 468 defer fake.getLatestSavePointMutex.Unlock() 469 fake.GetLatestSavePointStub = stub 470 } 471 472 func (fake *VersionedDB) GetLatestSavePointReturns(result1 *version.Height, result2 error) { 473 fake.getLatestSavePointMutex.Lock() 474 defer fake.getLatestSavePointMutex.Unlock() 475 fake.GetLatestSavePointStub = nil 476 fake.getLatestSavePointReturns = struct { 477 result1 *version.Height 478 result2 error 479 }{result1, result2} 480 } 481 482 func (fake *VersionedDB) GetLatestSavePointReturnsOnCall(i int, result1 *version.Height, result2 error) { 483 fake.getLatestSavePointMutex.Lock() 484 defer fake.getLatestSavePointMutex.Unlock() 485 fake.GetLatestSavePointStub = nil 486 if fake.getLatestSavePointReturnsOnCall == nil { 487 fake.getLatestSavePointReturnsOnCall = make(map[int]struct { 488 result1 *version.Height 489 result2 error 490 }) 491 } 492 fake.getLatestSavePointReturnsOnCall[i] = struct { 493 result1 *version.Height 494 result2 error 495 }{result1, result2} 496 } 497 498 func (fake *VersionedDB) GetState(arg1 string, arg2 string) (*statedb.VersionedValue, error) { 499 fake.getStateMutex.Lock() 500 ret, specificReturn := fake.getStateReturnsOnCall[len(fake.getStateArgsForCall)] 501 fake.getStateArgsForCall = append(fake.getStateArgsForCall, struct { 502 arg1 string 503 arg2 string 504 }{arg1, arg2}) 505 fake.recordInvocation("GetState", []interface{}{arg1, arg2}) 506 fake.getStateMutex.Unlock() 507 if fake.GetStateStub != nil { 508 return fake.GetStateStub(arg1, arg2) 509 } 510 if specificReturn { 511 return ret.result1, ret.result2 512 } 513 fakeReturns := fake.getStateReturns 514 return fakeReturns.result1, fakeReturns.result2 515 } 516 517 func (fake *VersionedDB) GetStateCallCount() int { 518 fake.getStateMutex.RLock() 519 defer fake.getStateMutex.RUnlock() 520 return len(fake.getStateArgsForCall) 521 } 522 523 func (fake *VersionedDB) GetStateCalls(stub func(string, string) (*statedb.VersionedValue, error)) { 524 fake.getStateMutex.Lock() 525 defer fake.getStateMutex.Unlock() 526 fake.GetStateStub = stub 527 } 528 529 func (fake *VersionedDB) GetStateArgsForCall(i int) (string, string) { 530 fake.getStateMutex.RLock() 531 defer fake.getStateMutex.RUnlock() 532 argsForCall := fake.getStateArgsForCall[i] 533 return argsForCall.arg1, argsForCall.arg2 534 } 535 536 func (fake *VersionedDB) GetStateReturns(result1 *statedb.VersionedValue, result2 error) { 537 fake.getStateMutex.Lock() 538 defer fake.getStateMutex.Unlock() 539 fake.GetStateStub = nil 540 fake.getStateReturns = struct { 541 result1 *statedb.VersionedValue 542 result2 error 543 }{result1, result2} 544 } 545 546 func (fake *VersionedDB) GetStateReturnsOnCall(i int, result1 *statedb.VersionedValue, result2 error) { 547 fake.getStateMutex.Lock() 548 defer fake.getStateMutex.Unlock() 549 fake.GetStateStub = nil 550 if fake.getStateReturnsOnCall == nil { 551 fake.getStateReturnsOnCall = make(map[int]struct { 552 result1 *statedb.VersionedValue 553 result2 error 554 }) 555 } 556 fake.getStateReturnsOnCall[i] = struct { 557 result1 *statedb.VersionedValue 558 result2 error 559 }{result1, result2} 560 } 561 562 func (fake *VersionedDB) GetStateMultipleKeys(arg1 string, arg2 []string) ([]*statedb.VersionedValue, error) { 563 var arg2Copy []string 564 if arg2 != nil { 565 arg2Copy = make([]string, len(arg2)) 566 copy(arg2Copy, arg2) 567 } 568 fake.getStateMultipleKeysMutex.Lock() 569 ret, specificReturn := fake.getStateMultipleKeysReturnsOnCall[len(fake.getStateMultipleKeysArgsForCall)] 570 fake.getStateMultipleKeysArgsForCall = append(fake.getStateMultipleKeysArgsForCall, struct { 571 arg1 string 572 arg2 []string 573 }{arg1, arg2Copy}) 574 fake.recordInvocation("GetStateMultipleKeys", []interface{}{arg1, arg2Copy}) 575 fake.getStateMultipleKeysMutex.Unlock() 576 if fake.GetStateMultipleKeysStub != nil { 577 return fake.GetStateMultipleKeysStub(arg1, arg2) 578 } 579 if specificReturn { 580 return ret.result1, ret.result2 581 } 582 fakeReturns := fake.getStateMultipleKeysReturns 583 return fakeReturns.result1, fakeReturns.result2 584 } 585 586 func (fake *VersionedDB) GetStateMultipleKeysCallCount() int { 587 fake.getStateMultipleKeysMutex.RLock() 588 defer fake.getStateMultipleKeysMutex.RUnlock() 589 return len(fake.getStateMultipleKeysArgsForCall) 590 } 591 592 func (fake *VersionedDB) GetStateMultipleKeysCalls(stub func(string, []string) ([]*statedb.VersionedValue, error)) { 593 fake.getStateMultipleKeysMutex.Lock() 594 defer fake.getStateMultipleKeysMutex.Unlock() 595 fake.GetStateMultipleKeysStub = stub 596 } 597 598 func (fake *VersionedDB) GetStateMultipleKeysArgsForCall(i int) (string, []string) { 599 fake.getStateMultipleKeysMutex.RLock() 600 defer fake.getStateMultipleKeysMutex.RUnlock() 601 argsForCall := fake.getStateMultipleKeysArgsForCall[i] 602 return argsForCall.arg1, argsForCall.arg2 603 } 604 605 func (fake *VersionedDB) GetStateMultipleKeysReturns(result1 []*statedb.VersionedValue, result2 error) { 606 fake.getStateMultipleKeysMutex.Lock() 607 defer fake.getStateMultipleKeysMutex.Unlock() 608 fake.GetStateMultipleKeysStub = nil 609 fake.getStateMultipleKeysReturns = struct { 610 result1 []*statedb.VersionedValue 611 result2 error 612 }{result1, result2} 613 } 614 615 func (fake *VersionedDB) GetStateMultipleKeysReturnsOnCall(i int, result1 []*statedb.VersionedValue, result2 error) { 616 fake.getStateMultipleKeysMutex.Lock() 617 defer fake.getStateMultipleKeysMutex.Unlock() 618 fake.GetStateMultipleKeysStub = nil 619 if fake.getStateMultipleKeysReturnsOnCall == nil { 620 fake.getStateMultipleKeysReturnsOnCall = make(map[int]struct { 621 result1 []*statedb.VersionedValue 622 result2 error 623 }) 624 } 625 fake.getStateMultipleKeysReturnsOnCall[i] = struct { 626 result1 []*statedb.VersionedValue 627 result2 error 628 }{result1, result2} 629 } 630 631 func (fake *VersionedDB) GetStateRangeScanIterator(arg1 string, arg2 string, arg3 string) (statedb.ResultsIterator, error) { 632 fake.getStateRangeScanIteratorMutex.Lock() 633 ret, specificReturn := fake.getStateRangeScanIteratorReturnsOnCall[len(fake.getStateRangeScanIteratorArgsForCall)] 634 fake.getStateRangeScanIteratorArgsForCall = append(fake.getStateRangeScanIteratorArgsForCall, struct { 635 arg1 string 636 arg2 string 637 arg3 string 638 }{arg1, arg2, arg3}) 639 fake.recordInvocation("GetStateRangeScanIterator", []interface{}{arg1, arg2, arg3}) 640 fake.getStateRangeScanIteratorMutex.Unlock() 641 if fake.GetStateRangeScanIteratorStub != nil { 642 return fake.GetStateRangeScanIteratorStub(arg1, arg2, arg3) 643 } 644 if specificReturn { 645 return ret.result1, ret.result2 646 } 647 fakeReturns := fake.getStateRangeScanIteratorReturns 648 return fakeReturns.result1, fakeReturns.result2 649 } 650 651 func (fake *VersionedDB) GetStateRangeScanIteratorCallCount() int { 652 fake.getStateRangeScanIteratorMutex.RLock() 653 defer fake.getStateRangeScanIteratorMutex.RUnlock() 654 return len(fake.getStateRangeScanIteratorArgsForCall) 655 } 656 657 func (fake *VersionedDB) GetStateRangeScanIteratorCalls(stub func(string, string, string) (statedb.ResultsIterator, error)) { 658 fake.getStateRangeScanIteratorMutex.Lock() 659 defer fake.getStateRangeScanIteratorMutex.Unlock() 660 fake.GetStateRangeScanIteratorStub = stub 661 } 662 663 func (fake *VersionedDB) GetStateRangeScanIteratorArgsForCall(i int) (string, string, string) { 664 fake.getStateRangeScanIteratorMutex.RLock() 665 defer fake.getStateRangeScanIteratorMutex.RUnlock() 666 argsForCall := fake.getStateRangeScanIteratorArgsForCall[i] 667 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 668 } 669 670 func (fake *VersionedDB) GetStateRangeScanIteratorReturns(result1 statedb.ResultsIterator, result2 error) { 671 fake.getStateRangeScanIteratorMutex.Lock() 672 defer fake.getStateRangeScanIteratorMutex.Unlock() 673 fake.GetStateRangeScanIteratorStub = nil 674 fake.getStateRangeScanIteratorReturns = struct { 675 result1 statedb.ResultsIterator 676 result2 error 677 }{result1, result2} 678 } 679 680 func (fake *VersionedDB) GetStateRangeScanIteratorReturnsOnCall(i int, result1 statedb.ResultsIterator, result2 error) { 681 fake.getStateRangeScanIteratorMutex.Lock() 682 defer fake.getStateRangeScanIteratorMutex.Unlock() 683 fake.GetStateRangeScanIteratorStub = nil 684 if fake.getStateRangeScanIteratorReturnsOnCall == nil { 685 fake.getStateRangeScanIteratorReturnsOnCall = make(map[int]struct { 686 result1 statedb.ResultsIterator 687 result2 error 688 }) 689 } 690 fake.getStateRangeScanIteratorReturnsOnCall[i] = struct { 691 result1 statedb.ResultsIterator 692 result2 error 693 }{result1, result2} 694 } 695 696 func (fake *VersionedDB) GetStateRangeScanIteratorWithMetadata(arg1 string, arg2 string, arg3 string, arg4 map[string]interface{}) (statedb.QueryResultsIterator, error) { 697 fake.getStateRangeScanIteratorWithMetadataMutex.Lock() 698 ret, specificReturn := fake.getStateRangeScanIteratorWithMetadataReturnsOnCall[len(fake.getStateRangeScanIteratorWithMetadataArgsForCall)] 699 fake.getStateRangeScanIteratorWithMetadataArgsForCall = append(fake.getStateRangeScanIteratorWithMetadataArgsForCall, struct { 700 arg1 string 701 arg2 string 702 arg3 string 703 arg4 map[string]interface{} 704 }{arg1, arg2, arg3, arg4}) 705 fake.recordInvocation("GetStateRangeScanIteratorWithMetadata", []interface{}{arg1, arg2, arg3, arg4}) 706 fake.getStateRangeScanIteratorWithMetadataMutex.Unlock() 707 if fake.GetStateRangeScanIteratorWithMetadataStub != nil { 708 return fake.GetStateRangeScanIteratorWithMetadataStub(arg1, arg2, arg3, arg4) 709 } 710 if specificReturn { 711 return ret.result1, ret.result2 712 } 713 fakeReturns := fake.getStateRangeScanIteratorWithMetadataReturns 714 return fakeReturns.result1, fakeReturns.result2 715 } 716 717 func (fake *VersionedDB) GetStateRangeScanIteratorWithMetadataCallCount() int { 718 fake.getStateRangeScanIteratorWithMetadataMutex.RLock() 719 defer fake.getStateRangeScanIteratorWithMetadataMutex.RUnlock() 720 return len(fake.getStateRangeScanIteratorWithMetadataArgsForCall) 721 } 722 723 func (fake *VersionedDB) GetStateRangeScanIteratorWithMetadataCalls(stub func(string, string, string, map[string]interface{}) (statedb.QueryResultsIterator, error)) { 724 fake.getStateRangeScanIteratorWithMetadataMutex.Lock() 725 defer fake.getStateRangeScanIteratorWithMetadataMutex.Unlock() 726 fake.GetStateRangeScanIteratorWithMetadataStub = stub 727 } 728 729 func (fake *VersionedDB) GetStateRangeScanIteratorWithMetadataArgsForCall(i int) (string, string, string, map[string]interface{}) { 730 fake.getStateRangeScanIteratorWithMetadataMutex.RLock() 731 defer fake.getStateRangeScanIteratorWithMetadataMutex.RUnlock() 732 argsForCall := fake.getStateRangeScanIteratorWithMetadataArgsForCall[i] 733 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 734 } 735 736 func (fake *VersionedDB) GetStateRangeScanIteratorWithMetadataReturns(result1 statedb.QueryResultsIterator, result2 error) { 737 fake.getStateRangeScanIteratorWithMetadataMutex.Lock() 738 defer fake.getStateRangeScanIteratorWithMetadataMutex.Unlock() 739 fake.GetStateRangeScanIteratorWithMetadataStub = nil 740 fake.getStateRangeScanIteratorWithMetadataReturns = struct { 741 result1 statedb.QueryResultsIterator 742 result2 error 743 }{result1, result2} 744 } 745 746 func (fake *VersionedDB) GetStateRangeScanIteratorWithMetadataReturnsOnCall(i int, result1 statedb.QueryResultsIterator, result2 error) { 747 fake.getStateRangeScanIteratorWithMetadataMutex.Lock() 748 defer fake.getStateRangeScanIteratorWithMetadataMutex.Unlock() 749 fake.GetStateRangeScanIteratorWithMetadataStub = nil 750 if fake.getStateRangeScanIteratorWithMetadataReturnsOnCall == nil { 751 fake.getStateRangeScanIteratorWithMetadataReturnsOnCall = make(map[int]struct { 752 result1 statedb.QueryResultsIterator 753 result2 error 754 }) 755 } 756 fake.getStateRangeScanIteratorWithMetadataReturnsOnCall[i] = struct { 757 result1 statedb.QueryResultsIterator 758 result2 error 759 }{result1, result2} 760 } 761 762 func (fake *VersionedDB) GetVersion(arg1 string, arg2 string) (*version.Height, error) { 763 fake.getVersionMutex.Lock() 764 ret, specificReturn := fake.getVersionReturnsOnCall[len(fake.getVersionArgsForCall)] 765 fake.getVersionArgsForCall = append(fake.getVersionArgsForCall, struct { 766 arg1 string 767 arg2 string 768 }{arg1, arg2}) 769 fake.recordInvocation("GetVersion", []interface{}{arg1, arg2}) 770 fake.getVersionMutex.Unlock() 771 if fake.GetVersionStub != nil { 772 return fake.GetVersionStub(arg1, arg2) 773 } 774 if specificReturn { 775 return ret.result1, ret.result2 776 } 777 fakeReturns := fake.getVersionReturns 778 return fakeReturns.result1, fakeReturns.result2 779 } 780 781 func (fake *VersionedDB) GetVersionCallCount() int { 782 fake.getVersionMutex.RLock() 783 defer fake.getVersionMutex.RUnlock() 784 return len(fake.getVersionArgsForCall) 785 } 786 787 func (fake *VersionedDB) GetVersionCalls(stub func(string, string) (*version.Height, error)) { 788 fake.getVersionMutex.Lock() 789 defer fake.getVersionMutex.Unlock() 790 fake.GetVersionStub = stub 791 } 792 793 func (fake *VersionedDB) GetVersionArgsForCall(i int) (string, string) { 794 fake.getVersionMutex.RLock() 795 defer fake.getVersionMutex.RUnlock() 796 argsForCall := fake.getVersionArgsForCall[i] 797 return argsForCall.arg1, argsForCall.arg2 798 } 799 800 func (fake *VersionedDB) GetVersionReturns(result1 *version.Height, result2 error) { 801 fake.getVersionMutex.Lock() 802 defer fake.getVersionMutex.Unlock() 803 fake.GetVersionStub = nil 804 fake.getVersionReturns = struct { 805 result1 *version.Height 806 result2 error 807 }{result1, result2} 808 } 809 810 func (fake *VersionedDB) GetVersionReturnsOnCall(i int, result1 *version.Height, result2 error) { 811 fake.getVersionMutex.Lock() 812 defer fake.getVersionMutex.Unlock() 813 fake.GetVersionStub = nil 814 if fake.getVersionReturnsOnCall == nil { 815 fake.getVersionReturnsOnCall = make(map[int]struct { 816 result1 *version.Height 817 result2 error 818 }) 819 } 820 fake.getVersionReturnsOnCall[i] = struct { 821 result1 *version.Height 822 result2 error 823 }{result1, result2} 824 } 825 826 func (fake *VersionedDB) Open() error { 827 fake.openMutex.Lock() 828 ret, specificReturn := fake.openReturnsOnCall[len(fake.openArgsForCall)] 829 fake.openArgsForCall = append(fake.openArgsForCall, struct { 830 }{}) 831 fake.recordInvocation("Open", []interface{}{}) 832 fake.openMutex.Unlock() 833 if fake.OpenStub != nil { 834 return fake.OpenStub() 835 } 836 if specificReturn { 837 return ret.result1 838 } 839 fakeReturns := fake.openReturns 840 return fakeReturns.result1 841 } 842 843 func (fake *VersionedDB) OpenCallCount() int { 844 fake.openMutex.RLock() 845 defer fake.openMutex.RUnlock() 846 return len(fake.openArgsForCall) 847 } 848 849 func (fake *VersionedDB) OpenCalls(stub func() error) { 850 fake.openMutex.Lock() 851 defer fake.openMutex.Unlock() 852 fake.OpenStub = stub 853 } 854 855 func (fake *VersionedDB) OpenReturns(result1 error) { 856 fake.openMutex.Lock() 857 defer fake.openMutex.Unlock() 858 fake.OpenStub = nil 859 fake.openReturns = struct { 860 result1 error 861 }{result1} 862 } 863 864 func (fake *VersionedDB) OpenReturnsOnCall(i int, result1 error) { 865 fake.openMutex.Lock() 866 defer fake.openMutex.Unlock() 867 fake.OpenStub = nil 868 if fake.openReturnsOnCall == nil { 869 fake.openReturnsOnCall = make(map[int]struct { 870 result1 error 871 }) 872 } 873 fake.openReturnsOnCall[i] = struct { 874 result1 error 875 }{result1} 876 } 877 878 func (fake *VersionedDB) ValidateKeyValue(arg1 string, arg2 []byte) error { 879 var arg2Copy []byte 880 if arg2 != nil { 881 arg2Copy = make([]byte, len(arg2)) 882 copy(arg2Copy, arg2) 883 } 884 fake.validateKeyValueMutex.Lock() 885 ret, specificReturn := fake.validateKeyValueReturnsOnCall[len(fake.validateKeyValueArgsForCall)] 886 fake.validateKeyValueArgsForCall = append(fake.validateKeyValueArgsForCall, struct { 887 arg1 string 888 arg2 []byte 889 }{arg1, arg2Copy}) 890 fake.recordInvocation("ValidateKeyValue", []interface{}{arg1, arg2Copy}) 891 fake.validateKeyValueMutex.Unlock() 892 if fake.ValidateKeyValueStub != nil { 893 return fake.ValidateKeyValueStub(arg1, arg2) 894 } 895 if specificReturn { 896 return ret.result1 897 } 898 fakeReturns := fake.validateKeyValueReturns 899 return fakeReturns.result1 900 } 901 902 func (fake *VersionedDB) ValidateKeyValueCallCount() int { 903 fake.validateKeyValueMutex.RLock() 904 defer fake.validateKeyValueMutex.RUnlock() 905 return len(fake.validateKeyValueArgsForCall) 906 } 907 908 func (fake *VersionedDB) ValidateKeyValueCalls(stub func(string, []byte) error) { 909 fake.validateKeyValueMutex.Lock() 910 defer fake.validateKeyValueMutex.Unlock() 911 fake.ValidateKeyValueStub = stub 912 } 913 914 func (fake *VersionedDB) ValidateKeyValueArgsForCall(i int) (string, []byte) { 915 fake.validateKeyValueMutex.RLock() 916 defer fake.validateKeyValueMutex.RUnlock() 917 argsForCall := fake.validateKeyValueArgsForCall[i] 918 return argsForCall.arg1, argsForCall.arg2 919 } 920 921 func (fake *VersionedDB) ValidateKeyValueReturns(result1 error) { 922 fake.validateKeyValueMutex.Lock() 923 defer fake.validateKeyValueMutex.Unlock() 924 fake.ValidateKeyValueStub = nil 925 fake.validateKeyValueReturns = struct { 926 result1 error 927 }{result1} 928 } 929 930 func (fake *VersionedDB) ValidateKeyValueReturnsOnCall(i int, result1 error) { 931 fake.validateKeyValueMutex.Lock() 932 defer fake.validateKeyValueMutex.Unlock() 933 fake.ValidateKeyValueStub = nil 934 if fake.validateKeyValueReturnsOnCall == nil { 935 fake.validateKeyValueReturnsOnCall = make(map[int]struct { 936 result1 error 937 }) 938 } 939 fake.validateKeyValueReturnsOnCall[i] = struct { 940 result1 error 941 }{result1} 942 } 943 944 func (fake *VersionedDB) Invocations() map[string][][]interface{} { 945 fake.invocationsMutex.RLock() 946 defer fake.invocationsMutex.RUnlock() 947 fake.applyUpdatesMutex.RLock() 948 defer fake.applyUpdatesMutex.RUnlock() 949 fake.bytesKeySupportedMutex.RLock() 950 defer fake.bytesKeySupportedMutex.RUnlock() 951 fake.closeMutex.RLock() 952 defer fake.closeMutex.RUnlock() 953 fake.executeQueryMutex.RLock() 954 defer fake.executeQueryMutex.RUnlock() 955 fake.executeQueryWithMetadataMutex.RLock() 956 defer fake.executeQueryWithMetadataMutex.RUnlock() 957 fake.getLatestSavePointMutex.RLock() 958 defer fake.getLatestSavePointMutex.RUnlock() 959 fake.getStateMutex.RLock() 960 defer fake.getStateMutex.RUnlock() 961 fake.getStateMultipleKeysMutex.RLock() 962 defer fake.getStateMultipleKeysMutex.RUnlock() 963 fake.getStateRangeScanIteratorMutex.RLock() 964 defer fake.getStateRangeScanIteratorMutex.RUnlock() 965 fake.getStateRangeScanIteratorWithMetadataMutex.RLock() 966 defer fake.getStateRangeScanIteratorWithMetadataMutex.RUnlock() 967 fake.getVersionMutex.RLock() 968 defer fake.getVersionMutex.RUnlock() 969 fake.openMutex.RLock() 970 defer fake.openMutex.RUnlock() 971 fake.validateKeyValueMutex.RLock() 972 defer fake.validateKeyValueMutex.RUnlock() 973 copiedInvocations := map[string][][]interface{}{} 974 for key, value := range fake.invocations { 975 copiedInvocations[key] = value 976 } 977 return copiedInvocations 978 } 979 980 func (fake *VersionedDB) recordInvocation(key string, args []interface{}) { 981 fake.invocationsMutex.Lock() 982 defer fake.invocationsMutex.Unlock() 983 if fake.invocations == nil { 984 fake.invocations = map[string][][]interface{}{} 985 } 986 if fake.invocations[key] == nil { 987 fake.invocations[key] = [][]interface{}{} 988 } 989 fake.invocations[key] = append(fake.invocations[key], args) 990 } 991 992 var _ statedb.VersionedDB = new(VersionedDB)