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