github.com/osdi23p228/fabric@v0.0.0-20221218062954-77808885f5db/core/chaincode/mock/peer_ledger.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package mock 3 4 import ( 5 "sync" 6 7 "github.com/hyperledger/fabric-protos-go/common" 8 "github.com/hyperledger/fabric-protos-go/peer" 9 ledgera "github.com/osdi23p228/fabric/common/ledger" 10 "github.com/osdi23p228/fabric/core/ledger" 11 ) 12 13 type PeerLedger struct { 14 CloseStub func() 15 closeMutex sync.RWMutex 16 closeArgsForCall []struct { 17 } 18 CommitLegacyStub func(*ledger.BlockAndPvtData, *ledger.CommitOptions) error 19 commitLegacyMutex sync.RWMutex 20 commitLegacyArgsForCall []struct { 21 arg1 *ledger.BlockAndPvtData 22 arg2 *ledger.CommitOptions 23 } 24 commitLegacyReturns struct { 25 result1 error 26 } 27 commitLegacyReturnsOnCall map[int]struct { 28 result1 error 29 } 30 CommitPvtDataOfOldBlocksStub func([]*ledger.ReconciledPvtdata, ledger.MissingPvtDataInfo) ([]*ledger.PvtdataHashMismatch, error) 31 commitPvtDataOfOldBlocksMutex sync.RWMutex 32 commitPvtDataOfOldBlocksArgsForCall []struct { 33 arg1 []*ledger.ReconciledPvtdata 34 arg2 ledger.MissingPvtDataInfo 35 } 36 commitPvtDataOfOldBlocksReturns struct { 37 result1 []*ledger.PvtdataHashMismatch 38 result2 error 39 } 40 commitPvtDataOfOldBlocksReturnsOnCall map[int]struct { 41 result1 []*ledger.PvtdataHashMismatch 42 result2 error 43 } 44 DoesPvtDataInfoExistStub func(uint64) (bool, error) 45 doesPvtDataInfoExistMutex sync.RWMutex 46 doesPvtDataInfoExistArgsForCall []struct { 47 arg1 uint64 48 } 49 doesPvtDataInfoExistReturns struct { 50 result1 bool 51 result2 error 52 } 53 doesPvtDataInfoExistReturnsOnCall map[int]struct { 54 result1 bool 55 result2 error 56 } 57 GetBlockByHashStub func([]byte) (*common.Block, error) 58 getBlockByHashMutex sync.RWMutex 59 getBlockByHashArgsForCall []struct { 60 arg1 []byte 61 } 62 getBlockByHashReturns struct { 63 result1 *common.Block 64 result2 error 65 } 66 getBlockByHashReturnsOnCall map[int]struct { 67 result1 *common.Block 68 result2 error 69 } 70 GetBlockByNumberStub func(uint64) (*common.Block, error) 71 getBlockByNumberMutex sync.RWMutex 72 getBlockByNumberArgsForCall []struct { 73 arg1 uint64 74 } 75 getBlockByNumberReturns struct { 76 result1 *common.Block 77 result2 error 78 } 79 getBlockByNumberReturnsOnCall map[int]struct { 80 result1 *common.Block 81 result2 error 82 } 83 GetBlockByTxIDStub func(string) (*common.Block, error) 84 getBlockByTxIDMutex sync.RWMutex 85 getBlockByTxIDArgsForCall []struct { 86 arg1 string 87 } 88 getBlockByTxIDReturns struct { 89 result1 *common.Block 90 result2 error 91 } 92 getBlockByTxIDReturnsOnCall map[int]struct { 93 result1 *common.Block 94 result2 error 95 } 96 GetBlockchainInfoStub func() (*common.BlockchainInfo, error) 97 getBlockchainInfoMutex sync.RWMutex 98 getBlockchainInfoArgsForCall []struct { 99 } 100 getBlockchainInfoReturns struct { 101 result1 *common.BlockchainInfo 102 result2 error 103 } 104 getBlockchainInfoReturnsOnCall map[int]struct { 105 result1 *common.BlockchainInfo 106 result2 error 107 } 108 GetBlocksIteratorStub func(uint64) (ledgera.ResultsIterator, error) 109 getBlocksIteratorMutex sync.RWMutex 110 getBlocksIteratorArgsForCall []struct { 111 arg1 uint64 112 } 113 getBlocksIteratorReturns struct { 114 result1 ledgera.ResultsIterator 115 result2 error 116 } 117 getBlocksIteratorReturnsOnCall map[int]struct { 118 result1 ledgera.ResultsIterator 119 result2 error 120 } 121 GetConfigHistoryRetrieverStub func() (ledger.ConfigHistoryRetriever, error) 122 getConfigHistoryRetrieverMutex sync.RWMutex 123 getConfigHistoryRetrieverArgsForCall []struct { 124 } 125 getConfigHistoryRetrieverReturns struct { 126 result1 ledger.ConfigHistoryRetriever 127 result2 error 128 } 129 getConfigHistoryRetrieverReturnsOnCall map[int]struct { 130 result1 ledger.ConfigHistoryRetriever 131 result2 error 132 } 133 GetMissingPvtDataTrackerStub func() (ledger.MissingPvtDataTracker, error) 134 getMissingPvtDataTrackerMutex sync.RWMutex 135 getMissingPvtDataTrackerArgsForCall []struct { 136 } 137 getMissingPvtDataTrackerReturns struct { 138 result1 ledger.MissingPvtDataTracker 139 result2 error 140 } 141 getMissingPvtDataTrackerReturnsOnCall map[int]struct { 142 result1 ledger.MissingPvtDataTracker 143 result2 error 144 } 145 GetPvtDataAndBlockByNumStub func(uint64, ledger.PvtNsCollFilter) (*ledger.BlockAndPvtData, error) 146 getPvtDataAndBlockByNumMutex sync.RWMutex 147 getPvtDataAndBlockByNumArgsForCall []struct { 148 arg1 uint64 149 arg2 ledger.PvtNsCollFilter 150 } 151 getPvtDataAndBlockByNumReturns struct { 152 result1 *ledger.BlockAndPvtData 153 result2 error 154 } 155 getPvtDataAndBlockByNumReturnsOnCall map[int]struct { 156 result1 *ledger.BlockAndPvtData 157 result2 error 158 } 159 GetPvtDataByNumStub func(uint64, ledger.PvtNsCollFilter) ([]*ledger.TxPvtData, error) 160 getPvtDataByNumMutex sync.RWMutex 161 getPvtDataByNumArgsForCall []struct { 162 arg1 uint64 163 arg2 ledger.PvtNsCollFilter 164 } 165 getPvtDataByNumReturns struct { 166 result1 []*ledger.TxPvtData 167 result2 error 168 } 169 getPvtDataByNumReturnsOnCall map[int]struct { 170 result1 []*ledger.TxPvtData 171 result2 error 172 } 173 GetTransactionByIDStub func(string) (*peer.ProcessedTransaction, error) 174 getTransactionByIDMutex sync.RWMutex 175 getTransactionByIDArgsForCall []struct { 176 arg1 string 177 } 178 getTransactionByIDReturns struct { 179 result1 *peer.ProcessedTransaction 180 result2 error 181 } 182 getTransactionByIDReturnsOnCall map[int]struct { 183 result1 *peer.ProcessedTransaction 184 result2 error 185 } 186 GetTxValidationCodeByTxIDStub func(string) (peer.TxValidationCode, error) 187 getTxValidationCodeByTxIDMutex sync.RWMutex 188 getTxValidationCodeByTxIDArgsForCall []struct { 189 arg1 string 190 } 191 getTxValidationCodeByTxIDReturns struct { 192 result1 peer.TxValidationCode 193 result2 error 194 } 195 getTxValidationCodeByTxIDReturnsOnCall map[int]struct { 196 result1 peer.TxValidationCode 197 result2 error 198 } 199 NewHistoryQueryExecutorStub func() (ledger.HistoryQueryExecutor, error) 200 newHistoryQueryExecutorMutex sync.RWMutex 201 newHistoryQueryExecutorArgsForCall []struct { 202 } 203 newHistoryQueryExecutorReturns struct { 204 result1 ledger.HistoryQueryExecutor 205 result2 error 206 } 207 newHistoryQueryExecutorReturnsOnCall map[int]struct { 208 result1 ledger.HistoryQueryExecutor 209 result2 error 210 } 211 NewQueryExecutorStub func() (ledger.QueryExecutor, error) 212 newQueryExecutorMutex sync.RWMutex 213 newQueryExecutorArgsForCall []struct { 214 } 215 newQueryExecutorReturns struct { 216 result1 ledger.QueryExecutor 217 result2 error 218 } 219 newQueryExecutorReturnsOnCall map[int]struct { 220 result1 ledger.QueryExecutor 221 result2 error 222 } 223 NewTxSimulatorStub func(string) (ledger.TxSimulator, error) 224 newTxSimulatorMutex sync.RWMutex 225 newTxSimulatorArgsForCall []struct { 226 arg1 string 227 } 228 newTxSimulatorReturns struct { 229 result1 ledger.TxSimulator 230 result2 error 231 } 232 newTxSimulatorReturnsOnCall map[int]struct { 233 result1 ledger.TxSimulator 234 result2 error 235 } 236 invocations map[string][][]interface{} 237 invocationsMutex sync.RWMutex 238 } 239 240 func (fake *PeerLedger) Close() { 241 fake.closeMutex.Lock() 242 fake.closeArgsForCall = append(fake.closeArgsForCall, struct { 243 }{}) 244 fake.recordInvocation("Close", []interface{}{}) 245 fake.closeMutex.Unlock() 246 if fake.CloseStub != nil { 247 fake.CloseStub() 248 } 249 } 250 251 func (fake *PeerLedger) CloseCallCount() int { 252 fake.closeMutex.RLock() 253 defer fake.closeMutex.RUnlock() 254 return len(fake.closeArgsForCall) 255 } 256 257 func (fake *PeerLedger) CloseCalls(stub func()) { 258 fake.closeMutex.Lock() 259 defer fake.closeMutex.Unlock() 260 fake.CloseStub = stub 261 } 262 263 func (fake *PeerLedger) CommitLegacy(arg1 *ledger.BlockAndPvtData, arg2 *ledger.CommitOptions) error { 264 fake.commitLegacyMutex.Lock() 265 ret, specificReturn := fake.commitLegacyReturnsOnCall[len(fake.commitLegacyArgsForCall)] 266 fake.commitLegacyArgsForCall = append(fake.commitLegacyArgsForCall, struct { 267 arg1 *ledger.BlockAndPvtData 268 arg2 *ledger.CommitOptions 269 }{arg1, arg2}) 270 fake.recordInvocation("CommitLegacy", []interface{}{arg1, arg2}) 271 fake.commitLegacyMutex.Unlock() 272 if fake.CommitLegacyStub != nil { 273 return fake.CommitLegacyStub(arg1, arg2) 274 } 275 if specificReturn { 276 return ret.result1 277 } 278 fakeReturns := fake.commitLegacyReturns 279 return fakeReturns.result1 280 } 281 282 func (fake *PeerLedger) CommitLegacyCallCount() int { 283 fake.commitLegacyMutex.RLock() 284 defer fake.commitLegacyMutex.RUnlock() 285 return len(fake.commitLegacyArgsForCall) 286 } 287 288 func (fake *PeerLedger) CommitLegacyCalls(stub func(*ledger.BlockAndPvtData, *ledger.CommitOptions) error) { 289 fake.commitLegacyMutex.Lock() 290 defer fake.commitLegacyMutex.Unlock() 291 fake.CommitLegacyStub = stub 292 } 293 294 func (fake *PeerLedger) CommitLegacyArgsForCall(i int) (*ledger.BlockAndPvtData, *ledger.CommitOptions) { 295 fake.commitLegacyMutex.RLock() 296 defer fake.commitLegacyMutex.RUnlock() 297 argsForCall := fake.commitLegacyArgsForCall[i] 298 return argsForCall.arg1, argsForCall.arg2 299 } 300 301 func (fake *PeerLedger) CommitLegacyReturns(result1 error) { 302 fake.commitLegacyMutex.Lock() 303 defer fake.commitLegacyMutex.Unlock() 304 fake.CommitLegacyStub = nil 305 fake.commitLegacyReturns = struct { 306 result1 error 307 }{result1} 308 } 309 310 func (fake *PeerLedger) CommitLegacyReturnsOnCall(i int, result1 error) { 311 fake.commitLegacyMutex.Lock() 312 defer fake.commitLegacyMutex.Unlock() 313 fake.CommitLegacyStub = nil 314 if fake.commitLegacyReturnsOnCall == nil { 315 fake.commitLegacyReturnsOnCall = make(map[int]struct { 316 result1 error 317 }) 318 } 319 fake.commitLegacyReturnsOnCall[i] = struct { 320 result1 error 321 }{result1} 322 } 323 324 func (fake *PeerLedger) CommitPvtDataOfOldBlocks(arg1 []*ledger.ReconciledPvtdata, arg2 ledger.MissingPvtDataInfo) ([]*ledger.PvtdataHashMismatch, error) { 325 var arg1Copy []*ledger.ReconciledPvtdata 326 if arg1 != nil { 327 arg1Copy = make([]*ledger.ReconciledPvtdata, len(arg1)) 328 copy(arg1Copy, arg1) 329 } 330 fake.commitPvtDataOfOldBlocksMutex.Lock() 331 ret, specificReturn := fake.commitPvtDataOfOldBlocksReturnsOnCall[len(fake.commitPvtDataOfOldBlocksArgsForCall)] 332 fake.commitPvtDataOfOldBlocksArgsForCall = append(fake.commitPvtDataOfOldBlocksArgsForCall, struct { 333 arg1 []*ledger.ReconciledPvtdata 334 arg2 ledger.MissingPvtDataInfo 335 }{arg1Copy, arg2}) 336 fake.recordInvocation("CommitPvtDataOfOldBlocks", []interface{}{arg1Copy, arg2}) 337 fake.commitPvtDataOfOldBlocksMutex.Unlock() 338 if fake.CommitPvtDataOfOldBlocksStub != nil { 339 return fake.CommitPvtDataOfOldBlocksStub(arg1, arg2) 340 } 341 if specificReturn { 342 return ret.result1, ret.result2 343 } 344 fakeReturns := fake.commitPvtDataOfOldBlocksReturns 345 return fakeReturns.result1, fakeReturns.result2 346 } 347 348 func (fake *PeerLedger) CommitPvtDataOfOldBlocksCallCount() int { 349 fake.commitPvtDataOfOldBlocksMutex.RLock() 350 defer fake.commitPvtDataOfOldBlocksMutex.RUnlock() 351 return len(fake.commitPvtDataOfOldBlocksArgsForCall) 352 } 353 354 func (fake *PeerLedger) CommitPvtDataOfOldBlocksCalls(stub func([]*ledger.ReconciledPvtdata, ledger.MissingPvtDataInfo) ([]*ledger.PvtdataHashMismatch, error)) { 355 fake.commitPvtDataOfOldBlocksMutex.Lock() 356 defer fake.commitPvtDataOfOldBlocksMutex.Unlock() 357 fake.CommitPvtDataOfOldBlocksStub = stub 358 } 359 360 func (fake *PeerLedger) CommitPvtDataOfOldBlocksArgsForCall(i int) ([]*ledger.ReconciledPvtdata, ledger.MissingPvtDataInfo) { 361 fake.commitPvtDataOfOldBlocksMutex.RLock() 362 defer fake.commitPvtDataOfOldBlocksMutex.RUnlock() 363 argsForCall := fake.commitPvtDataOfOldBlocksArgsForCall[i] 364 return argsForCall.arg1, argsForCall.arg2 365 } 366 367 func (fake *PeerLedger) CommitPvtDataOfOldBlocksReturns(result1 []*ledger.PvtdataHashMismatch, result2 error) { 368 fake.commitPvtDataOfOldBlocksMutex.Lock() 369 defer fake.commitPvtDataOfOldBlocksMutex.Unlock() 370 fake.CommitPvtDataOfOldBlocksStub = nil 371 fake.commitPvtDataOfOldBlocksReturns = struct { 372 result1 []*ledger.PvtdataHashMismatch 373 result2 error 374 }{result1, result2} 375 } 376 377 func (fake *PeerLedger) CommitPvtDataOfOldBlocksReturnsOnCall(i int, result1 []*ledger.PvtdataHashMismatch, result2 error) { 378 fake.commitPvtDataOfOldBlocksMutex.Lock() 379 defer fake.commitPvtDataOfOldBlocksMutex.Unlock() 380 fake.CommitPvtDataOfOldBlocksStub = nil 381 if fake.commitPvtDataOfOldBlocksReturnsOnCall == nil { 382 fake.commitPvtDataOfOldBlocksReturnsOnCall = make(map[int]struct { 383 result1 []*ledger.PvtdataHashMismatch 384 result2 error 385 }) 386 } 387 fake.commitPvtDataOfOldBlocksReturnsOnCall[i] = struct { 388 result1 []*ledger.PvtdataHashMismatch 389 result2 error 390 }{result1, result2} 391 } 392 393 func (fake *PeerLedger) DoesPvtDataInfoExist(arg1 uint64) (bool, error) { 394 fake.doesPvtDataInfoExistMutex.Lock() 395 ret, specificReturn := fake.doesPvtDataInfoExistReturnsOnCall[len(fake.doesPvtDataInfoExistArgsForCall)] 396 fake.doesPvtDataInfoExistArgsForCall = append(fake.doesPvtDataInfoExistArgsForCall, struct { 397 arg1 uint64 398 }{arg1}) 399 fake.recordInvocation("DoesPvtDataInfoExist", []interface{}{arg1}) 400 fake.doesPvtDataInfoExistMutex.Unlock() 401 if fake.DoesPvtDataInfoExistStub != nil { 402 return fake.DoesPvtDataInfoExistStub(arg1) 403 } 404 if specificReturn { 405 return ret.result1, ret.result2 406 } 407 fakeReturns := fake.doesPvtDataInfoExistReturns 408 return fakeReturns.result1, fakeReturns.result2 409 } 410 411 func (fake *PeerLedger) DoesPvtDataInfoExistCallCount() int { 412 fake.doesPvtDataInfoExistMutex.RLock() 413 defer fake.doesPvtDataInfoExistMutex.RUnlock() 414 return len(fake.doesPvtDataInfoExistArgsForCall) 415 } 416 417 func (fake *PeerLedger) DoesPvtDataInfoExistCalls(stub func(uint64) (bool, error)) { 418 fake.doesPvtDataInfoExistMutex.Lock() 419 defer fake.doesPvtDataInfoExistMutex.Unlock() 420 fake.DoesPvtDataInfoExistStub = stub 421 } 422 423 func (fake *PeerLedger) DoesPvtDataInfoExistArgsForCall(i int) uint64 { 424 fake.doesPvtDataInfoExistMutex.RLock() 425 defer fake.doesPvtDataInfoExistMutex.RUnlock() 426 argsForCall := fake.doesPvtDataInfoExistArgsForCall[i] 427 return argsForCall.arg1 428 } 429 430 func (fake *PeerLedger) DoesPvtDataInfoExistReturns(result1 bool, result2 error) { 431 fake.doesPvtDataInfoExistMutex.Lock() 432 defer fake.doesPvtDataInfoExistMutex.Unlock() 433 fake.DoesPvtDataInfoExistStub = nil 434 fake.doesPvtDataInfoExistReturns = struct { 435 result1 bool 436 result2 error 437 }{result1, result2} 438 } 439 440 func (fake *PeerLedger) DoesPvtDataInfoExistReturnsOnCall(i int, result1 bool, result2 error) { 441 fake.doesPvtDataInfoExistMutex.Lock() 442 defer fake.doesPvtDataInfoExistMutex.Unlock() 443 fake.DoesPvtDataInfoExistStub = nil 444 if fake.doesPvtDataInfoExistReturnsOnCall == nil { 445 fake.doesPvtDataInfoExistReturnsOnCall = make(map[int]struct { 446 result1 bool 447 result2 error 448 }) 449 } 450 fake.doesPvtDataInfoExistReturnsOnCall[i] = struct { 451 result1 bool 452 result2 error 453 }{result1, result2} 454 } 455 456 func (fake *PeerLedger) GetBlockByHash(arg1 []byte) (*common.Block, error) { 457 var arg1Copy []byte 458 if arg1 != nil { 459 arg1Copy = make([]byte, len(arg1)) 460 copy(arg1Copy, arg1) 461 } 462 fake.getBlockByHashMutex.Lock() 463 ret, specificReturn := fake.getBlockByHashReturnsOnCall[len(fake.getBlockByHashArgsForCall)] 464 fake.getBlockByHashArgsForCall = append(fake.getBlockByHashArgsForCall, struct { 465 arg1 []byte 466 }{arg1Copy}) 467 fake.recordInvocation("GetBlockByHash", []interface{}{arg1Copy}) 468 fake.getBlockByHashMutex.Unlock() 469 if fake.GetBlockByHashStub != nil { 470 return fake.GetBlockByHashStub(arg1) 471 } 472 if specificReturn { 473 return ret.result1, ret.result2 474 } 475 fakeReturns := fake.getBlockByHashReturns 476 return fakeReturns.result1, fakeReturns.result2 477 } 478 479 func (fake *PeerLedger) GetBlockByHashCallCount() int { 480 fake.getBlockByHashMutex.RLock() 481 defer fake.getBlockByHashMutex.RUnlock() 482 return len(fake.getBlockByHashArgsForCall) 483 } 484 485 func (fake *PeerLedger) GetBlockByHashCalls(stub func([]byte) (*common.Block, error)) { 486 fake.getBlockByHashMutex.Lock() 487 defer fake.getBlockByHashMutex.Unlock() 488 fake.GetBlockByHashStub = stub 489 } 490 491 func (fake *PeerLedger) GetBlockByHashArgsForCall(i int) []byte { 492 fake.getBlockByHashMutex.RLock() 493 defer fake.getBlockByHashMutex.RUnlock() 494 argsForCall := fake.getBlockByHashArgsForCall[i] 495 return argsForCall.arg1 496 } 497 498 func (fake *PeerLedger) GetBlockByHashReturns(result1 *common.Block, result2 error) { 499 fake.getBlockByHashMutex.Lock() 500 defer fake.getBlockByHashMutex.Unlock() 501 fake.GetBlockByHashStub = nil 502 fake.getBlockByHashReturns = struct { 503 result1 *common.Block 504 result2 error 505 }{result1, result2} 506 } 507 508 func (fake *PeerLedger) GetBlockByHashReturnsOnCall(i int, result1 *common.Block, result2 error) { 509 fake.getBlockByHashMutex.Lock() 510 defer fake.getBlockByHashMutex.Unlock() 511 fake.GetBlockByHashStub = nil 512 if fake.getBlockByHashReturnsOnCall == nil { 513 fake.getBlockByHashReturnsOnCall = make(map[int]struct { 514 result1 *common.Block 515 result2 error 516 }) 517 } 518 fake.getBlockByHashReturnsOnCall[i] = struct { 519 result1 *common.Block 520 result2 error 521 }{result1, result2} 522 } 523 524 func (fake *PeerLedger) GetBlockByNumber(arg1 uint64) (*common.Block, error) { 525 fake.getBlockByNumberMutex.Lock() 526 ret, specificReturn := fake.getBlockByNumberReturnsOnCall[len(fake.getBlockByNumberArgsForCall)] 527 fake.getBlockByNumberArgsForCall = append(fake.getBlockByNumberArgsForCall, struct { 528 arg1 uint64 529 }{arg1}) 530 fake.recordInvocation("GetBlockByNumber", []interface{}{arg1}) 531 fake.getBlockByNumberMutex.Unlock() 532 if fake.GetBlockByNumberStub != nil { 533 return fake.GetBlockByNumberStub(arg1) 534 } 535 if specificReturn { 536 return ret.result1, ret.result2 537 } 538 fakeReturns := fake.getBlockByNumberReturns 539 return fakeReturns.result1, fakeReturns.result2 540 } 541 542 func (fake *PeerLedger) GetBlockByNumberCallCount() int { 543 fake.getBlockByNumberMutex.RLock() 544 defer fake.getBlockByNumberMutex.RUnlock() 545 return len(fake.getBlockByNumberArgsForCall) 546 } 547 548 func (fake *PeerLedger) GetBlockByNumberCalls(stub func(uint64) (*common.Block, error)) { 549 fake.getBlockByNumberMutex.Lock() 550 defer fake.getBlockByNumberMutex.Unlock() 551 fake.GetBlockByNumberStub = stub 552 } 553 554 func (fake *PeerLedger) GetBlockByNumberArgsForCall(i int) uint64 { 555 fake.getBlockByNumberMutex.RLock() 556 defer fake.getBlockByNumberMutex.RUnlock() 557 argsForCall := fake.getBlockByNumberArgsForCall[i] 558 return argsForCall.arg1 559 } 560 561 func (fake *PeerLedger) GetBlockByNumberReturns(result1 *common.Block, result2 error) { 562 fake.getBlockByNumberMutex.Lock() 563 defer fake.getBlockByNumberMutex.Unlock() 564 fake.GetBlockByNumberStub = nil 565 fake.getBlockByNumberReturns = struct { 566 result1 *common.Block 567 result2 error 568 }{result1, result2} 569 } 570 571 func (fake *PeerLedger) GetBlockByNumberReturnsOnCall(i int, result1 *common.Block, result2 error) { 572 fake.getBlockByNumberMutex.Lock() 573 defer fake.getBlockByNumberMutex.Unlock() 574 fake.GetBlockByNumberStub = nil 575 if fake.getBlockByNumberReturnsOnCall == nil { 576 fake.getBlockByNumberReturnsOnCall = make(map[int]struct { 577 result1 *common.Block 578 result2 error 579 }) 580 } 581 fake.getBlockByNumberReturnsOnCall[i] = struct { 582 result1 *common.Block 583 result2 error 584 }{result1, result2} 585 } 586 587 func (fake *PeerLedger) GetBlockByTxID(arg1 string) (*common.Block, error) { 588 fake.getBlockByTxIDMutex.Lock() 589 ret, specificReturn := fake.getBlockByTxIDReturnsOnCall[len(fake.getBlockByTxIDArgsForCall)] 590 fake.getBlockByTxIDArgsForCall = append(fake.getBlockByTxIDArgsForCall, struct { 591 arg1 string 592 }{arg1}) 593 fake.recordInvocation("GetBlockByTxID", []interface{}{arg1}) 594 fake.getBlockByTxIDMutex.Unlock() 595 if fake.GetBlockByTxIDStub != nil { 596 return fake.GetBlockByTxIDStub(arg1) 597 } 598 if specificReturn { 599 return ret.result1, ret.result2 600 } 601 fakeReturns := fake.getBlockByTxIDReturns 602 return fakeReturns.result1, fakeReturns.result2 603 } 604 605 func (fake *PeerLedger) GetBlockByTxIDCallCount() int { 606 fake.getBlockByTxIDMutex.RLock() 607 defer fake.getBlockByTxIDMutex.RUnlock() 608 return len(fake.getBlockByTxIDArgsForCall) 609 } 610 611 func (fake *PeerLedger) GetBlockByTxIDCalls(stub func(string) (*common.Block, error)) { 612 fake.getBlockByTxIDMutex.Lock() 613 defer fake.getBlockByTxIDMutex.Unlock() 614 fake.GetBlockByTxIDStub = stub 615 } 616 617 func (fake *PeerLedger) GetBlockByTxIDArgsForCall(i int) string { 618 fake.getBlockByTxIDMutex.RLock() 619 defer fake.getBlockByTxIDMutex.RUnlock() 620 argsForCall := fake.getBlockByTxIDArgsForCall[i] 621 return argsForCall.arg1 622 } 623 624 func (fake *PeerLedger) GetBlockByTxIDReturns(result1 *common.Block, result2 error) { 625 fake.getBlockByTxIDMutex.Lock() 626 defer fake.getBlockByTxIDMutex.Unlock() 627 fake.GetBlockByTxIDStub = nil 628 fake.getBlockByTxIDReturns = struct { 629 result1 *common.Block 630 result2 error 631 }{result1, result2} 632 } 633 634 func (fake *PeerLedger) GetBlockByTxIDReturnsOnCall(i int, result1 *common.Block, result2 error) { 635 fake.getBlockByTxIDMutex.Lock() 636 defer fake.getBlockByTxIDMutex.Unlock() 637 fake.GetBlockByTxIDStub = nil 638 if fake.getBlockByTxIDReturnsOnCall == nil { 639 fake.getBlockByTxIDReturnsOnCall = make(map[int]struct { 640 result1 *common.Block 641 result2 error 642 }) 643 } 644 fake.getBlockByTxIDReturnsOnCall[i] = struct { 645 result1 *common.Block 646 result2 error 647 }{result1, result2} 648 } 649 650 func (fake *PeerLedger) GetBlockchainInfo() (*common.BlockchainInfo, error) { 651 fake.getBlockchainInfoMutex.Lock() 652 ret, specificReturn := fake.getBlockchainInfoReturnsOnCall[len(fake.getBlockchainInfoArgsForCall)] 653 fake.getBlockchainInfoArgsForCall = append(fake.getBlockchainInfoArgsForCall, struct { 654 }{}) 655 fake.recordInvocation("GetBlockchainInfo", []interface{}{}) 656 fake.getBlockchainInfoMutex.Unlock() 657 if fake.GetBlockchainInfoStub != nil { 658 return fake.GetBlockchainInfoStub() 659 } 660 if specificReturn { 661 return ret.result1, ret.result2 662 } 663 fakeReturns := fake.getBlockchainInfoReturns 664 return fakeReturns.result1, fakeReturns.result2 665 } 666 667 func (fake *PeerLedger) GetBlockchainInfoCallCount() int { 668 fake.getBlockchainInfoMutex.RLock() 669 defer fake.getBlockchainInfoMutex.RUnlock() 670 return len(fake.getBlockchainInfoArgsForCall) 671 } 672 673 func (fake *PeerLedger) GetBlockchainInfoCalls(stub func() (*common.BlockchainInfo, error)) { 674 fake.getBlockchainInfoMutex.Lock() 675 defer fake.getBlockchainInfoMutex.Unlock() 676 fake.GetBlockchainInfoStub = stub 677 } 678 679 func (fake *PeerLedger) GetBlockchainInfoReturns(result1 *common.BlockchainInfo, result2 error) { 680 fake.getBlockchainInfoMutex.Lock() 681 defer fake.getBlockchainInfoMutex.Unlock() 682 fake.GetBlockchainInfoStub = nil 683 fake.getBlockchainInfoReturns = struct { 684 result1 *common.BlockchainInfo 685 result2 error 686 }{result1, result2} 687 } 688 689 func (fake *PeerLedger) GetBlockchainInfoReturnsOnCall(i int, result1 *common.BlockchainInfo, result2 error) { 690 fake.getBlockchainInfoMutex.Lock() 691 defer fake.getBlockchainInfoMutex.Unlock() 692 fake.GetBlockchainInfoStub = nil 693 if fake.getBlockchainInfoReturnsOnCall == nil { 694 fake.getBlockchainInfoReturnsOnCall = make(map[int]struct { 695 result1 *common.BlockchainInfo 696 result2 error 697 }) 698 } 699 fake.getBlockchainInfoReturnsOnCall[i] = struct { 700 result1 *common.BlockchainInfo 701 result2 error 702 }{result1, result2} 703 } 704 705 func (fake *PeerLedger) GetBlocksIterator(arg1 uint64) (ledgera.ResultsIterator, error) { 706 fake.getBlocksIteratorMutex.Lock() 707 ret, specificReturn := fake.getBlocksIteratorReturnsOnCall[len(fake.getBlocksIteratorArgsForCall)] 708 fake.getBlocksIteratorArgsForCall = append(fake.getBlocksIteratorArgsForCall, struct { 709 arg1 uint64 710 }{arg1}) 711 fake.recordInvocation("GetBlocksIterator", []interface{}{arg1}) 712 fake.getBlocksIteratorMutex.Unlock() 713 if fake.GetBlocksIteratorStub != nil { 714 return fake.GetBlocksIteratorStub(arg1) 715 } 716 if specificReturn { 717 return ret.result1, ret.result2 718 } 719 fakeReturns := fake.getBlocksIteratorReturns 720 return fakeReturns.result1, fakeReturns.result2 721 } 722 723 func (fake *PeerLedger) GetBlocksIteratorCallCount() int { 724 fake.getBlocksIteratorMutex.RLock() 725 defer fake.getBlocksIteratorMutex.RUnlock() 726 return len(fake.getBlocksIteratorArgsForCall) 727 } 728 729 func (fake *PeerLedger) GetBlocksIteratorCalls(stub func(uint64) (ledgera.ResultsIterator, error)) { 730 fake.getBlocksIteratorMutex.Lock() 731 defer fake.getBlocksIteratorMutex.Unlock() 732 fake.GetBlocksIteratorStub = stub 733 } 734 735 func (fake *PeerLedger) GetBlocksIteratorArgsForCall(i int) uint64 { 736 fake.getBlocksIteratorMutex.RLock() 737 defer fake.getBlocksIteratorMutex.RUnlock() 738 argsForCall := fake.getBlocksIteratorArgsForCall[i] 739 return argsForCall.arg1 740 } 741 742 func (fake *PeerLedger) GetBlocksIteratorReturns(result1 ledgera.ResultsIterator, result2 error) { 743 fake.getBlocksIteratorMutex.Lock() 744 defer fake.getBlocksIteratorMutex.Unlock() 745 fake.GetBlocksIteratorStub = nil 746 fake.getBlocksIteratorReturns = struct { 747 result1 ledgera.ResultsIterator 748 result2 error 749 }{result1, result2} 750 } 751 752 func (fake *PeerLedger) GetBlocksIteratorReturnsOnCall(i int, result1 ledgera.ResultsIterator, result2 error) { 753 fake.getBlocksIteratorMutex.Lock() 754 defer fake.getBlocksIteratorMutex.Unlock() 755 fake.GetBlocksIteratorStub = nil 756 if fake.getBlocksIteratorReturnsOnCall == nil { 757 fake.getBlocksIteratorReturnsOnCall = make(map[int]struct { 758 result1 ledgera.ResultsIterator 759 result2 error 760 }) 761 } 762 fake.getBlocksIteratorReturnsOnCall[i] = struct { 763 result1 ledgera.ResultsIterator 764 result2 error 765 }{result1, result2} 766 } 767 768 func (fake *PeerLedger) GetConfigHistoryRetriever() (ledger.ConfigHistoryRetriever, error) { 769 fake.getConfigHistoryRetrieverMutex.Lock() 770 ret, specificReturn := fake.getConfigHistoryRetrieverReturnsOnCall[len(fake.getConfigHistoryRetrieverArgsForCall)] 771 fake.getConfigHistoryRetrieverArgsForCall = append(fake.getConfigHistoryRetrieverArgsForCall, struct { 772 }{}) 773 fake.recordInvocation("GetConfigHistoryRetriever", []interface{}{}) 774 fake.getConfigHistoryRetrieverMutex.Unlock() 775 if fake.GetConfigHistoryRetrieverStub != nil { 776 return fake.GetConfigHistoryRetrieverStub() 777 } 778 if specificReturn { 779 return ret.result1, ret.result2 780 } 781 fakeReturns := fake.getConfigHistoryRetrieverReturns 782 return fakeReturns.result1, fakeReturns.result2 783 } 784 785 func (fake *PeerLedger) GetConfigHistoryRetrieverCallCount() int { 786 fake.getConfigHistoryRetrieverMutex.RLock() 787 defer fake.getConfigHistoryRetrieverMutex.RUnlock() 788 return len(fake.getConfigHistoryRetrieverArgsForCall) 789 } 790 791 func (fake *PeerLedger) GetConfigHistoryRetrieverCalls(stub func() (ledger.ConfigHistoryRetriever, error)) { 792 fake.getConfigHistoryRetrieverMutex.Lock() 793 defer fake.getConfigHistoryRetrieverMutex.Unlock() 794 fake.GetConfigHistoryRetrieverStub = stub 795 } 796 797 func (fake *PeerLedger) GetConfigHistoryRetrieverReturns(result1 ledger.ConfigHistoryRetriever, result2 error) { 798 fake.getConfigHistoryRetrieverMutex.Lock() 799 defer fake.getConfigHistoryRetrieverMutex.Unlock() 800 fake.GetConfigHistoryRetrieverStub = nil 801 fake.getConfigHistoryRetrieverReturns = struct { 802 result1 ledger.ConfigHistoryRetriever 803 result2 error 804 }{result1, result2} 805 } 806 807 func (fake *PeerLedger) GetConfigHistoryRetrieverReturnsOnCall(i int, result1 ledger.ConfigHistoryRetriever, result2 error) { 808 fake.getConfigHistoryRetrieverMutex.Lock() 809 defer fake.getConfigHistoryRetrieverMutex.Unlock() 810 fake.GetConfigHistoryRetrieverStub = nil 811 if fake.getConfigHistoryRetrieverReturnsOnCall == nil { 812 fake.getConfigHistoryRetrieverReturnsOnCall = make(map[int]struct { 813 result1 ledger.ConfigHistoryRetriever 814 result2 error 815 }) 816 } 817 fake.getConfigHistoryRetrieverReturnsOnCall[i] = struct { 818 result1 ledger.ConfigHistoryRetriever 819 result2 error 820 }{result1, result2} 821 } 822 823 func (fake *PeerLedger) GetMissingPvtDataTracker() (ledger.MissingPvtDataTracker, error) { 824 fake.getMissingPvtDataTrackerMutex.Lock() 825 ret, specificReturn := fake.getMissingPvtDataTrackerReturnsOnCall[len(fake.getMissingPvtDataTrackerArgsForCall)] 826 fake.getMissingPvtDataTrackerArgsForCall = append(fake.getMissingPvtDataTrackerArgsForCall, struct { 827 }{}) 828 fake.recordInvocation("GetMissingPvtDataTracker", []interface{}{}) 829 fake.getMissingPvtDataTrackerMutex.Unlock() 830 if fake.GetMissingPvtDataTrackerStub != nil { 831 return fake.GetMissingPvtDataTrackerStub() 832 } 833 if specificReturn { 834 return ret.result1, ret.result2 835 } 836 fakeReturns := fake.getMissingPvtDataTrackerReturns 837 return fakeReturns.result1, fakeReturns.result2 838 } 839 840 func (fake *PeerLedger) GetMissingPvtDataTrackerCallCount() int { 841 fake.getMissingPvtDataTrackerMutex.RLock() 842 defer fake.getMissingPvtDataTrackerMutex.RUnlock() 843 return len(fake.getMissingPvtDataTrackerArgsForCall) 844 } 845 846 func (fake *PeerLedger) GetMissingPvtDataTrackerCalls(stub func() (ledger.MissingPvtDataTracker, error)) { 847 fake.getMissingPvtDataTrackerMutex.Lock() 848 defer fake.getMissingPvtDataTrackerMutex.Unlock() 849 fake.GetMissingPvtDataTrackerStub = stub 850 } 851 852 func (fake *PeerLedger) GetMissingPvtDataTrackerReturns(result1 ledger.MissingPvtDataTracker, result2 error) { 853 fake.getMissingPvtDataTrackerMutex.Lock() 854 defer fake.getMissingPvtDataTrackerMutex.Unlock() 855 fake.GetMissingPvtDataTrackerStub = nil 856 fake.getMissingPvtDataTrackerReturns = struct { 857 result1 ledger.MissingPvtDataTracker 858 result2 error 859 }{result1, result2} 860 } 861 862 func (fake *PeerLedger) GetMissingPvtDataTrackerReturnsOnCall(i int, result1 ledger.MissingPvtDataTracker, result2 error) { 863 fake.getMissingPvtDataTrackerMutex.Lock() 864 defer fake.getMissingPvtDataTrackerMutex.Unlock() 865 fake.GetMissingPvtDataTrackerStub = nil 866 if fake.getMissingPvtDataTrackerReturnsOnCall == nil { 867 fake.getMissingPvtDataTrackerReturnsOnCall = make(map[int]struct { 868 result1 ledger.MissingPvtDataTracker 869 result2 error 870 }) 871 } 872 fake.getMissingPvtDataTrackerReturnsOnCall[i] = struct { 873 result1 ledger.MissingPvtDataTracker 874 result2 error 875 }{result1, result2} 876 } 877 878 func (fake *PeerLedger) GetPvtDataAndBlockByNum(arg1 uint64, arg2 ledger.PvtNsCollFilter) (*ledger.BlockAndPvtData, error) { 879 fake.getPvtDataAndBlockByNumMutex.Lock() 880 ret, specificReturn := fake.getPvtDataAndBlockByNumReturnsOnCall[len(fake.getPvtDataAndBlockByNumArgsForCall)] 881 fake.getPvtDataAndBlockByNumArgsForCall = append(fake.getPvtDataAndBlockByNumArgsForCall, struct { 882 arg1 uint64 883 arg2 ledger.PvtNsCollFilter 884 }{arg1, arg2}) 885 fake.recordInvocation("GetPvtDataAndBlockByNum", []interface{}{arg1, arg2}) 886 fake.getPvtDataAndBlockByNumMutex.Unlock() 887 if fake.GetPvtDataAndBlockByNumStub != nil { 888 return fake.GetPvtDataAndBlockByNumStub(arg1, arg2) 889 } 890 if specificReturn { 891 return ret.result1, ret.result2 892 } 893 fakeReturns := fake.getPvtDataAndBlockByNumReturns 894 return fakeReturns.result1, fakeReturns.result2 895 } 896 897 func (fake *PeerLedger) GetPvtDataAndBlockByNumCallCount() int { 898 fake.getPvtDataAndBlockByNumMutex.RLock() 899 defer fake.getPvtDataAndBlockByNumMutex.RUnlock() 900 return len(fake.getPvtDataAndBlockByNumArgsForCall) 901 } 902 903 func (fake *PeerLedger) GetPvtDataAndBlockByNumCalls(stub func(uint64, ledger.PvtNsCollFilter) (*ledger.BlockAndPvtData, error)) { 904 fake.getPvtDataAndBlockByNumMutex.Lock() 905 defer fake.getPvtDataAndBlockByNumMutex.Unlock() 906 fake.GetPvtDataAndBlockByNumStub = stub 907 } 908 909 func (fake *PeerLedger) GetPvtDataAndBlockByNumArgsForCall(i int) (uint64, ledger.PvtNsCollFilter) { 910 fake.getPvtDataAndBlockByNumMutex.RLock() 911 defer fake.getPvtDataAndBlockByNumMutex.RUnlock() 912 argsForCall := fake.getPvtDataAndBlockByNumArgsForCall[i] 913 return argsForCall.arg1, argsForCall.arg2 914 } 915 916 func (fake *PeerLedger) GetPvtDataAndBlockByNumReturns(result1 *ledger.BlockAndPvtData, result2 error) { 917 fake.getPvtDataAndBlockByNumMutex.Lock() 918 defer fake.getPvtDataAndBlockByNumMutex.Unlock() 919 fake.GetPvtDataAndBlockByNumStub = nil 920 fake.getPvtDataAndBlockByNumReturns = struct { 921 result1 *ledger.BlockAndPvtData 922 result2 error 923 }{result1, result2} 924 } 925 926 func (fake *PeerLedger) GetPvtDataAndBlockByNumReturnsOnCall(i int, result1 *ledger.BlockAndPvtData, result2 error) { 927 fake.getPvtDataAndBlockByNumMutex.Lock() 928 defer fake.getPvtDataAndBlockByNumMutex.Unlock() 929 fake.GetPvtDataAndBlockByNumStub = nil 930 if fake.getPvtDataAndBlockByNumReturnsOnCall == nil { 931 fake.getPvtDataAndBlockByNumReturnsOnCall = make(map[int]struct { 932 result1 *ledger.BlockAndPvtData 933 result2 error 934 }) 935 } 936 fake.getPvtDataAndBlockByNumReturnsOnCall[i] = struct { 937 result1 *ledger.BlockAndPvtData 938 result2 error 939 }{result1, result2} 940 } 941 942 func (fake *PeerLedger) GetPvtDataByNum(arg1 uint64, arg2 ledger.PvtNsCollFilter) ([]*ledger.TxPvtData, error) { 943 fake.getPvtDataByNumMutex.Lock() 944 ret, specificReturn := fake.getPvtDataByNumReturnsOnCall[len(fake.getPvtDataByNumArgsForCall)] 945 fake.getPvtDataByNumArgsForCall = append(fake.getPvtDataByNumArgsForCall, struct { 946 arg1 uint64 947 arg2 ledger.PvtNsCollFilter 948 }{arg1, arg2}) 949 fake.recordInvocation("GetPvtDataByNum", []interface{}{arg1, arg2}) 950 fake.getPvtDataByNumMutex.Unlock() 951 if fake.GetPvtDataByNumStub != nil { 952 return fake.GetPvtDataByNumStub(arg1, arg2) 953 } 954 if specificReturn { 955 return ret.result1, ret.result2 956 } 957 fakeReturns := fake.getPvtDataByNumReturns 958 return fakeReturns.result1, fakeReturns.result2 959 } 960 961 func (fake *PeerLedger) GetPvtDataByNumCallCount() int { 962 fake.getPvtDataByNumMutex.RLock() 963 defer fake.getPvtDataByNumMutex.RUnlock() 964 return len(fake.getPvtDataByNumArgsForCall) 965 } 966 967 func (fake *PeerLedger) GetPvtDataByNumCalls(stub func(uint64, ledger.PvtNsCollFilter) ([]*ledger.TxPvtData, error)) { 968 fake.getPvtDataByNumMutex.Lock() 969 defer fake.getPvtDataByNumMutex.Unlock() 970 fake.GetPvtDataByNumStub = stub 971 } 972 973 func (fake *PeerLedger) GetPvtDataByNumArgsForCall(i int) (uint64, ledger.PvtNsCollFilter) { 974 fake.getPvtDataByNumMutex.RLock() 975 defer fake.getPvtDataByNumMutex.RUnlock() 976 argsForCall := fake.getPvtDataByNumArgsForCall[i] 977 return argsForCall.arg1, argsForCall.arg2 978 } 979 980 func (fake *PeerLedger) GetPvtDataByNumReturns(result1 []*ledger.TxPvtData, result2 error) { 981 fake.getPvtDataByNumMutex.Lock() 982 defer fake.getPvtDataByNumMutex.Unlock() 983 fake.GetPvtDataByNumStub = nil 984 fake.getPvtDataByNumReturns = struct { 985 result1 []*ledger.TxPvtData 986 result2 error 987 }{result1, result2} 988 } 989 990 func (fake *PeerLedger) GetPvtDataByNumReturnsOnCall(i int, result1 []*ledger.TxPvtData, result2 error) { 991 fake.getPvtDataByNumMutex.Lock() 992 defer fake.getPvtDataByNumMutex.Unlock() 993 fake.GetPvtDataByNumStub = nil 994 if fake.getPvtDataByNumReturnsOnCall == nil { 995 fake.getPvtDataByNumReturnsOnCall = make(map[int]struct { 996 result1 []*ledger.TxPvtData 997 result2 error 998 }) 999 } 1000 fake.getPvtDataByNumReturnsOnCall[i] = struct { 1001 result1 []*ledger.TxPvtData 1002 result2 error 1003 }{result1, result2} 1004 } 1005 1006 func (fake *PeerLedger) GetTransactionByID(arg1 string) (*peer.ProcessedTransaction, error) { 1007 fake.getTransactionByIDMutex.Lock() 1008 ret, specificReturn := fake.getTransactionByIDReturnsOnCall[len(fake.getTransactionByIDArgsForCall)] 1009 fake.getTransactionByIDArgsForCall = append(fake.getTransactionByIDArgsForCall, struct { 1010 arg1 string 1011 }{arg1}) 1012 fake.recordInvocation("GetTransactionByID", []interface{}{arg1}) 1013 fake.getTransactionByIDMutex.Unlock() 1014 if fake.GetTransactionByIDStub != nil { 1015 return fake.GetTransactionByIDStub(arg1) 1016 } 1017 if specificReturn { 1018 return ret.result1, ret.result2 1019 } 1020 fakeReturns := fake.getTransactionByIDReturns 1021 return fakeReturns.result1, fakeReturns.result2 1022 } 1023 1024 func (fake *PeerLedger) GetTransactionByIDCallCount() int { 1025 fake.getTransactionByIDMutex.RLock() 1026 defer fake.getTransactionByIDMutex.RUnlock() 1027 return len(fake.getTransactionByIDArgsForCall) 1028 } 1029 1030 func (fake *PeerLedger) GetTransactionByIDCalls(stub func(string) (*peer.ProcessedTransaction, error)) { 1031 fake.getTransactionByIDMutex.Lock() 1032 defer fake.getTransactionByIDMutex.Unlock() 1033 fake.GetTransactionByIDStub = stub 1034 } 1035 1036 func (fake *PeerLedger) GetTransactionByIDArgsForCall(i int) string { 1037 fake.getTransactionByIDMutex.RLock() 1038 defer fake.getTransactionByIDMutex.RUnlock() 1039 argsForCall := fake.getTransactionByIDArgsForCall[i] 1040 return argsForCall.arg1 1041 } 1042 1043 func (fake *PeerLedger) GetTransactionByIDReturns(result1 *peer.ProcessedTransaction, result2 error) { 1044 fake.getTransactionByIDMutex.Lock() 1045 defer fake.getTransactionByIDMutex.Unlock() 1046 fake.GetTransactionByIDStub = nil 1047 fake.getTransactionByIDReturns = struct { 1048 result1 *peer.ProcessedTransaction 1049 result2 error 1050 }{result1, result2} 1051 } 1052 1053 func (fake *PeerLedger) GetTransactionByIDReturnsOnCall(i int, result1 *peer.ProcessedTransaction, result2 error) { 1054 fake.getTransactionByIDMutex.Lock() 1055 defer fake.getTransactionByIDMutex.Unlock() 1056 fake.GetTransactionByIDStub = nil 1057 if fake.getTransactionByIDReturnsOnCall == nil { 1058 fake.getTransactionByIDReturnsOnCall = make(map[int]struct { 1059 result1 *peer.ProcessedTransaction 1060 result2 error 1061 }) 1062 } 1063 fake.getTransactionByIDReturnsOnCall[i] = struct { 1064 result1 *peer.ProcessedTransaction 1065 result2 error 1066 }{result1, result2} 1067 } 1068 1069 func (fake *PeerLedger) GetTxValidationCodeByTxID(arg1 string) (peer.TxValidationCode, error) { 1070 fake.getTxValidationCodeByTxIDMutex.Lock() 1071 ret, specificReturn := fake.getTxValidationCodeByTxIDReturnsOnCall[len(fake.getTxValidationCodeByTxIDArgsForCall)] 1072 fake.getTxValidationCodeByTxIDArgsForCall = append(fake.getTxValidationCodeByTxIDArgsForCall, struct { 1073 arg1 string 1074 }{arg1}) 1075 fake.recordInvocation("GetTxValidationCodeByTxID", []interface{}{arg1}) 1076 fake.getTxValidationCodeByTxIDMutex.Unlock() 1077 if fake.GetTxValidationCodeByTxIDStub != nil { 1078 return fake.GetTxValidationCodeByTxIDStub(arg1) 1079 } 1080 if specificReturn { 1081 return ret.result1, ret.result2 1082 } 1083 fakeReturns := fake.getTxValidationCodeByTxIDReturns 1084 return fakeReturns.result1, fakeReturns.result2 1085 } 1086 1087 func (fake *PeerLedger) GetTxValidationCodeByTxIDCallCount() int { 1088 fake.getTxValidationCodeByTxIDMutex.RLock() 1089 defer fake.getTxValidationCodeByTxIDMutex.RUnlock() 1090 return len(fake.getTxValidationCodeByTxIDArgsForCall) 1091 } 1092 1093 func (fake *PeerLedger) GetTxValidationCodeByTxIDCalls(stub func(string) (peer.TxValidationCode, error)) { 1094 fake.getTxValidationCodeByTxIDMutex.Lock() 1095 defer fake.getTxValidationCodeByTxIDMutex.Unlock() 1096 fake.GetTxValidationCodeByTxIDStub = stub 1097 } 1098 1099 func (fake *PeerLedger) GetTxValidationCodeByTxIDArgsForCall(i int) string { 1100 fake.getTxValidationCodeByTxIDMutex.RLock() 1101 defer fake.getTxValidationCodeByTxIDMutex.RUnlock() 1102 argsForCall := fake.getTxValidationCodeByTxIDArgsForCall[i] 1103 return argsForCall.arg1 1104 } 1105 1106 func (fake *PeerLedger) GetTxValidationCodeByTxIDReturns(result1 peer.TxValidationCode, result2 error) { 1107 fake.getTxValidationCodeByTxIDMutex.Lock() 1108 defer fake.getTxValidationCodeByTxIDMutex.Unlock() 1109 fake.GetTxValidationCodeByTxIDStub = nil 1110 fake.getTxValidationCodeByTxIDReturns = struct { 1111 result1 peer.TxValidationCode 1112 result2 error 1113 }{result1, result2} 1114 } 1115 1116 func (fake *PeerLedger) GetTxValidationCodeByTxIDReturnsOnCall(i int, result1 peer.TxValidationCode, result2 error) { 1117 fake.getTxValidationCodeByTxIDMutex.Lock() 1118 defer fake.getTxValidationCodeByTxIDMutex.Unlock() 1119 fake.GetTxValidationCodeByTxIDStub = nil 1120 if fake.getTxValidationCodeByTxIDReturnsOnCall == nil { 1121 fake.getTxValidationCodeByTxIDReturnsOnCall = make(map[int]struct { 1122 result1 peer.TxValidationCode 1123 result2 error 1124 }) 1125 } 1126 fake.getTxValidationCodeByTxIDReturnsOnCall[i] = struct { 1127 result1 peer.TxValidationCode 1128 result2 error 1129 }{result1, result2} 1130 } 1131 1132 func (fake *PeerLedger) NewHistoryQueryExecutor() (ledger.HistoryQueryExecutor, error) { 1133 fake.newHistoryQueryExecutorMutex.Lock() 1134 ret, specificReturn := fake.newHistoryQueryExecutorReturnsOnCall[len(fake.newHistoryQueryExecutorArgsForCall)] 1135 fake.newHistoryQueryExecutorArgsForCall = append(fake.newHistoryQueryExecutorArgsForCall, struct { 1136 }{}) 1137 fake.recordInvocation("NewHistoryQueryExecutor", []interface{}{}) 1138 fake.newHistoryQueryExecutorMutex.Unlock() 1139 if fake.NewHistoryQueryExecutorStub != nil { 1140 return fake.NewHistoryQueryExecutorStub() 1141 } 1142 if specificReturn { 1143 return ret.result1, ret.result2 1144 } 1145 fakeReturns := fake.newHistoryQueryExecutorReturns 1146 return fakeReturns.result1, fakeReturns.result2 1147 } 1148 1149 func (fake *PeerLedger) NewHistoryQueryExecutorCallCount() int { 1150 fake.newHistoryQueryExecutorMutex.RLock() 1151 defer fake.newHistoryQueryExecutorMutex.RUnlock() 1152 return len(fake.newHistoryQueryExecutorArgsForCall) 1153 } 1154 1155 func (fake *PeerLedger) NewHistoryQueryExecutorCalls(stub func() (ledger.HistoryQueryExecutor, error)) { 1156 fake.newHistoryQueryExecutorMutex.Lock() 1157 defer fake.newHistoryQueryExecutorMutex.Unlock() 1158 fake.NewHistoryQueryExecutorStub = stub 1159 } 1160 1161 func (fake *PeerLedger) NewHistoryQueryExecutorReturns(result1 ledger.HistoryQueryExecutor, result2 error) { 1162 fake.newHistoryQueryExecutorMutex.Lock() 1163 defer fake.newHistoryQueryExecutorMutex.Unlock() 1164 fake.NewHistoryQueryExecutorStub = nil 1165 fake.newHistoryQueryExecutorReturns = struct { 1166 result1 ledger.HistoryQueryExecutor 1167 result2 error 1168 }{result1, result2} 1169 } 1170 1171 func (fake *PeerLedger) NewHistoryQueryExecutorReturnsOnCall(i int, result1 ledger.HistoryQueryExecutor, result2 error) { 1172 fake.newHistoryQueryExecutorMutex.Lock() 1173 defer fake.newHistoryQueryExecutorMutex.Unlock() 1174 fake.NewHistoryQueryExecutorStub = nil 1175 if fake.newHistoryQueryExecutorReturnsOnCall == nil { 1176 fake.newHistoryQueryExecutorReturnsOnCall = make(map[int]struct { 1177 result1 ledger.HistoryQueryExecutor 1178 result2 error 1179 }) 1180 } 1181 fake.newHistoryQueryExecutorReturnsOnCall[i] = struct { 1182 result1 ledger.HistoryQueryExecutor 1183 result2 error 1184 }{result1, result2} 1185 } 1186 1187 func (fake *PeerLedger) NewQueryExecutor() (ledger.QueryExecutor, error) { 1188 fake.newQueryExecutorMutex.Lock() 1189 ret, specificReturn := fake.newQueryExecutorReturnsOnCall[len(fake.newQueryExecutorArgsForCall)] 1190 fake.newQueryExecutorArgsForCall = append(fake.newQueryExecutorArgsForCall, struct { 1191 }{}) 1192 fake.recordInvocation("NewQueryExecutor", []interface{}{}) 1193 fake.newQueryExecutorMutex.Unlock() 1194 if fake.NewQueryExecutorStub != nil { 1195 return fake.NewQueryExecutorStub() 1196 } 1197 if specificReturn { 1198 return ret.result1, ret.result2 1199 } 1200 fakeReturns := fake.newQueryExecutorReturns 1201 return fakeReturns.result1, fakeReturns.result2 1202 } 1203 1204 func (fake *PeerLedger) NewQueryExecutorCallCount() int { 1205 fake.newQueryExecutorMutex.RLock() 1206 defer fake.newQueryExecutorMutex.RUnlock() 1207 return len(fake.newQueryExecutorArgsForCall) 1208 } 1209 1210 func (fake *PeerLedger) NewQueryExecutorCalls(stub func() (ledger.QueryExecutor, error)) { 1211 fake.newQueryExecutorMutex.Lock() 1212 defer fake.newQueryExecutorMutex.Unlock() 1213 fake.NewQueryExecutorStub = stub 1214 } 1215 1216 func (fake *PeerLedger) NewQueryExecutorReturns(result1 ledger.QueryExecutor, result2 error) { 1217 fake.newQueryExecutorMutex.Lock() 1218 defer fake.newQueryExecutorMutex.Unlock() 1219 fake.NewQueryExecutorStub = nil 1220 fake.newQueryExecutorReturns = struct { 1221 result1 ledger.QueryExecutor 1222 result2 error 1223 }{result1, result2} 1224 } 1225 1226 func (fake *PeerLedger) NewQueryExecutorReturnsOnCall(i int, result1 ledger.QueryExecutor, result2 error) { 1227 fake.newQueryExecutorMutex.Lock() 1228 defer fake.newQueryExecutorMutex.Unlock() 1229 fake.NewQueryExecutorStub = nil 1230 if fake.newQueryExecutorReturnsOnCall == nil { 1231 fake.newQueryExecutorReturnsOnCall = make(map[int]struct { 1232 result1 ledger.QueryExecutor 1233 result2 error 1234 }) 1235 } 1236 fake.newQueryExecutorReturnsOnCall[i] = struct { 1237 result1 ledger.QueryExecutor 1238 result2 error 1239 }{result1, result2} 1240 } 1241 1242 func (fake *PeerLedger) NewTxSimulator(arg1 string) (ledger.TxSimulator, error) { 1243 fake.newTxSimulatorMutex.Lock() 1244 ret, specificReturn := fake.newTxSimulatorReturnsOnCall[len(fake.newTxSimulatorArgsForCall)] 1245 fake.newTxSimulatorArgsForCall = append(fake.newTxSimulatorArgsForCall, struct { 1246 arg1 string 1247 }{arg1}) 1248 fake.recordInvocation("NewTxSimulator", []interface{}{arg1}) 1249 fake.newTxSimulatorMutex.Unlock() 1250 if fake.NewTxSimulatorStub != nil { 1251 return fake.NewTxSimulatorStub(arg1) 1252 } 1253 if specificReturn { 1254 return ret.result1, ret.result2 1255 } 1256 fakeReturns := fake.newTxSimulatorReturns 1257 return fakeReturns.result1, fakeReturns.result2 1258 } 1259 1260 func (fake *PeerLedger) NewTxSimulatorCallCount() int { 1261 fake.newTxSimulatorMutex.RLock() 1262 defer fake.newTxSimulatorMutex.RUnlock() 1263 return len(fake.newTxSimulatorArgsForCall) 1264 } 1265 1266 func (fake *PeerLedger) NewTxSimulatorCalls(stub func(string) (ledger.TxSimulator, error)) { 1267 fake.newTxSimulatorMutex.Lock() 1268 defer fake.newTxSimulatorMutex.Unlock() 1269 fake.NewTxSimulatorStub = stub 1270 } 1271 1272 func (fake *PeerLedger) NewTxSimulatorArgsForCall(i int) string { 1273 fake.newTxSimulatorMutex.RLock() 1274 defer fake.newTxSimulatorMutex.RUnlock() 1275 argsForCall := fake.newTxSimulatorArgsForCall[i] 1276 return argsForCall.arg1 1277 } 1278 1279 func (fake *PeerLedger) NewTxSimulatorReturns(result1 ledger.TxSimulator, result2 error) { 1280 fake.newTxSimulatorMutex.Lock() 1281 defer fake.newTxSimulatorMutex.Unlock() 1282 fake.NewTxSimulatorStub = nil 1283 fake.newTxSimulatorReturns = struct { 1284 result1 ledger.TxSimulator 1285 result2 error 1286 }{result1, result2} 1287 } 1288 1289 func (fake *PeerLedger) NewTxSimulatorReturnsOnCall(i int, result1 ledger.TxSimulator, result2 error) { 1290 fake.newTxSimulatorMutex.Lock() 1291 defer fake.newTxSimulatorMutex.Unlock() 1292 fake.NewTxSimulatorStub = nil 1293 if fake.newTxSimulatorReturnsOnCall == nil { 1294 fake.newTxSimulatorReturnsOnCall = make(map[int]struct { 1295 result1 ledger.TxSimulator 1296 result2 error 1297 }) 1298 } 1299 fake.newTxSimulatorReturnsOnCall[i] = struct { 1300 result1 ledger.TxSimulator 1301 result2 error 1302 }{result1, result2} 1303 } 1304 1305 func (fake *PeerLedger) Invocations() map[string][][]interface{} { 1306 fake.invocationsMutex.RLock() 1307 defer fake.invocationsMutex.RUnlock() 1308 fake.closeMutex.RLock() 1309 defer fake.closeMutex.RUnlock() 1310 fake.commitLegacyMutex.RLock() 1311 defer fake.commitLegacyMutex.RUnlock() 1312 fake.commitPvtDataOfOldBlocksMutex.RLock() 1313 defer fake.commitPvtDataOfOldBlocksMutex.RUnlock() 1314 fake.doesPvtDataInfoExistMutex.RLock() 1315 defer fake.doesPvtDataInfoExistMutex.RUnlock() 1316 fake.getBlockByHashMutex.RLock() 1317 defer fake.getBlockByHashMutex.RUnlock() 1318 fake.getBlockByNumberMutex.RLock() 1319 defer fake.getBlockByNumberMutex.RUnlock() 1320 fake.getBlockByTxIDMutex.RLock() 1321 defer fake.getBlockByTxIDMutex.RUnlock() 1322 fake.getBlockchainInfoMutex.RLock() 1323 defer fake.getBlockchainInfoMutex.RUnlock() 1324 fake.getBlocksIteratorMutex.RLock() 1325 defer fake.getBlocksIteratorMutex.RUnlock() 1326 fake.getConfigHistoryRetrieverMutex.RLock() 1327 defer fake.getConfigHistoryRetrieverMutex.RUnlock() 1328 fake.getMissingPvtDataTrackerMutex.RLock() 1329 defer fake.getMissingPvtDataTrackerMutex.RUnlock() 1330 fake.getPvtDataAndBlockByNumMutex.RLock() 1331 defer fake.getPvtDataAndBlockByNumMutex.RUnlock() 1332 fake.getPvtDataByNumMutex.RLock() 1333 defer fake.getPvtDataByNumMutex.RUnlock() 1334 fake.getTransactionByIDMutex.RLock() 1335 defer fake.getTransactionByIDMutex.RUnlock() 1336 fake.getTxValidationCodeByTxIDMutex.RLock() 1337 defer fake.getTxValidationCodeByTxIDMutex.RUnlock() 1338 fake.newHistoryQueryExecutorMutex.RLock() 1339 defer fake.newHistoryQueryExecutorMutex.RUnlock() 1340 fake.newQueryExecutorMutex.RLock() 1341 defer fake.newQueryExecutorMutex.RUnlock() 1342 fake.newTxSimulatorMutex.RLock() 1343 defer fake.newTxSimulatorMutex.RUnlock() 1344 copiedInvocations := map[string][][]interface{}{} 1345 for key, value := range fake.invocations { 1346 copiedInvocations[key] = value 1347 } 1348 return copiedInvocations 1349 } 1350 1351 func (fake *PeerLedger) recordInvocation(key string, args []interface{}) { 1352 fake.invocationsMutex.Lock() 1353 defer fake.invocationsMutex.Unlock() 1354 if fake.invocations == nil { 1355 fake.invocations = map[string][][]interface{}{} 1356 } 1357 if fake.invocations[key] == nil { 1358 fake.invocations[key] = [][]interface{}{} 1359 } 1360 fake.invocations[key] = append(fake.invocations[key], args) 1361 }