github.com/hechain20/hechain@v0.0.0-20220316014945-b544036ba106/core/endorser/fake/tx_simulator.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package fake 3 4 import ( 5 "sync" 6 7 "github.com/hechain20/hechain/common/ledger" 8 ledgera "github.com/hechain20/hechain/core/ledger" 9 ) 10 11 type TxSimulator struct { 12 DeletePrivateDataStub func(string, string, string) error 13 deletePrivateDataMutex sync.RWMutex 14 deletePrivateDataArgsForCall []struct { 15 arg1 string 16 arg2 string 17 arg3 string 18 } 19 deletePrivateDataReturns struct { 20 result1 error 21 } 22 deletePrivateDataReturnsOnCall map[int]struct { 23 result1 error 24 } 25 DeletePrivateDataMetadataStub func(string, string, string) error 26 deletePrivateDataMetadataMutex sync.RWMutex 27 deletePrivateDataMetadataArgsForCall []struct { 28 arg1 string 29 arg2 string 30 arg3 string 31 } 32 deletePrivateDataMetadataReturns struct { 33 result1 error 34 } 35 deletePrivateDataMetadataReturnsOnCall map[int]struct { 36 result1 error 37 } 38 DeleteStateStub func(string, string) error 39 deleteStateMutex sync.RWMutex 40 deleteStateArgsForCall []struct { 41 arg1 string 42 arg2 string 43 } 44 deleteStateReturns struct { 45 result1 error 46 } 47 deleteStateReturnsOnCall map[int]struct { 48 result1 error 49 } 50 DeleteStateMetadataStub func(string, string) error 51 deleteStateMetadataMutex sync.RWMutex 52 deleteStateMetadataArgsForCall []struct { 53 arg1 string 54 arg2 string 55 } 56 deleteStateMetadataReturns struct { 57 result1 error 58 } 59 deleteStateMetadataReturnsOnCall map[int]struct { 60 result1 error 61 } 62 DoneStub func() 63 doneMutex sync.RWMutex 64 doneArgsForCall []struct { 65 } 66 ExecuteQueryStub func(string, string) (ledger.ResultsIterator, error) 67 executeQueryMutex sync.RWMutex 68 executeQueryArgsForCall []struct { 69 arg1 string 70 arg2 string 71 } 72 executeQueryReturns struct { 73 result1 ledger.ResultsIterator 74 result2 error 75 } 76 executeQueryReturnsOnCall map[int]struct { 77 result1 ledger.ResultsIterator 78 result2 error 79 } 80 ExecuteQueryOnPrivateDataStub func(string, string, string) (ledger.ResultsIterator, error) 81 executeQueryOnPrivateDataMutex sync.RWMutex 82 executeQueryOnPrivateDataArgsForCall []struct { 83 arg1 string 84 arg2 string 85 arg3 string 86 } 87 executeQueryOnPrivateDataReturns struct { 88 result1 ledger.ResultsIterator 89 result2 error 90 } 91 executeQueryOnPrivateDataReturnsOnCall map[int]struct { 92 result1 ledger.ResultsIterator 93 result2 error 94 } 95 ExecuteQueryWithPaginationStub func(string, string, string, int32) (ledgera.QueryResultsIterator, error) 96 executeQueryWithPaginationMutex sync.RWMutex 97 executeQueryWithPaginationArgsForCall []struct { 98 arg1 string 99 arg2 string 100 arg3 string 101 arg4 int32 102 } 103 executeQueryWithPaginationReturns struct { 104 result1 ledgera.QueryResultsIterator 105 result2 error 106 } 107 executeQueryWithPaginationReturnsOnCall map[int]struct { 108 result1 ledgera.QueryResultsIterator 109 result2 error 110 } 111 ExecuteUpdateStub func(string) error 112 executeUpdateMutex sync.RWMutex 113 executeUpdateArgsForCall []struct { 114 arg1 string 115 } 116 executeUpdateReturns struct { 117 result1 error 118 } 119 executeUpdateReturnsOnCall map[int]struct { 120 result1 error 121 } 122 GetPrivateDataStub func(string, string, string) ([]byte, error) 123 getPrivateDataMutex sync.RWMutex 124 getPrivateDataArgsForCall []struct { 125 arg1 string 126 arg2 string 127 arg3 string 128 } 129 getPrivateDataReturns struct { 130 result1 []byte 131 result2 error 132 } 133 getPrivateDataReturnsOnCall map[int]struct { 134 result1 []byte 135 result2 error 136 } 137 GetPrivateDataHashStub func(string, string, string) ([]byte, error) 138 getPrivateDataHashMutex sync.RWMutex 139 getPrivateDataHashArgsForCall []struct { 140 arg1 string 141 arg2 string 142 arg3 string 143 } 144 getPrivateDataHashReturns struct { 145 result1 []byte 146 result2 error 147 } 148 getPrivateDataHashReturnsOnCall map[int]struct { 149 result1 []byte 150 result2 error 151 } 152 GetPrivateDataMetadataStub func(string, string, string) (map[string][]byte, error) 153 getPrivateDataMetadataMutex sync.RWMutex 154 getPrivateDataMetadataArgsForCall []struct { 155 arg1 string 156 arg2 string 157 arg3 string 158 } 159 getPrivateDataMetadataReturns struct { 160 result1 map[string][]byte 161 result2 error 162 } 163 getPrivateDataMetadataReturnsOnCall map[int]struct { 164 result1 map[string][]byte 165 result2 error 166 } 167 GetPrivateDataMetadataByHashStub func(string, string, []byte) (map[string][]byte, error) 168 getPrivateDataMetadataByHashMutex sync.RWMutex 169 getPrivateDataMetadataByHashArgsForCall []struct { 170 arg1 string 171 arg2 string 172 arg3 []byte 173 } 174 getPrivateDataMetadataByHashReturns struct { 175 result1 map[string][]byte 176 result2 error 177 } 178 getPrivateDataMetadataByHashReturnsOnCall map[int]struct { 179 result1 map[string][]byte 180 result2 error 181 } 182 GetPrivateDataMultipleKeysStub func(string, string, []string) ([][]byte, error) 183 getPrivateDataMultipleKeysMutex sync.RWMutex 184 getPrivateDataMultipleKeysArgsForCall []struct { 185 arg1 string 186 arg2 string 187 arg3 []string 188 } 189 getPrivateDataMultipleKeysReturns struct { 190 result1 [][]byte 191 result2 error 192 } 193 getPrivateDataMultipleKeysReturnsOnCall map[int]struct { 194 result1 [][]byte 195 result2 error 196 } 197 GetPrivateDataRangeScanIteratorStub func(string, string, string, string) (ledger.ResultsIterator, error) 198 getPrivateDataRangeScanIteratorMutex sync.RWMutex 199 getPrivateDataRangeScanIteratorArgsForCall []struct { 200 arg1 string 201 arg2 string 202 arg3 string 203 arg4 string 204 } 205 getPrivateDataRangeScanIteratorReturns struct { 206 result1 ledger.ResultsIterator 207 result2 error 208 } 209 getPrivateDataRangeScanIteratorReturnsOnCall map[int]struct { 210 result1 ledger.ResultsIterator 211 result2 error 212 } 213 GetStateStub func(string, string) ([]byte, error) 214 getStateMutex sync.RWMutex 215 getStateArgsForCall []struct { 216 arg1 string 217 arg2 string 218 } 219 getStateReturns struct { 220 result1 []byte 221 result2 error 222 } 223 getStateReturnsOnCall map[int]struct { 224 result1 []byte 225 result2 error 226 } 227 GetStateMetadataStub func(string, string) (map[string][]byte, error) 228 getStateMetadataMutex sync.RWMutex 229 getStateMetadataArgsForCall []struct { 230 arg1 string 231 arg2 string 232 } 233 getStateMetadataReturns struct { 234 result1 map[string][]byte 235 result2 error 236 } 237 getStateMetadataReturnsOnCall map[int]struct { 238 result1 map[string][]byte 239 result2 error 240 } 241 GetStateMultipleKeysStub func(string, []string) ([][]byte, error) 242 getStateMultipleKeysMutex sync.RWMutex 243 getStateMultipleKeysArgsForCall []struct { 244 arg1 string 245 arg2 []string 246 } 247 getStateMultipleKeysReturns struct { 248 result1 [][]byte 249 result2 error 250 } 251 getStateMultipleKeysReturnsOnCall map[int]struct { 252 result1 [][]byte 253 result2 error 254 } 255 GetStateRangeScanIteratorStub func(string, string, string) (ledger.ResultsIterator, error) 256 getStateRangeScanIteratorMutex sync.RWMutex 257 getStateRangeScanIteratorArgsForCall []struct { 258 arg1 string 259 arg2 string 260 arg3 string 261 } 262 getStateRangeScanIteratorReturns struct { 263 result1 ledger.ResultsIterator 264 result2 error 265 } 266 getStateRangeScanIteratorReturnsOnCall map[int]struct { 267 result1 ledger.ResultsIterator 268 result2 error 269 } 270 GetStateRangeScanIteratorWithPaginationStub func(string, string, string, int32) (ledgera.QueryResultsIterator, error) 271 getStateRangeScanIteratorWithPaginationMutex sync.RWMutex 272 getStateRangeScanIteratorWithPaginationArgsForCall []struct { 273 arg1 string 274 arg2 string 275 arg3 string 276 arg4 int32 277 } 278 getStateRangeScanIteratorWithPaginationReturns struct { 279 result1 ledgera.QueryResultsIterator 280 result2 error 281 } 282 getStateRangeScanIteratorWithPaginationReturnsOnCall map[int]struct { 283 result1 ledgera.QueryResultsIterator 284 result2 error 285 } 286 GetTxSimulationResultsStub func() (*ledgera.TxSimulationResults, error) 287 getTxSimulationResultsMutex sync.RWMutex 288 getTxSimulationResultsArgsForCall []struct { 289 } 290 getTxSimulationResultsReturns struct { 291 result1 *ledgera.TxSimulationResults 292 result2 error 293 } 294 getTxSimulationResultsReturnsOnCall map[int]struct { 295 result1 *ledgera.TxSimulationResults 296 result2 error 297 } 298 SetPrivateDataStub func(string, string, string, []byte) error 299 setPrivateDataMutex sync.RWMutex 300 setPrivateDataArgsForCall []struct { 301 arg1 string 302 arg2 string 303 arg3 string 304 arg4 []byte 305 } 306 setPrivateDataReturns struct { 307 result1 error 308 } 309 setPrivateDataReturnsOnCall map[int]struct { 310 result1 error 311 } 312 SetPrivateDataMetadataStub func(string, string, string, map[string][]byte) error 313 setPrivateDataMetadataMutex sync.RWMutex 314 setPrivateDataMetadataArgsForCall []struct { 315 arg1 string 316 arg2 string 317 arg3 string 318 arg4 map[string][]byte 319 } 320 setPrivateDataMetadataReturns struct { 321 result1 error 322 } 323 setPrivateDataMetadataReturnsOnCall map[int]struct { 324 result1 error 325 } 326 SetPrivateDataMultipleKeysStub func(string, string, map[string][]byte) error 327 setPrivateDataMultipleKeysMutex sync.RWMutex 328 setPrivateDataMultipleKeysArgsForCall []struct { 329 arg1 string 330 arg2 string 331 arg3 map[string][]byte 332 } 333 setPrivateDataMultipleKeysReturns struct { 334 result1 error 335 } 336 setPrivateDataMultipleKeysReturnsOnCall map[int]struct { 337 result1 error 338 } 339 SetStateStub func(string, string, []byte) error 340 setStateMutex sync.RWMutex 341 setStateArgsForCall []struct { 342 arg1 string 343 arg2 string 344 arg3 []byte 345 } 346 setStateReturns struct { 347 result1 error 348 } 349 setStateReturnsOnCall map[int]struct { 350 result1 error 351 } 352 SetStateMetadataStub func(string, string, map[string][]byte) error 353 setStateMetadataMutex sync.RWMutex 354 setStateMetadataArgsForCall []struct { 355 arg1 string 356 arg2 string 357 arg3 map[string][]byte 358 } 359 setStateMetadataReturns struct { 360 result1 error 361 } 362 setStateMetadataReturnsOnCall map[int]struct { 363 result1 error 364 } 365 SetStateMultipleKeysStub func(string, map[string][]byte) error 366 setStateMultipleKeysMutex sync.RWMutex 367 setStateMultipleKeysArgsForCall []struct { 368 arg1 string 369 arg2 map[string][]byte 370 } 371 setStateMultipleKeysReturns struct { 372 result1 error 373 } 374 setStateMultipleKeysReturnsOnCall map[int]struct { 375 result1 error 376 } 377 invocations map[string][][]interface{} 378 invocationsMutex sync.RWMutex 379 } 380 381 func (fake *TxSimulator) DeletePrivateData(arg1 string, arg2 string, arg3 string) error { 382 fake.deletePrivateDataMutex.Lock() 383 ret, specificReturn := fake.deletePrivateDataReturnsOnCall[len(fake.deletePrivateDataArgsForCall)] 384 fake.deletePrivateDataArgsForCall = append(fake.deletePrivateDataArgsForCall, struct { 385 arg1 string 386 arg2 string 387 arg3 string 388 }{arg1, arg2, arg3}) 389 fake.recordInvocation("DeletePrivateData", []interface{}{arg1, arg2, arg3}) 390 fake.deletePrivateDataMutex.Unlock() 391 if fake.DeletePrivateDataStub != nil { 392 return fake.DeletePrivateDataStub(arg1, arg2, arg3) 393 } 394 if specificReturn { 395 return ret.result1 396 } 397 fakeReturns := fake.deletePrivateDataReturns 398 return fakeReturns.result1 399 } 400 401 func (fake *TxSimulator) DeletePrivateDataCallCount() int { 402 fake.deletePrivateDataMutex.RLock() 403 defer fake.deletePrivateDataMutex.RUnlock() 404 return len(fake.deletePrivateDataArgsForCall) 405 } 406 407 func (fake *TxSimulator) DeletePrivateDataCalls(stub func(string, string, string) error) { 408 fake.deletePrivateDataMutex.Lock() 409 defer fake.deletePrivateDataMutex.Unlock() 410 fake.DeletePrivateDataStub = stub 411 } 412 413 func (fake *TxSimulator) DeletePrivateDataArgsForCall(i int) (string, string, string) { 414 fake.deletePrivateDataMutex.RLock() 415 defer fake.deletePrivateDataMutex.RUnlock() 416 argsForCall := fake.deletePrivateDataArgsForCall[i] 417 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 418 } 419 420 func (fake *TxSimulator) DeletePrivateDataReturns(result1 error) { 421 fake.deletePrivateDataMutex.Lock() 422 defer fake.deletePrivateDataMutex.Unlock() 423 fake.DeletePrivateDataStub = nil 424 fake.deletePrivateDataReturns = struct { 425 result1 error 426 }{result1} 427 } 428 429 func (fake *TxSimulator) DeletePrivateDataReturnsOnCall(i int, result1 error) { 430 fake.deletePrivateDataMutex.Lock() 431 defer fake.deletePrivateDataMutex.Unlock() 432 fake.DeletePrivateDataStub = nil 433 if fake.deletePrivateDataReturnsOnCall == nil { 434 fake.deletePrivateDataReturnsOnCall = make(map[int]struct { 435 result1 error 436 }) 437 } 438 fake.deletePrivateDataReturnsOnCall[i] = struct { 439 result1 error 440 }{result1} 441 } 442 443 func (fake *TxSimulator) DeletePrivateDataMetadata(arg1 string, arg2 string, arg3 string) error { 444 fake.deletePrivateDataMetadataMutex.Lock() 445 ret, specificReturn := fake.deletePrivateDataMetadataReturnsOnCall[len(fake.deletePrivateDataMetadataArgsForCall)] 446 fake.deletePrivateDataMetadataArgsForCall = append(fake.deletePrivateDataMetadataArgsForCall, struct { 447 arg1 string 448 arg2 string 449 arg3 string 450 }{arg1, arg2, arg3}) 451 fake.recordInvocation("DeletePrivateDataMetadata", []interface{}{arg1, arg2, arg3}) 452 fake.deletePrivateDataMetadataMutex.Unlock() 453 if fake.DeletePrivateDataMetadataStub != nil { 454 return fake.DeletePrivateDataMetadataStub(arg1, arg2, arg3) 455 } 456 if specificReturn { 457 return ret.result1 458 } 459 fakeReturns := fake.deletePrivateDataMetadataReturns 460 return fakeReturns.result1 461 } 462 463 func (fake *TxSimulator) DeletePrivateDataMetadataCallCount() int { 464 fake.deletePrivateDataMetadataMutex.RLock() 465 defer fake.deletePrivateDataMetadataMutex.RUnlock() 466 return len(fake.deletePrivateDataMetadataArgsForCall) 467 } 468 469 func (fake *TxSimulator) DeletePrivateDataMetadataCalls(stub func(string, string, string) error) { 470 fake.deletePrivateDataMetadataMutex.Lock() 471 defer fake.deletePrivateDataMetadataMutex.Unlock() 472 fake.DeletePrivateDataMetadataStub = stub 473 } 474 475 func (fake *TxSimulator) DeletePrivateDataMetadataArgsForCall(i int) (string, string, string) { 476 fake.deletePrivateDataMetadataMutex.RLock() 477 defer fake.deletePrivateDataMetadataMutex.RUnlock() 478 argsForCall := fake.deletePrivateDataMetadataArgsForCall[i] 479 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 480 } 481 482 func (fake *TxSimulator) DeletePrivateDataMetadataReturns(result1 error) { 483 fake.deletePrivateDataMetadataMutex.Lock() 484 defer fake.deletePrivateDataMetadataMutex.Unlock() 485 fake.DeletePrivateDataMetadataStub = nil 486 fake.deletePrivateDataMetadataReturns = struct { 487 result1 error 488 }{result1} 489 } 490 491 func (fake *TxSimulator) DeletePrivateDataMetadataReturnsOnCall(i int, result1 error) { 492 fake.deletePrivateDataMetadataMutex.Lock() 493 defer fake.deletePrivateDataMetadataMutex.Unlock() 494 fake.DeletePrivateDataMetadataStub = nil 495 if fake.deletePrivateDataMetadataReturnsOnCall == nil { 496 fake.deletePrivateDataMetadataReturnsOnCall = make(map[int]struct { 497 result1 error 498 }) 499 } 500 fake.deletePrivateDataMetadataReturnsOnCall[i] = struct { 501 result1 error 502 }{result1} 503 } 504 505 func (fake *TxSimulator) DeleteState(arg1 string, arg2 string) error { 506 fake.deleteStateMutex.Lock() 507 ret, specificReturn := fake.deleteStateReturnsOnCall[len(fake.deleteStateArgsForCall)] 508 fake.deleteStateArgsForCall = append(fake.deleteStateArgsForCall, struct { 509 arg1 string 510 arg2 string 511 }{arg1, arg2}) 512 fake.recordInvocation("DeleteState", []interface{}{arg1, arg2}) 513 fake.deleteStateMutex.Unlock() 514 if fake.DeleteStateStub != nil { 515 return fake.DeleteStateStub(arg1, arg2) 516 } 517 if specificReturn { 518 return ret.result1 519 } 520 fakeReturns := fake.deleteStateReturns 521 return fakeReturns.result1 522 } 523 524 func (fake *TxSimulator) DeleteStateCallCount() int { 525 fake.deleteStateMutex.RLock() 526 defer fake.deleteStateMutex.RUnlock() 527 return len(fake.deleteStateArgsForCall) 528 } 529 530 func (fake *TxSimulator) DeleteStateCalls(stub func(string, string) error) { 531 fake.deleteStateMutex.Lock() 532 defer fake.deleteStateMutex.Unlock() 533 fake.DeleteStateStub = stub 534 } 535 536 func (fake *TxSimulator) DeleteStateArgsForCall(i int) (string, string) { 537 fake.deleteStateMutex.RLock() 538 defer fake.deleteStateMutex.RUnlock() 539 argsForCall := fake.deleteStateArgsForCall[i] 540 return argsForCall.arg1, argsForCall.arg2 541 } 542 543 func (fake *TxSimulator) DeleteStateReturns(result1 error) { 544 fake.deleteStateMutex.Lock() 545 defer fake.deleteStateMutex.Unlock() 546 fake.DeleteStateStub = nil 547 fake.deleteStateReturns = struct { 548 result1 error 549 }{result1} 550 } 551 552 func (fake *TxSimulator) DeleteStateReturnsOnCall(i int, result1 error) { 553 fake.deleteStateMutex.Lock() 554 defer fake.deleteStateMutex.Unlock() 555 fake.DeleteStateStub = nil 556 if fake.deleteStateReturnsOnCall == nil { 557 fake.deleteStateReturnsOnCall = make(map[int]struct { 558 result1 error 559 }) 560 } 561 fake.deleteStateReturnsOnCall[i] = struct { 562 result1 error 563 }{result1} 564 } 565 566 func (fake *TxSimulator) DeleteStateMetadata(arg1 string, arg2 string) error { 567 fake.deleteStateMetadataMutex.Lock() 568 ret, specificReturn := fake.deleteStateMetadataReturnsOnCall[len(fake.deleteStateMetadataArgsForCall)] 569 fake.deleteStateMetadataArgsForCall = append(fake.deleteStateMetadataArgsForCall, struct { 570 arg1 string 571 arg2 string 572 }{arg1, arg2}) 573 fake.recordInvocation("DeleteStateMetadata", []interface{}{arg1, arg2}) 574 fake.deleteStateMetadataMutex.Unlock() 575 if fake.DeleteStateMetadataStub != nil { 576 return fake.DeleteStateMetadataStub(arg1, arg2) 577 } 578 if specificReturn { 579 return ret.result1 580 } 581 fakeReturns := fake.deleteStateMetadataReturns 582 return fakeReturns.result1 583 } 584 585 func (fake *TxSimulator) DeleteStateMetadataCallCount() int { 586 fake.deleteStateMetadataMutex.RLock() 587 defer fake.deleteStateMetadataMutex.RUnlock() 588 return len(fake.deleteStateMetadataArgsForCall) 589 } 590 591 func (fake *TxSimulator) DeleteStateMetadataCalls(stub func(string, string) error) { 592 fake.deleteStateMetadataMutex.Lock() 593 defer fake.deleteStateMetadataMutex.Unlock() 594 fake.DeleteStateMetadataStub = stub 595 } 596 597 func (fake *TxSimulator) DeleteStateMetadataArgsForCall(i int) (string, string) { 598 fake.deleteStateMetadataMutex.RLock() 599 defer fake.deleteStateMetadataMutex.RUnlock() 600 argsForCall := fake.deleteStateMetadataArgsForCall[i] 601 return argsForCall.arg1, argsForCall.arg2 602 } 603 604 func (fake *TxSimulator) DeleteStateMetadataReturns(result1 error) { 605 fake.deleteStateMetadataMutex.Lock() 606 defer fake.deleteStateMetadataMutex.Unlock() 607 fake.DeleteStateMetadataStub = nil 608 fake.deleteStateMetadataReturns = struct { 609 result1 error 610 }{result1} 611 } 612 613 func (fake *TxSimulator) DeleteStateMetadataReturnsOnCall(i int, result1 error) { 614 fake.deleteStateMetadataMutex.Lock() 615 defer fake.deleteStateMetadataMutex.Unlock() 616 fake.DeleteStateMetadataStub = nil 617 if fake.deleteStateMetadataReturnsOnCall == nil { 618 fake.deleteStateMetadataReturnsOnCall = make(map[int]struct { 619 result1 error 620 }) 621 } 622 fake.deleteStateMetadataReturnsOnCall[i] = struct { 623 result1 error 624 }{result1} 625 } 626 627 func (fake *TxSimulator) Done() { 628 fake.doneMutex.Lock() 629 fake.doneArgsForCall = append(fake.doneArgsForCall, struct { 630 }{}) 631 fake.recordInvocation("Done", []interface{}{}) 632 fake.doneMutex.Unlock() 633 if fake.DoneStub != nil { 634 fake.DoneStub() 635 } 636 } 637 638 func (fake *TxSimulator) DoneCallCount() int { 639 fake.doneMutex.RLock() 640 defer fake.doneMutex.RUnlock() 641 return len(fake.doneArgsForCall) 642 } 643 644 func (fake *TxSimulator) DoneCalls(stub func()) { 645 fake.doneMutex.Lock() 646 defer fake.doneMutex.Unlock() 647 fake.DoneStub = stub 648 } 649 650 func (fake *TxSimulator) ExecuteQuery(arg1 string, arg2 string) (ledger.ResultsIterator, error) { 651 fake.executeQueryMutex.Lock() 652 ret, specificReturn := fake.executeQueryReturnsOnCall[len(fake.executeQueryArgsForCall)] 653 fake.executeQueryArgsForCall = append(fake.executeQueryArgsForCall, struct { 654 arg1 string 655 arg2 string 656 }{arg1, arg2}) 657 fake.recordInvocation("ExecuteQuery", []interface{}{arg1, arg2}) 658 fake.executeQueryMutex.Unlock() 659 if fake.ExecuteQueryStub != nil { 660 return fake.ExecuteQueryStub(arg1, arg2) 661 } 662 if specificReturn { 663 return ret.result1, ret.result2 664 } 665 fakeReturns := fake.executeQueryReturns 666 return fakeReturns.result1, fakeReturns.result2 667 } 668 669 func (fake *TxSimulator) ExecuteQueryCallCount() int { 670 fake.executeQueryMutex.RLock() 671 defer fake.executeQueryMutex.RUnlock() 672 return len(fake.executeQueryArgsForCall) 673 } 674 675 func (fake *TxSimulator) ExecuteQueryCalls(stub func(string, string) (ledger.ResultsIterator, error)) { 676 fake.executeQueryMutex.Lock() 677 defer fake.executeQueryMutex.Unlock() 678 fake.ExecuteQueryStub = stub 679 } 680 681 func (fake *TxSimulator) ExecuteQueryArgsForCall(i int) (string, string) { 682 fake.executeQueryMutex.RLock() 683 defer fake.executeQueryMutex.RUnlock() 684 argsForCall := fake.executeQueryArgsForCall[i] 685 return argsForCall.arg1, argsForCall.arg2 686 } 687 688 func (fake *TxSimulator) ExecuteQueryReturns(result1 ledger.ResultsIterator, result2 error) { 689 fake.executeQueryMutex.Lock() 690 defer fake.executeQueryMutex.Unlock() 691 fake.ExecuteQueryStub = nil 692 fake.executeQueryReturns = struct { 693 result1 ledger.ResultsIterator 694 result2 error 695 }{result1, result2} 696 } 697 698 func (fake *TxSimulator) ExecuteQueryReturnsOnCall(i int, result1 ledger.ResultsIterator, result2 error) { 699 fake.executeQueryMutex.Lock() 700 defer fake.executeQueryMutex.Unlock() 701 fake.ExecuteQueryStub = nil 702 if fake.executeQueryReturnsOnCall == nil { 703 fake.executeQueryReturnsOnCall = make(map[int]struct { 704 result1 ledger.ResultsIterator 705 result2 error 706 }) 707 } 708 fake.executeQueryReturnsOnCall[i] = struct { 709 result1 ledger.ResultsIterator 710 result2 error 711 }{result1, result2} 712 } 713 714 func (fake *TxSimulator) ExecuteQueryOnPrivateData(arg1 string, arg2 string, arg3 string) (ledger.ResultsIterator, error) { 715 fake.executeQueryOnPrivateDataMutex.Lock() 716 ret, specificReturn := fake.executeQueryOnPrivateDataReturnsOnCall[len(fake.executeQueryOnPrivateDataArgsForCall)] 717 fake.executeQueryOnPrivateDataArgsForCall = append(fake.executeQueryOnPrivateDataArgsForCall, struct { 718 arg1 string 719 arg2 string 720 arg3 string 721 }{arg1, arg2, arg3}) 722 fake.recordInvocation("ExecuteQueryOnPrivateData", []interface{}{arg1, arg2, arg3}) 723 fake.executeQueryOnPrivateDataMutex.Unlock() 724 if fake.ExecuteQueryOnPrivateDataStub != nil { 725 return fake.ExecuteQueryOnPrivateDataStub(arg1, arg2, arg3) 726 } 727 if specificReturn { 728 return ret.result1, ret.result2 729 } 730 fakeReturns := fake.executeQueryOnPrivateDataReturns 731 return fakeReturns.result1, fakeReturns.result2 732 } 733 734 func (fake *TxSimulator) ExecuteQueryOnPrivateDataCallCount() int { 735 fake.executeQueryOnPrivateDataMutex.RLock() 736 defer fake.executeQueryOnPrivateDataMutex.RUnlock() 737 return len(fake.executeQueryOnPrivateDataArgsForCall) 738 } 739 740 func (fake *TxSimulator) ExecuteQueryOnPrivateDataCalls(stub func(string, string, string) (ledger.ResultsIterator, error)) { 741 fake.executeQueryOnPrivateDataMutex.Lock() 742 defer fake.executeQueryOnPrivateDataMutex.Unlock() 743 fake.ExecuteQueryOnPrivateDataStub = stub 744 } 745 746 func (fake *TxSimulator) ExecuteQueryOnPrivateDataArgsForCall(i int) (string, string, string) { 747 fake.executeQueryOnPrivateDataMutex.RLock() 748 defer fake.executeQueryOnPrivateDataMutex.RUnlock() 749 argsForCall := fake.executeQueryOnPrivateDataArgsForCall[i] 750 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 751 } 752 753 func (fake *TxSimulator) ExecuteQueryOnPrivateDataReturns(result1 ledger.ResultsIterator, result2 error) { 754 fake.executeQueryOnPrivateDataMutex.Lock() 755 defer fake.executeQueryOnPrivateDataMutex.Unlock() 756 fake.ExecuteQueryOnPrivateDataStub = nil 757 fake.executeQueryOnPrivateDataReturns = struct { 758 result1 ledger.ResultsIterator 759 result2 error 760 }{result1, result2} 761 } 762 763 func (fake *TxSimulator) ExecuteQueryOnPrivateDataReturnsOnCall(i int, result1 ledger.ResultsIterator, result2 error) { 764 fake.executeQueryOnPrivateDataMutex.Lock() 765 defer fake.executeQueryOnPrivateDataMutex.Unlock() 766 fake.ExecuteQueryOnPrivateDataStub = nil 767 if fake.executeQueryOnPrivateDataReturnsOnCall == nil { 768 fake.executeQueryOnPrivateDataReturnsOnCall = make(map[int]struct { 769 result1 ledger.ResultsIterator 770 result2 error 771 }) 772 } 773 fake.executeQueryOnPrivateDataReturnsOnCall[i] = struct { 774 result1 ledger.ResultsIterator 775 result2 error 776 }{result1, result2} 777 } 778 779 func (fake *TxSimulator) ExecuteQueryWithPagination(arg1 string, arg2 string, arg3 string, arg4 int32) (ledgera.QueryResultsIterator, error) { 780 fake.executeQueryWithPaginationMutex.Lock() 781 ret, specificReturn := fake.executeQueryWithPaginationReturnsOnCall[len(fake.executeQueryWithPaginationArgsForCall)] 782 fake.executeQueryWithPaginationArgsForCall = append(fake.executeQueryWithPaginationArgsForCall, struct { 783 arg1 string 784 arg2 string 785 arg3 string 786 arg4 int32 787 }{arg1, arg2, arg3, arg4}) 788 fake.recordInvocation("ExecuteQueryWithPagination", []interface{}{arg1, arg2, arg3, arg4}) 789 fake.executeQueryWithPaginationMutex.Unlock() 790 if fake.ExecuteQueryWithPaginationStub != nil { 791 return fake.ExecuteQueryWithPaginationStub(arg1, arg2, arg3, arg4) 792 } 793 if specificReturn { 794 return ret.result1, ret.result2 795 } 796 fakeReturns := fake.executeQueryWithPaginationReturns 797 return fakeReturns.result1, fakeReturns.result2 798 } 799 800 func (fake *TxSimulator) ExecuteQueryWithPaginationCallCount() int { 801 fake.executeQueryWithPaginationMutex.RLock() 802 defer fake.executeQueryWithPaginationMutex.RUnlock() 803 return len(fake.executeQueryWithPaginationArgsForCall) 804 } 805 806 func (fake *TxSimulator) ExecuteQueryWithPaginationCalls(stub func(string, string, string, int32) (ledgera.QueryResultsIterator, error)) { 807 fake.executeQueryWithPaginationMutex.Lock() 808 defer fake.executeQueryWithPaginationMutex.Unlock() 809 fake.ExecuteQueryWithPaginationStub = stub 810 } 811 812 func (fake *TxSimulator) ExecuteQueryWithPaginationArgsForCall(i int) (string, string, string, int32) { 813 fake.executeQueryWithPaginationMutex.RLock() 814 defer fake.executeQueryWithPaginationMutex.RUnlock() 815 argsForCall := fake.executeQueryWithPaginationArgsForCall[i] 816 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 817 } 818 819 func (fake *TxSimulator) ExecuteQueryWithPaginationReturns(result1 ledgera.QueryResultsIterator, result2 error) { 820 fake.executeQueryWithPaginationMutex.Lock() 821 defer fake.executeQueryWithPaginationMutex.Unlock() 822 fake.ExecuteQueryWithPaginationStub = nil 823 fake.executeQueryWithPaginationReturns = struct { 824 result1 ledgera.QueryResultsIterator 825 result2 error 826 }{result1, result2} 827 } 828 829 func (fake *TxSimulator) ExecuteQueryWithPaginationReturnsOnCall(i int, result1 ledgera.QueryResultsIterator, result2 error) { 830 fake.executeQueryWithPaginationMutex.Lock() 831 defer fake.executeQueryWithPaginationMutex.Unlock() 832 fake.ExecuteQueryWithPaginationStub = nil 833 if fake.executeQueryWithPaginationReturnsOnCall == nil { 834 fake.executeQueryWithPaginationReturnsOnCall = make(map[int]struct { 835 result1 ledgera.QueryResultsIterator 836 result2 error 837 }) 838 } 839 fake.executeQueryWithPaginationReturnsOnCall[i] = struct { 840 result1 ledgera.QueryResultsIterator 841 result2 error 842 }{result1, result2} 843 } 844 845 func (fake *TxSimulator) ExecuteUpdate(arg1 string) error { 846 fake.executeUpdateMutex.Lock() 847 ret, specificReturn := fake.executeUpdateReturnsOnCall[len(fake.executeUpdateArgsForCall)] 848 fake.executeUpdateArgsForCall = append(fake.executeUpdateArgsForCall, struct { 849 arg1 string 850 }{arg1}) 851 fake.recordInvocation("ExecuteUpdate", []interface{}{arg1}) 852 fake.executeUpdateMutex.Unlock() 853 if fake.ExecuteUpdateStub != nil { 854 return fake.ExecuteUpdateStub(arg1) 855 } 856 if specificReturn { 857 return ret.result1 858 } 859 fakeReturns := fake.executeUpdateReturns 860 return fakeReturns.result1 861 } 862 863 func (fake *TxSimulator) ExecuteUpdateCallCount() int { 864 fake.executeUpdateMutex.RLock() 865 defer fake.executeUpdateMutex.RUnlock() 866 return len(fake.executeUpdateArgsForCall) 867 } 868 869 func (fake *TxSimulator) ExecuteUpdateCalls(stub func(string) error) { 870 fake.executeUpdateMutex.Lock() 871 defer fake.executeUpdateMutex.Unlock() 872 fake.ExecuteUpdateStub = stub 873 } 874 875 func (fake *TxSimulator) ExecuteUpdateArgsForCall(i int) string { 876 fake.executeUpdateMutex.RLock() 877 defer fake.executeUpdateMutex.RUnlock() 878 argsForCall := fake.executeUpdateArgsForCall[i] 879 return argsForCall.arg1 880 } 881 882 func (fake *TxSimulator) ExecuteUpdateReturns(result1 error) { 883 fake.executeUpdateMutex.Lock() 884 defer fake.executeUpdateMutex.Unlock() 885 fake.ExecuteUpdateStub = nil 886 fake.executeUpdateReturns = struct { 887 result1 error 888 }{result1} 889 } 890 891 func (fake *TxSimulator) ExecuteUpdateReturnsOnCall(i int, result1 error) { 892 fake.executeUpdateMutex.Lock() 893 defer fake.executeUpdateMutex.Unlock() 894 fake.ExecuteUpdateStub = nil 895 if fake.executeUpdateReturnsOnCall == nil { 896 fake.executeUpdateReturnsOnCall = make(map[int]struct { 897 result1 error 898 }) 899 } 900 fake.executeUpdateReturnsOnCall[i] = struct { 901 result1 error 902 }{result1} 903 } 904 905 func (fake *TxSimulator) GetPrivateData(arg1 string, arg2 string, arg3 string) ([]byte, error) { 906 fake.getPrivateDataMutex.Lock() 907 ret, specificReturn := fake.getPrivateDataReturnsOnCall[len(fake.getPrivateDataArgsForCall)] 908 fake.getPrivateDataArgsForCall = append(fake.getPrivateDataArgsForCall, struct { 909 arg1 string 910 arg2 string 911 arg3 string 912 }{arg1, arg2, arg3}) 913 fake.recordInvocation("GetPrivateData", []interface{}{arg1, arg2, arg3}) 914 fake.getPrivateDataMutex.Unlock() 915 if fake.GetPrivateDataStub != nil { 916 return fake.GetPrivateDataStub(arg1, arg2, arg3) 917 } 918 if specificReturn { 919 return ret.result1, ret.result2 920 } 921 fakeReturns := fake.getPrivateDataReturns 922 return fakeReturns.result1, fakeReturns.result2 923 } 924 925 func (fake *TxSimulator) GetPrivateDataCallCount() int { 926 fake.getPrivateDataMutex.RLock() 927 defer fake.getPrivateDataMutex.RUnlock() 928 return len(fake.getPrivateDataArgsForCall) 929 } 930 931 func (fake *TxSimulator) GetPrivateDataCalls(stub func(string, string, string) ([]byte, error)) { 932 fake.getPrivateDataMutex.Lock() 933 defer fake.getPrivateDataMutex.Unlock() 934 fake.GetPrivateDataStub = stub 935 } 936 937 func (fake *TxSimulator) GetPrivateDataArgsForCall(i int) (string, string, string) { 938 fake.getPrivateDataMutex.RLock() 939 defer fake.getPrivateDataMutex.RUnlock() 940 argsForCall := fake.getPrivateDataArgsForCall[i] 941 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 942 } 943 944 func (fake *TxSimulator) GetPrivateDataReturns(result1 []byte, result2 error) { 945 fake.getPrivateDataMutex.Lock() 946 defer fake.getPrivateDataMutex.Unlock() 947 fake.GetPrivateDataStub = nil 948 fake.getPrivateDataReturns = struct { 949 result1 []byte 950 result2 error 951 }{result1, result2} 952 } 953 954 func (fake *TxSimulator) GetPrivateDataReturnsOnCall(i int, result1 []byte, result2 error) { 955 fake.getPrivateDataMutex.Lock() 956 defer fake.getPrivateDataMutex.Unlock() 957 fake.GetPrivateDataStub = nil 958 if fake.getPrivateDataReturnsOnCall == nil { 959 fake.getPrivateDataReturnsOnCall = make(map[int]struct { 960 result1 []byte 961 result2 error 962 }) 963 } 964 fake.getPrivateDataReturnsOnCall[i] = struct { 965 result1 []byte 966 result2 error 967 }{result1, result2} 968 } 969 970 func (fake *TxSimulator) GetPrivateDataHash(arg1 string, arg2 string, arg3 string) ([]byte, error) { 971 fake.getPrivateDataHashMutex.Lock() 972 ret, specificReturn := fake.getPrivateDataHashReturnsOnCall[len(fake.getPrivateDataHashArgsForCall)] 973 fake.getPrivateDataHashArgsForCall = append(fake.getPrivateDataHashArgsForCall, struct { 974 arg1 string 975 arg2 string 976 arg3 string 977 }{arg1, arg2, arg3}) 978 fake.recordInvocation("GetPrivateDataHash", []interface{}{arg1, arg2, arg3}) 979 fake.getPrivateDataHashMutex.Unlock() 980 if fake.GetPrivateDataHashStub != nil { 981 return fake.GetPrivateDataHashStub(arg1, arg2, arg3) 982 } 983 if specificReturn { 984 return ret.result1, ret.result2 985 } 986 fakeReturns := fake.getPrivateDataHashReturns 987 return fakeReturns.result1, fakeReturns.result2 988 } 989 990 func (fake *TxSimulator) GetPrivateDataHashCallCount() int { 991 fake.getPrivateDataHashMutex.RLock() 992 defer fake.getPrivateDataHashMutex.RUnlock() 993 return len(fake.getPrivateDataHashArgsForCall) 994 } 995 996 func (fake *TxSimulator) GetPrivateDataHashCalls(stub func(string, string, string) ([]byte, error)) { 997 fake.getPrivateDataHashMutex.Lock() 998 defer fake.getPrivateDataHashMutex.Unlock() 999 fake.GetPrivateDataHashStub = stub 1000 } 1001 1002 func (fake *TxSimulator) GetPrivateDataHashArgsForCall(i int) (string, string, string) { 1003 fake.getPrivateDataHashMutex.RLock() 1004 defer fake.getPrivateDataHashMutex.RUnlock() 1005 argsForCall := fake.getPrivateDataHashArgsForCall[i] 1006 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 1007 } 1008 1009 func (fake *TxSimulator) GetPrivateDataHashReturns(result1 []byte, result2 error) { 1010 fake.getPrivateDataHashMutex.Lock() 1011 defer fake.getPrivateDataHashMutex.Unlock() 1012 fake.GetPrivateDataHashStub = nil 1013 fake.getPrivateDataHashReturns = struct { 1014 result1 []byte 1015 result2 error 1016 }{result1, result2} 1017 } 1018 1019 func (fake *TxSimulator) GetPrivateDataHashReturnsOnCall(i int, result1 []byte, result2 error) { 1020 fake.getPrivateDataHashMutex.Lock() 1021 defer fake.getPrivateDataHashMutex.Unlock() 1022 fake.GetPrivateDataHashStub = nil 1023 if fake.getPrivateDataHashReturnsOnCall == nil { 1024 fake.getPrivateDataHashReturnsOnCall = make(map[int]struct { 1025 result1 []byte 1026 result2 error 1027 }) 1028 } 1029 fake.getPrivateDataHashReturnsOnCall[i] = struct { 1030 result1 []byte 1031 result2 error 1032 }{result1, result2} 1033 } 1034 1035 func (fake *TxSimulator) GetPrivateDataMetadata(arg1 string, arg2 string, arg3 string) (map[string][]byte, error) { 1036 fake.getPrivateDataMetadataMutex.Lock() 1037 ret, specificReturn := fake.getPrivateDataMetadataReturnsOnCall[len(fake.getPrivateDataMetadataArgsForCall)] 1038 fake.getPrivateDataMetadataArgsForCall = append(fake.getPrivateDataMetadataArgsForCall, struct { 1039 arg1 string 1040 arg2 string 1041 arg3 string 1042 }{arg1, arg2, arg3}) 1043 fake.recordInvocation("GetPrivateDataMetadata", []interface{}{arg1, arg2, arg3}) 1044 fake.getPrivateDataMetadataMutex.Unlock() 1045 if fake.GetPrivateDataMetadataStub != nil { 1046 return fake.GetPrivateDataMetadataStub(arg1, arg2, arg3) 1047 } 1048 if specificReturn { 1049 return ret.result1, ret.result2 1050 } 1051 fakeReturns := fake.getPrivateDataMetadataReturns 1052 return fakeReturns.result1, fakeReturns.result2 1053 } 1054 1055 func (fake *TxSimulator) GetPrivateDataMetadataCallCount() int { 1056 fake.getPrivateDataMetadataMutex.RLock() 1057 defer fake.getPrivateDataMetadataMutex.RUnlock() 1058 return len(fake.getPrivateDataMetadataArgsForCall) 1059 } 1060 1061 func (fake *TxSimulator) GetPrivateDataMetadataCalls(stub func(string, string, string) (map[string][]byte, error)) { 1062 fake.getPrivateDataMetadataMutex.Lock() 1063 defer fake.getPrivateDataMetadataMutex.Unlock() 1064 fake.GetPrivateDataMetadataStub = stub 1065 } 1066 1067 func (fake *TxSimulator) GetPrivateDataMetadataArgsForCall(i int) (string, string, string) { 1068 fake.getPrivateDataMetadataMutex.RLock() 1069 defer fake.getPrivateDataMetadataMutex.RUnlock() 1070 argsForCall := fake.getPrivateDataMetadataArgsForCall[i] 1071 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 1072 } 1073 1074 func (fake *TxSimulator) GetPrivateDataMetadataReturns(result1 map[string][]byte, result2 error) { 1075 fake.getPrivateDataMetadataMutex.Lock() 1076 defer fake.getPrivateDataMetadataMutex.Unlock() 1077 fake.GetPrivateDataMetadataStub = nil 1078 fake.getPrivateDataMetadataReturns = struct { 1079 result1 map[string][]byte 1080 result2 error 1081 }{result1, result2} 1082 } 1083 1084 func (fake *TxSimulator) GetPrivateDataMetadataReturnsOnCall(i int, result1 map[string][]byte, result2 error) { 1085 fake.getPrivateDataMetadataMutex.Lock() 1086 defer fake.getPrivateDataMetadataMutex.Unlock() 1087 fake.GetPrivateDataMetadataStub = nil 1088 if fake.getPrivateDataMetadataReturnsOnCall == nil { 1089 fake.getPrivateDataMetadataReturnsOnCall = make(map[int]struct { 1090 result1 map[string][]byte 1091 result2 error 1092 }) 1093 } 1094 fake.getPrivateDataMetadataReturnsOnCall[i] = struct { 1095 result1 map[string][]byte 1096 result2 error 1097 }{result1, result2} 1098 } 1099 1100 func (fake *TxSimulator) GetPrivateDataMetadataByHash(arg1 string, arg2 string, arg3 []byte) (map[string][]byte, error) { 1101 var arg3Copy []byte 1102 if arg3 != nil { 1103 arg3Copy = make([]byte, len(arg3)) 1104 copy(arg3Copy, arg3) 1105 } 1106 fake.getPrivateDataMetadataByHashMutex.Lock() 1107 ret, specificReturn := fake.getPrivateDataMetadataByHashReturnsOnCall[len(fake.getPrivateDataMetadataByHashArgsForCall)] 1108 fake.getPrivateDataMetadataByHashArgsForCall = append(fake.getPrivateDataMetadataByHashArgsForCall, struct { 1109 arg1 string 1110 arg2 string 1111 arg3 []byte 1112 }{arg1, arg2, arg3Copy}) 1113 fake.recordInvocation("GetPrivateDataMetadataByHash", []interface{}{arg1, arg2, arg3Copy}) 1114 fake.getPrivateDataMetadataByHashMutex.Unlock() 1115 if fake.GetPrivateDataMetadataByHashStub != nil { 1116 return fake.GetPrivateDataMetadataByHashStub(arg1, arg2, arg3) 1117 } 1118 if specificReturn { 1119 return ret.result1, ret.result2 1120 } 1121 fakeReturns := fake.getPrivateDataMetadataByHashReturns 1122 return fakeReturns.result1, fakeReturns.result2 1123 } 1124 1125 func (fake *TxSimulator) GetPrivateDataMetadataByHashCallCount() int { 1126 fake.getPrivateDataMetadataByHashMutex.RLock() 1127 defer fake.getPrivateDataMetadataByHashMutex.RUnlock() 1128 return len(fake.getPrivateDataMetadataByHashArgsForCall) 1129 } 1130 1131 func (fake *TxSimulator) GetPrivateDataMetadataByHashCalls(stub func(string, string, []byte) (map[string][]byte, error)) { 1132 fake.getPrivateDataMetadataByHashMutex.Lock() 1133 defer fake.getPrivateDataMetadataByHashMutex.Unlock() 1134 fake.GetPrivateDataMetadataByHashStub = stub 1135 } 1136 1137 func (fake *TxSimulator) GetPrivateDataMetadataByHashArgsForCall(i int) (string, string, []byte) { 1138 fake.getPrivateDataMetadataByHashMutex.RLock() 1139 defer fake.getPrivateDataMetadataByHashMutex.RUnlock() 1140 argsForCall := fake.getPrivateDataMetadataByHashArgsForCall[i] 1141 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 1142 } 1143 1144 func (fake *TxSimulator) GetPrivateDataMetadataByHashReturns(result1 map[string][]byte, result2 error) { 1145 fake.getPrivateDataMetadataByHashMutex.Lock() 1146 defer fake.getPrivateDataMetadataByHashMutex.Unlock() 1147 fake.GetPrivateDataMetadataByHashStub = nil 1148 fake.getPrivateDataMetadataByHashReturns = struct { 1149 result1 map[string][]byte 1150 result2 error 1151 }{result1, result2} 1152 } 1153 1154 func (fake *TxSimulator) GetPrivateDataMetadataByHashReturnsOnCall(i int, result1 map[string][]byte, result2 error) { 1155 fake.getPrivateDataMetadataByHashMutex.Lock() 1156 defer fake.getPrivateDataMetadataByHashMutex.Unlock() 1157 fake.GetPrivateDataMetadataByHashStub = nil 1158 if fake.getPrivateDataMetadataByHashReturnsOnCall == nil { 1159 fake.getPrivateDataMetadataByHashReturnsOnCall = make(map[int]struct { 1160 result1 map[string][]byte 1161 result2 error 1162 }) 1163 } 1164 fake.getPrivateDataMetadataByHashReturnsOnCall[i] = struct { 1165 result1 map[string][]byte 1166 result2 error 1167 }{result1, result2} 1168 } 1169 1170 func (fake *TxSimulator) GetPrivateDataMultipleKeys(arg1 string, arg2 string, arg3 []string) ([][]byte, error) { 1171 var arg3Copy []string 1172 if arg3 != nil { 1173 arg3Copy = make([]string, len(arg3)) 1174 copy(arg3Copy, arg3) 1175 } 1176 fake.getPrivateDataMultipleKeysMutex.Lock() 1177 ret, specificReturn := fake.getPrivateDataMultipleKeysReturnsOnCall[len(fake.getPrivateDataMultipleKeysArgsForCall)] 1178 fake.getPrivateDataMultipleKeysArgsForCall = append(fake.getPrivateDataMultipleKeysArgsForCall, struct { 1179 arg1 string 1180 arg2 string 1181 arg3 []string 1182 }{arg1, arg2, arg3Copy}) 1183 fake.recordInvocation("GetPrivateDataMultipleKeys", []interface{}{arg1, arg2, arg3Copy}) 1184 fake.getPrivateDataMultipleKeysMutex.Unlock() 1185 if fake.GetPrivateDataMultipleKeysStub != nil { 1186 return fake.GetPrivateDataMultipleKeysStub(arg1, arg2, arg3) 1187 } 1188 if specificReturn { 1189 return ret.result1, ret.result2 1190 } 1191 fakeReturns := fake.getPrivateDataMultipleKeysReturns 1192 return fakeReturns.result1, fakeReturns.result2 1193 } 1194 1195 func (fake *TxSimulator) GetPrivateDataMultipleKeysCallCount() int { 1196 fake.getPrivateDataMultipleKeysMutex.RLock() 1197 defer fake.getPrivateDataMultipleKeysMutex.RUnlock() 1198 return len(fake.getPrivateDataMultipleKeysArgsForCall) 1199 } 1200 1201 func (fake *TxSimulator) GetPrivateDataMultipleKeysCalls(stub func(string, string, []string) ([][]byte, error)) { 1202 fake.getPrivateDataMultipleKeysMutex.Lock() 1203 defer fake.getPrivateDataMultipleKeysMutex.Unlock() 1204 fake.GetPrivateDataMultipleKeysStub = stub 1205 } 1206 1207 func (fake *TxSimulator) GetPrivateDataMultipleKeysArgsForCall(i int) (string, string, []string) { 1208 fake.getPrivateDataMultipleKeysMutex.RLock() 1209 defer fake.getPrivateDataMultipleKeysMutex.RUnlock() 1210 argsForCall := fake.getPrivateDataMultipleKeysArgsForCall[i] 1211 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 1212 } 1213 1214 func (fake *TxSimulator) GetPrivateDataMultipleKeysReturns(result1 [][]byte, result2 error) { 1215 fake.getPrivateDataMultipleKeysMutex.Lock() 1216 defer fake.getPrivateDataMultipleKeysMutex.Unlock() 1217 fake.GetPrivateDataMultipleKeysStub = nil 1218 fake.getPrivateDataMultipleKeysReturns = struct { 1219 result1 [][]byte 1220 result2 error 1221 }{result1, result2} 1222 } 1223 1224 func (fake *TxSimulator) GetPrivateDataMultipleKeysReturnsOnCall(i int, result1 [][]byte, result2 error) { 1225 fake.getPrivateDataMultipleKeysMutex.Lock() 1226 defer fake.getPrivateDataMultipleKeysMutex.Unlock() 1227 fake.GetPrivateDataMultipleKeysStub = nil 1228 if fake.getPrivateDataMultipleKeysReturnsOnCall == nil { 1229 fake.getPrivateDataMultipleKeysReturnsOnCall = make(map[int]struct { 1230 result1 [][]byte 1231 result2 error 1232 }) 1233 } 1234 fake.getPrivateDataMultipleKeysReturnsOnCall[i] = struct { 1235 result1 [][]byte 1236 result2 error 1237 }{result1, result2} 1238 } 1239 1240 func (fake *TxSimulator) GetPrivateDataRangeScanIterator(arg1 string, arg2 string, arg3 string, arg4 string) (ledger.ResultsIterator, error) { 1241 fake.getPrivateDataRangeScanIteratorMutex.Lock() 1242 ret, specificReturn := fake.getPrivateDataRangeScanIteratorReturnsOnCall[len(fake.getPrivateDataRangeScanIteratorArgsForCall)] 1243 fake.getPrivateDataRangeScanIteratorArgsForCall = append(fake.getPrivateDataRangeScanIteratorArgsForCall, struct { 1244 arg1 string 1245 arg2 string 1246 arg3 string 1247 arg4 string 1248 }{arg1, arg2, arg3, arg4}) 1249 fake.recordInvocation("GetPrivateDataRangeScanIterator", []interface{}{arg1, arg2, arg3, arg4}) 1250 fake.getPrivateDataRangeScanIteratorMutex.Unlock() 1251 if fake.GetPrivateDataRangeScanIteratorStub != nil { 1252 return fake.GetPrivateDataRangeScanIteratorStub(arg1, arg2, arg3, arg4) 1253 } 1254 if specificReturn { 1255 return ret.result1, ret.result2 1256 } 1257 fakeReturns := fake.getPrivateDataRangeScanIteratorReturns 1258 return fakeReturns.result1, fakeReturns.result2 1259 } 1260 1261 func (fake *TxSimulator) GetPrivateDataRangeScanIteratorCallCount() int { 1262 fake.getPrivateDataRangeScanIteratorMutex.RLock() 1263 defer fake.getPrivateDataRangeScanIteratorMutex.RUnlock() 1264 return len(fake.getPrivateDataRangeScanIteratorArgsForCall) 1265 } 1266 1267 func (fake *TxSimulator) GetPrivateDataRangeScanIteratorCalls(stub func(string, string, string, string) (ledger.ResultsIterator, error)) { 1268 fake.getPrivateDataRangeScanIteratorMutex.Lock() 1269 defer fake.getPrivateDataRangeScanIteratorMutex.Unlock() 1270 fake.GetPrivateDataRangeScanIteratorStub = stub 1271 } 1272 1273 func (fake *TxSimulator) GetPrivateDataRangeScanIteratorArgsForCall(i int) (string, string, string, string) { 1274 fake.getPrivateDataRangeScanIteratorMutex.RLock() 1275 defer fake.getPrivateDataRangeScanIteratorMutex.RUnlock() 1276 argsForCall := fake.getPrivateDataRangeScanIteratorArgsForCall[i] 1277 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 1278 } 1279 1280 func (fake *TxSimulator) GetPrivateDataRangeScanIteratorReturns(result1 ledger.ResultsIterator, result2 error) { 1281 fake.getPrivateDataRangeScanIteratorMutex.Lock() 1282 defer fake.getPrivateDataRangeScanIteratorMutex.Unlock() 1283 fake.GetPrivateDataRangeScanIteratorStub = nil 1284 fake.getPrivateDataRangeScanIteratorReturns = struct { 1285 result1 ledger.ResultsIterator 1286 result2 error 1287 }{result1, result2} 1288 } 1289 1290 func (fake *TxSimulator) GetPrivateDataRangeScanIteratorReturnsOnCall(i int, result1 ledger.ResultsIterator, result2 error) { 1291 fake.getPrivateDataRangeScanIteratorMutex.Lock() 1292 defer fake.getPrivateDataRangeScanIteratorMutex.Unlock() 1293 fake.GetPrivateDataRangeScanIteratorStub = nil 1294 if fake.getPrivateDataRangeScanIteratorReturnsOnCall == nil { 1295 fake.getPrivateDataRangeScanIteratorReturnsOnCall = make(map[int]struct { 1296 result1 ledger.ResultsIterator 1297 result2 error 1298 }) 1299 } 1300 fake.getPrivateDataRangeScanIteratorReturnsOnCall[i] = struct { 1301 result1 ledger.ResultsIterator 1302 result2 error 1303 }{result1, result2} 1304 } 1305 1306 func (fake *TxSimulator) GetState(arg1 string, arg2 string) ([]byte, error) { 1307 fake.getStateMutex.Lock() 1308 ret, specificReturn := fake.getStateReturnsOnCall[len(fake.getStateArgsForCall)] 1309 fake.getStateArgsForCall = append(fake.getStateArgsForCall, struct { 1310 arg1 string 1311 arg2 string 1312 }{arg1, arg2}) 1313 fake.recordInvocation("GetState", []interface{}{arg1, arg2}) 1314 fake.getStateMutex.Unlock() 1315 if fake.GetStateStub != nil { 1316 return fake.GetStateStub(arg1, arg2) 1317 } 1318 if specificReturn { 1319 return ret.result1, ret.result2 1320 } 1321 fakeReturns := fake.getStateReturns 1322 return fakeReturns.result1, fakeReturns.result2 1323 } 1324 1325 func (fake *TxSimulator) GetStateCallCount() int { 1326 fake.getStateMutex.RLock() 1327 defer fake.getStateMutex.RUnlock() 1328 return len(fake.getStateArgsForCall) 1329 } 1330 1331 func (fake *TxSimulator) GetStateCalls(stub func(string, string) ([]byte, error)) { 1332 fake.getStateMutex.Lock() 1333 defer fake.getStateMutex.Unlock() 1334 fake.GetStateStub = stub 1335 } 1336 1337 func (fake *TxSimulator) GetStateArgsForCall(i int) (string, string) { 1338 fake.getStateMutex.RLock() 1339 defer fake.getStateMutex.RUnlock() 1340 argsForCall := fake.getStateArgsForCall[i] 1341 return argsForCall.arg1, argsForCall.arg2 1342 } 1343 1344 func (fake *TxSimulator) GetStateReturns(result1 []byte, result2 error) { 1345 fake.getStateMutex.Lock() 1346 defer fake.getStateMutex.Unlock() 1347 fake.GetStateStub = nil 1348 fake.getStateReturns = struct { 1349 result1 []byte 1350 result2 error 1351 }{result1, result2} 1352 } 1353 1354 func (fake *TxSimulator) GetStateReturnsOnCall(i int, result1 []byte, result2 error) { 1355 fake.getStateMutex.Lock() 1356 defer fake.getStateMutex.Unlock() 1357 fake.GetStateStub = nil 1358 if fake.getStateReturnsOnCall == nil { 1359 fake.getStateReturnsOnCall = make(map[int]struct { 1360 result1 []byte 1361 result2 error 1362 }) 1363 } 1364 fake.getStateReturnsOnCall[i] = struct { 1365 result1 []byte 1366 result2 error 1367 }{result1, result2} 1368 } 1369 1370 func (fake *TxSimulator) GetStateMetadata(arg1 string, arg2 string) (map[string][]byte, error) { 1371 fake.getStateMetadataMutex.Lock() 1372 ret, specificReturn := fake.getStateMetadataReturnsOnCall[len(fake.getStateMetadataArgsForCall)] 1373 fake.getStateMetadataArgsForCall = append(fake.getStateMetadataArgsForCall, struct { 1374 arg1 string 1375 arg2 string 1376 }{arg1, arg2}) 1377 fake.recordInvocation("GetStateMetadata", []interface{}{arg1, arg2}) 1378 fake.getStateMetadataMutex.Unlock() 1379 if fake.GetStateMetadataStub != nil { 1380 return fake.GetStateMetadataStub(arg1, arg2) 1381 } 1382 if specificReturn { 1383 return ret.result1, ret.result2 1384 } 1385 fakeReturns := fake.getStateMetadataReturns 1386 return fakeReturns.result1, fakeReturns.result2 1387 } 1388 1389 func (fake *TxSimulator) GetStateMetadataCallCount() int { 1390 fake.getStateMetadataMutex.RLock() 1391 defer fake.getStateMetadataMutex.RUnlock() 1392 return len(fake.getStateMetadataArgsForCall) 1393 } 1394 1395 func (fake *TxSimulator) GetStateMetadataCalls(stub func(string, string) (map[string][]byte, error)) { 1396 fake.getStateMetadataMutex.Lock() 1397 defer fake.getStateMetadataMutex.Unlock() 1398 fake.GetStateMetadataStub = stub 1399 } 1400 1401 func (fake *TxSimulator) GetStateMetadataArgsForCall(i int) (string, string) { 1402 fake.getStateMetadataMutex.RLock() 1403 defer fake.getStateMetadataMutex.RUnlock() 1404 argsForCall := fake.getStateMetadataArgsForCall[i] 1405 return argsForCall.arg1, argsForCall.arg2 1406 } 1407 1408 func (fake *TxSimulator) GetStateMetadataReturns(result1 map[string][]byte, result2 error) { 1409 fake.getStateMetadataMutex.Lock() 1410 defer fake.getStateMetadataMutex.Unlock() 1411 fake.GetStateMetadataStub = nil 1412 fake.getStateMetadataReturns = struct { 1413 result1 map[string][]byte 1414 result2 error 1415 }{result1, result2} 1416 } 1417 1418 func (fake *TxSimulator) GetStateMetadataReturnsOnCall(i int, result1 map[string][]byte, result2 error) { 1419 fake.getStateMetadataMutex.Lock() 1420 defer fake.getStateMetadataMutex.Unlock() 1421 fake.GetStateMetadataStub = nil 1422 if fake.getStateMetadataReturnsOnCall == nil { 1423 fake.getStateMetadataReturnsOnCall = make(map[int]struct { 1424 result1 map[string][]byte 1425 result2 error 1426 }) 1427 } 1428 fake.getStateMetadataReturnsOnCall[i] = struct { 1429 result1 map[string][]byte 1430 result2 error 1431 }{result1, result2} 1432 } 1433 1434 func (fake *TxSimulator) GetStateMultipleKeys(arg1 string, arg2 []string) ([][]byte, error) { 1435 var arg2Copy []string 1436 if arg2 != nil { 1437 arg2Copy = make([]string, len(arg2)) 1438 copy(arg2Copy, arg2) 1439 } 1440 fake.getStateMultipleKeysMutex.Lock() 1441 ret, specificReturn := fake.getStateMultipleKeysReturnsOnCall[len(fake.getStateMultipleKeysArgsForCall)] 1442 fake.getStateMultipleKeysArgsForCall = append(fake.getStateMultipleKeysArgsForCall, struct { 1443 arg1 string 1444 arg2 []string 1445 }{arg1, arg2Copy}) 1446 fake.recordInvocation("GetStateMultipleKeys", []interface{}{arg1, arg2Copy}) 1447 fake.getStateMultipleKeysMutex.Unlock() 1448 if fake.GetStateMultipleKeysStub != nil { 1449 return fake.GetStateMultipleKeysStub(arg1, arg2) 1450 } 1451 if specificReturn { 1452 return ret.result1, ret.result2 1453 } 1454 fakeReturns := fake.getStateMultipleKeysReturns 1455 return fakeReturns.result1, fakeReturns.result2 1456 } 1457 1458 func (fake *TxSimulator) GetStateMultipleKeysCallCount() int { 1459 fake.getStateMultipleKeysMutex.RLock() 1460 defer fake.getStateMultipleKeysMutex.RUnlock() 1461 return len(fake.getStateMultipleKeysArgsForCall) 1462 } 1463 1464 func (fake *TxSimulator) GetStateMultipleKeysCalls(stub func(string, []string) ([][]byte, error)) { 1465 fake.getStateMultipleKeysMutex.Lock() 1466 defer fake.getStateMultipleKeysMutex.Unlock() 1467 fake.GetStateMultipleKeysStub = stub 1468 } 1469 1470 func (fake *TxSimulator) GetStateMultipleKeysArgsForCall(i int) (string, []string) { 1471 fake.getStateMultipleKeysMutex.RLock() 1472 defer fake.getStateMultipleKeysMutex.RUnlock() 1473 argsForCall := fake.getStateMultipleKeysArgsForCall[i] 1474 return argsForCall.arg1, argsForCall.arg2 1475 } 1476 1477 func (fake *TxSimulator) GetStateMultipleKeysReturns(result1 [][]byte, result2 error) { 1478 fake.getStateMultipleKeysMutex.Lock() 1479 defer fake.getStateMultipleKeysMutex.Unlock() 1480 fake.GetStateMultipleKeysStub = nil 1481 fake.getStateMultipleKeysReturns = struct { 1482 result1 [][]byte 1483 result2 error 1484 }{result1, result2} 1485 } 1486 1487 func (fake *TxSimulator) GetStateMultipleKeysReturnsOnCall(i int, result1 [][]byte, result2 error) { 1488 fake.getStateMultipleKeysMutex.Lock() 1489 defer fake.getStateMultipleKeysMutex.Unlock() 1490 fake.GetStateMultipleKeysStub = nil 1491 if fake.getStateMultipleKeysReturnsOnCall == nil { 1492 fake.getStateMultipleKeysReturnsOnCall = make(map[int]struct { 1493 result1 [][]byte 1494 result2 error 1495 }) 1496 } 1497 fake.getStateMultipleKeysReturnsOnCall[i] = struct { 1498 result1 [][]byte 1499 result2 error 1500 }{result1, result2} 1501 } 1502 1503 func (fake *TxSimulator) GetStateRangeScanIterator(arg1 string, arg2 string, arg3 string) (ledger.ResultsIterator, error) { 1504 fake.getStateRangeScanIteratorMutex.Lock() 1505 ret, specificReturn := fake.getStateRangeScanIteratorReturnsOnCall[len(fake.getStateRangeScanIteratorArgsForCall)] 1506 fake.getStateRangeScanIteratorArgsForCall = append(fake.getStateRangeScanIteratorArgsForCall, struct { 1507 arg1 string 1508 arg2 string 1509 arg3 string 1510 }{arg1, arg2, arg3}) 1511 fake.recordInvocation("GetStateRangeScanIterator", []interface{}{arg1, arg2, arg3}) 1512 fake.getStateRangeScanIteratorMutex.Unlock() 1513 if fake.GetStateRangeScanIteratorStub != nil { 1514 return fake.GetStateRangeScanIteratorStub(arg1, arg2, arg3) 1515 } 1516 if specificReturn { 1517 return ret.result1, ret.result2 1518 } 1519 fakeReturns := fake.getStateRangeScanIteratorReturns 1520 return fakeReturns.result1, fakeReturns.result2 1521 } 1522 1523 func (fake *TxSimulator) GetStateRangeScanIteratorCallCount() int { 1524 fake.getStateRangeScanIteratorMutex.RLock() 1525 defer fake.getStateRangeScanIteratorMutex.RUnlock() 1526 return len(fake.getStateRangeScanIteratorArgsForCall) 1527 } 1528 1529 func (fake *TxSimulator) GetStateRangeScanIteratorCalls(stub func(string, string, string) (ledger.ResultsIterator, error)) { 1530 fake.getStateRangeScanIteratorMutex.Lock() 1531 defer fake.getStateRangeScanIteratorMutex.Unlock() 1532 fake.GetStateRangeScanIteratorStub = stub 1533 } 1534 1535 func (fake *TxSimulator) GetStateRangeScanIteratorArgsForCall(i int) (string, string, string) { 1536 fake.getStateRangeScanIteratorMutex.RLock() 1537 defer fake.getStateRangeScanIteratorMutex.RUnlock() 1538 argsForCall := fake.getStateRangeScanIteratorArgsForCall[i] 1539 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 1540 } 1541 1542 func (fake *TxSimulator) GetStateRangeScanIteratorReturns(result1 ledger.ResultsIterator, result2 error) { 1543 fake.getStateRangeScanIteratorMutex.Lock() 1544 defer fake.getStateRangeScanIteratorMutex.Unlock() 1545 fake.GetStateRangeScanIteratorStub = nil 1546 fake.getStateRangeScanIteratorReturns = struct { 1547 result1 ledger.ResultsIterator 1548 result2 error 1549 }{result1, result2} 1550 } 1551 1552 func (fake *TxSimulator) GetStateRangeScanIteratorReturnsOnCall(i int, result1 ledger.ResultsIterator, result2 error) { 1553 fake.getStateRangeScanIteratorMutex.Lock() 1554 defer fake.getStateRangeScanIteratorMutex.Unlock() 1555 fake.GetStateRangeScanIteratorStub = nil 1556 if fake.getStateRangeScanIteratorReturnsOnCall == nil { 1557 fake.getStateRangeScanIteratorReturnsOnCall = make(map[int]struct { 1558 result1 ledger.ResultsIterator 1559 result2 error 1560 }) 1561 } 1562 fake.getStateRangeScanIteratorReturnsOnCall[i] = struct { 1563 result1 ledger.ResultsIterator 1564 result2 error 1565 }{result1, result2} 1566 } 1567 1568 func (fake *TxSimulator) GetStateRangeScanIteratorWithPagination(arg1 string, arg2 string, arg3 string, arg4 int32) (ledgera.QueryResultsIterator, error) { 1569 fake.getStateRangeScanIteratorWithPaginationMutex.Lock() 1570 ret, specificReturn := fake.getStateRangeScanIteratorWithPaginationReturnsOnCall[len(fake.getStateRangeScanIteratorWithPaginationArgsForCall)] 1571 fake.getStateRangeScanIteratorWithPaginationArgsForCall = append(fake.getStateRangeScanIteratorWithPaginationArgsForCall, struct { 1572 arg1 string 1573 arg2 string 1574 arg3 string 1575 arg4 int32 1576 }{arg1, arg2, arg3, arg4}) 1577 fake.recordInvocation("GetStateRangeScanIteratorWithPagination", []interface{}{arg1, arg2, arg3, arg4}) 1578 fake.getStateRangeScanIteratorWithPaginationMutex.Unlock() 1579 if fake.GetStateRangeScanIteratorWithPaginationStub != nil { 1580 return fake.GetStateRangeScanIteratorWithPaginationStub(arg1, arg2, arg3, arg4) 1581 } 1582 if specificReturn { 1583 return ret.result1, ret.result2 1584 } 1585 fakeReturns := fake.getStateRangeScanIteratorWithPaginationReturns 1586 return fakeReturns.result1, fakeReturns.result2 1587 } 1588 1589 func (fake *TxSimulator) GetStateRangeScanIteratorWithPaginationCallCount() int { 1590 fake.getStateRangeScanIteratorWithPaginationMutex.RLock() 1591 defer fake.getStateRangeScanIteratorWithPaginationMutex.RUnlock() 1592 return len(fake.getStateRangeScanIteratorWithPaginationArgsForCall) 1593 } 1594 1595 func (fake *TxSimulator) GetStateRangeScanIteratorWithPaginationCalls(stub func(string, string, string, int32) (ledgera.QueryResultsIterator, error)) { 1596 fake.getStateRangeScanIteratorWithPaginationMutex.Lock() 1597 defer fake.getStateRangeScanIteratorWithPaginationMutex.Unlock() 1598 fake.GetStateRangeScanIteratorWithPaginationStub = stub 1599 } 1600 1601 func (fake *TxSimulator) GetStateRangeScanIteratorWithPaginationArgsForCall(i int) (string, string, string, int32) { 1602 fake.getStateRangeScanIteratorWithPaginationMutex.RLock() 1603 defer fake.getStateRangeScanIteratorWithPaginationMutex.RUnlock() 1604 argsForCall := fake.getStateRangeScanIteratorWithPaginationArgsForCall[i] 1605 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 1606 } 1607 1608 func (fake *TxSimulator) GetStateRangeScanIteratorWithPaginationReturns(result1 ledgera.QueryResultsIterator, result2 error) { 1609 fake.getStateRangeScanIteratorWithPaginationMutex.Lock() 1610 defer fake.getStateRangeScanIteratorWithPaginationMutex.Unlock() 1611 fake.GetStateRangeScanIteratorWithPaginationStub = nil 1612 fake.getStateRangeScanIteratorWithPaginationReturns = struct { 1613 result1 ledgera.QueryResultsIterator 1614 result2 error 1615 }{result1, result2} 1616 } 1617 1618 func (fake *TxSimulator) GetStateRangeScanIteratorWithPaginationReturnsOnCall(i int, result1 ledgera.QueryResultsIterator, result2 error) { 1619 fake.getStateRangeScanIteratorWithPaginationMutex.Lock() 1620 defer fake.getStateRangeScanIteratorWithPaginationMutex.Unlock() 1621 fake.GetStateRangeScanIteratorWithPaginationStub = nil 1622 if fake.getStateRangeScanIteratorWithPaginationReturnsOnCall == nil { 1623 fake.getStateRangeScanIteratorWithPaginationReturnsOnCall = make(map[int]struct { 1624 result1 ledgera.QueryResultsIterator 1625 result2 error 1626 }) 1627 } 1628 fake.getStateRangeScanIteratorWithPaginationReturnsOnCall[i] = struct { 1629 result1 ledgera.QueryResultsIterator 1630 result2 error 1631 }{result1, result2} 1632 } 1633 1634 func (fake *TxSimulator) GetTxSimulationResults() (*ledgera.TxSimulationResults, error) { 1635 fake.getTxSimulationResultsMutex.Lock() 1636 ret, specificReturn := fake.getTxSimulationResultsReturnsOnCall[len(fake.getTxSimulationResultsArgsForCall)] 1637 fake.getTxSimulationResultsArgsForCall = append(fake.getTxSimulationResultsArgsForCall, struct { 1638 }{}) 1639 fake.recordInvocation("GetTxSimulationResults", []interface{}{}) 1640 fake.getTxSimulationResultsMutex.Unlock() 1641 if fake.GetTxSimulationResultsStub != nil { 1642 return fake.GetTxSimulationResultsStub() 1643 } 1644 if specificReturn { 1645 return ret.result1, ret.result2 1646 } 1647 fakeReturns := fake.getTxSimulationResultsReturns 1648 return fakeReturns.result1, fakeReturns.result2 1649 } 1650 1651 func (fake *TxSimulator) GetTxSimulationResultsCallCount() int { 1652 fake.getTxSimulationResultsMutex.RLock() 1653 defer fake.getTxSimulationResultsMutex.RUnlock() 1654 return len(fake.getTxSimulationResultsArgsForCall) 1655 } 1656 1657 func (fake *TxSimulator) GetTxSimulationResultsCalls(stub func() (*ledgera.TxSimulationResults, error)) { 1658 fake.getTxSimulationResultsMutex.Lock() 1659 defer fake.getTxSimulationResultsMutex.Unlock() 1660 fake.GetTxSimulationResultsStub = stub 1661 } 1662 1663 func (fake *TxSimulator) GetTxSimulationResultsReturns(result1 *ledgera.TxSimulationResults, result2 error) { 1664 fake.getTxSimulationResultsMutex.Lock() 1665 defer fake.getTxSimulationResultsMutex.Unlock() 1666 fake.GetTxSimulationResultsStub = nil 1667 fake.getTxSimulationResultsReturns = struct { 1668 result1 *ledgera.TxSimulationResults 1669 result2 error 1670 }{result1, result2} 1671 } 1672 1673 func (fake *TxSimulator) GetTxSimulationResultsReturnsOnCall(i int, result1 *ledgera.TxSimulationResults, result2 error) { 1674 fake.getTxSimulationResultsMutex.Lock() 1675 defer fake.getTxSimulationResultsMutex.Unlock() 1676 fake.GetTxSimulationResultsStub = nil 1677 if fake.getTxSimulationResultsReturnsOnCall == nil { 1678 fake.getTxSimulationResultsReturnsOnCall = make(map[int]struct { 1679 result1 *ledgera.TxSimulationResults 1680 result2 error 1681 }) 1682 } 1683 fake.getTxSimulationResultsReturnsOnCall[i] = struct { 1684 result1 *ledgera.TxSimulationResults 1685 result2 error 1686 }{result1, result2} 1687 } 1688 1689 func (fake *TxSimulator) SetPrivateData(arg1 string, arg2 string, arg3 string, arg4 []byte) error { 1690 var arg4Copy []byte 1691 if arg4 != nil { 1692 arg4Copy = make([]byte, len(arg4)) 1693 copy(arg4Copy, arg4) 1694 } 1695 fake.setPrivateDataMutex.Lock() 1696 ret, specificReturn := fake.setPrivateDataReturnsOnCall[len(fake.setPrivateDataArgsForCall)] 1697 fake.setPrivateDataArgsForCall = append(fake.setPrivateDataArgsForCall, struct { 1698 arg1 string 1699 arg2 string 1700 arg3 string 1701 arg4 []byte 1702 }{arg1, arg2, arg3, arg4Copy}) 1703 fake.recordInvocation("SetPrivateData", []interface{}{arg1, arg2, arg3, arg4Copy}) 1704 fake.setPrivateDataMutex.Unlock() 1705 if fake.SetPrivateDataStub != nil { 1706 return fake.SetPrivateDataStub(arg1, arg2, arg3, arg4) 1707 } 1708 if specificReturn { 1709 return ret.result1 1710 } 1711 fakeReturns := fake.setPrivateDataReturns 1712 return fakeReturns.result1 1713 } 1714 1715 func (fake *TxSimulator) SetPrivateDataCallCount() int { 1716 fake.setPrivateDataMutex.RLock() 1717 defer fake.setPrivateDataMutex.RUnlock() 1718 return len(fake.setPrivateDataArgsForCall) 1719 } 1720 1721 func (fake *TxSimulator) SetPrivateDataCalls(stub func(string, string, string, []byte) error) { 1722 fake.setPrivateDataMutex.Lock() 1723 defer fake.setPrivateDataMutex.Unlock() 1724 fake.SetPrivateDataStub = stub 1725 } 1726 1727 func (fake *TxSimulator) SetPrivateDataArgsForCall(i int) (string, string, string, []byte) { 1728 fake.setPrivateDataMutex.RLock() 1729 defer fake.setPrivateDataMutex.RUnlock() 1730 argsForCall := fake.setPrivateDataArgsForCall[i] 1731 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 1732 } 1733 1734 func (fake *TxSimulator) SetPrivateDataReturns(result1 error) { 1735 fake.setPrivateDataMutex.Lock() 1736 defer fake.setPrivateDataMutex.Unlock() 1737 fake.SetPrivateDataStub = nil 1738 fake.setPrivateDataReturns = struct { 1739 result1 error 1740 }{result1} 1741 } 1742 1743 func (fake *TxSimulator) SetPrivateDataReturnsOnCall(i int, result1 error) { 1744 fake.setPrivateDataMutex.Lock() 1745 defer fake.setPrivateDataMutex.Unlock() 1746 fake.SetPrivateDataStub = nil 1747 if fake.setPrivateDataReturnsOnCall == nil { 1748 fake.setPrivateDataReturnsOnCall = make(map[int]struct { 1749 result1 error 1750 }) 1751 } 1752 fake.setPrivateDataReturnsOnCall[i] = struct { 1753 result1 error 1754 }{result1} 1755 } 1756 1757 func (fake *TxSimulator) SetPrivateDataMetadata(arg1 string, arg2 string, arg3 string, arg4 map[string][]byte) error { 1758 fake.setPrivateDataMetadataMutex.Lock() 1759 ret, specificReturn := fake.setPrivateDataMetadataReturnsOnCall[len(fake.setPrivateDataMetadataArgsForCall)] 1760 fake.setPrivateDataMetadataArgsForCall = append(fake.setPrivateDataMetadataArgsForCall, struct { 1761 arg1 string 1762 arg2 string 1763 arg3 string 1764 arg4 map[string][]byte 1765 }{arg1, arg2, arg3, arg4}) 1766 fake.recordInvocation("SetPrivateDataMetadata", []interface{}{arg1, arg2, arg3, arg4}) 1767 fake.setPrivateDataMetadataMutex.Unlock() 1768 if fake.SetPrivateDataMetadataStub != nil { 1769 return fake.SetPrivateDataMetadataStub(arg1, arg2, arg3, arg4) 1770 } 1771 if specificReturn { 1772 return ret.result1 1773 } 1774 fakeReturns := fake.setPrivateDataMetadataReturns 1775 return fakeReturns.result1 1776 } 1777 1778 func (fake *TxSimulator) SetPrivateDataMetadataCallCount() int { 1779 fake.setPrivateDataMetadataMutex.RLock() 1780 defer fake.setPrivateDataMetadataMutex.RUnlock() 1781 return len(fake.setPrivateDataMetadataArgsForCall) 1782 } 1783 1784 func (fake *TxSimulator) SetPrivateDataMetadataCalls(stub func(string, string, string, map[string][]byte) error) { 1785 fake.setPrivateDataMetadataMutex.Lock() 1786 defer fake.setPrivateDataMetadataMutex.Unlock() 1787 fake.SetPrivateDataMetadataStub = stub 1788 } 1789 1790 func (fake *TxSimulator) SetPrivateDataMetadataArgsForCall(i int) (string, string, string, map[string][]byte) { 1791 fake.setPrivateDataMetadataMutex.RLock() 1792 defer fake.setPrivateDataMetadataMutex.RUnlock() 1793 argsForCall := fake.setPrivateDataMetadataArgsForCall[i] 1794 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 1795 } 1796 1797 func (fake *TxSimulator) SetPrivateDataMetadataReturns(result1 error) { 1798 fake.setPrivateDataMetadataMutex.Lock() 1799 defer fake.setPrivateDataMetadataMutex.Unlock() 1800 fake.SetPrivateDataMetadataStub = nil 1801 fake.setPrivateDataMetadataReturns = struct { 1802 result1 error 1803 }{result1} 1804 } 1805 1806 func (fake *TxSimulator) SetPrivateDataMetadataReturnsOnCall(i int, result1 error) { 1807 fake.setPrivateDataMetadataMutex.Lock() 1808 defer fake.setPrivateDataMetadataMutex.Unlock() 1809 fake.SetPrivateDataMetadataStub = nil 1810 if fake.setPrivateDataMetadataReturnsOnCall == nil { 1811 fake.setPrivateDataMetadataReturnsOnCall = make(map[int]struct { 1812 result1 error 1813 }) 1814 } 1815 fake.setPrivateDataMetadataReturnsOnCall[i] = struct { 1816 result1 error 1817 }{result1} 1818 } 1819 1820 func (fake *TxSimulator) SetPrivateDataMultipleKeys(arg1 string, arg2 string, arg3 map[string][]byte) error { 1821 fake.setPrivateDataMultipleKeysMutex.Lock() 1822 ret, specificReturn := fake.setPrivateDataMultipleKeysReturnsOnCall[len(fake.setPrivateDataMultipleKeysArgsForCall)] 1823 fake.setPrivateDataMultipleKeysArgsForCall = append(fake.setPrivateDataMultipleKeysArgsForCall, struct { 1824 arg1 string 1825 arg2 string 1826 arg3 map[string][]byte 1827 }{arg1, arg2, arg3}) 1828 fake.recordInvocation("SetPrivateDataMultipleKeys", []interface{}{arg1, arg2, arg3}) 1829 fake.setPrivateDataMultipleKeysMutex.Unlock() 1830 if fake.SetPrivateDataMultipleKeysStub != nil { 1831 return fake.SetPrivateDataMultipleKeysStub(arg1, arg2, arg3) 1832 } 1833 if specificReturn { 1834 return ret.result1 1835 } 1836 fakeReturns := fake.setPrivateDataMultipleKeysReturns 1837 return fakeReturns.result1 1838 } 1839 1840 func (fake *TxSimulator) SetPrivateDataMultipleKeysCallCount() int { 1841 fake.setPrivateDataMultipleKeysMutex.RLock() 1842 defer fake.setPrivateDataMultipleKeysMutex.RUnlock() 1843 return len(fake.setPrivateDataMultipleKeysArgsForCall) 1844 } 1845 1846 func (fake *TxSimulator) SetPrivateDataMultipleKeysCalls(stub func(string, string, map[string][]byte) error) { 1847 fake.setPrivateDataMultipleKeysMutex.Lock() 1848 defer fake.setPrivateDataMultipleKeysMutex.Unlock() 1849 fake.SetPrivateDataMultipleKeysStub = stub 1850 } 1851 1852 func (fake *TxSimulator) SetPrivateDataMultipleKeysArgsForCall(i int) (string, string, map[string][]byte) { 1853 fake.setPrivateDataMultipleKeysMutex.RLock() 1854 defer fake.setPrivateDataMultipleKeysMutex.RUnlock() 1855 argsForCall := fake.setPrivateDataMultipleKeysArgsForCall[i] 1856 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 1857 } 1858 1859 func (fake *TxSimulator) SetPrivateDataMultipleKeysReturns(result1 error) { 1860 fake.setPrivateDataMultipleKeysMutex.Lock() 1861 defer fake.setPrivateDataMultipleKeysMutex.Unlock() 1862 fake.SetPrivateDataMultipleKeysStub = nil 1863 fake.setPrivateDataMultipleKeysReturns = struct { 1864 result1 error 1865 }{result1} 1866 } 1867 1868 func (fake *TxSimulator) SetPrivateDataMultipleKeysReturnsOnCall(i int, result1 error) { 1869 fake.setPrivateDataMultipleKeysMutex.Lock() 1870 defer fake.setPrivateDataMultipleKeysMutex.Unlock() 1871 fake.SetPrivateDataMultipleKeysStub = nil 1872 if fake.setPrivateDataMultipleKeysReturnsOnCall == nil { 1873 fake.setPrivateDataMultipleKeysReturnsOnCall = make(map[int]struct { 1874 result1 error 1875 }) 1876 } 1877 fake.setPrivateDataMultipleKeysReturnsOnCall[i] = struct { 1878 result1 error 1879 }{result1} 1880 } 1881 1882 func (fake *TxSimulator) SetState(arg1 string, arg2 string, arg3 []byte) error { 1883 var arg3Copy []byte 1884 if arg3 != nil { 1885 arg3Copy = make([]byte, len(arg3)) 1886 copy(arg3Copy, arg3) 1887 } 1888 fake.setStateMutex.Lock() 1889 ret, specificReturn := fake.setStateReturnsOnCall[len(fake.setStateArgsForCall)] 1890 fake.setStateArgsForCall = append(fake.setStateArgsForCall, struct { 1891 arg1 string 1892 arg2 string 1893 arg3 []byte 1894 }{arg1, arg2, arg3Copy}) 1895 fake.recordInvocation("SetState", []interface{}{arg1, arg2, arg3Copy}) 1896 fake.setStateMutex.Unlock() 1897 if fake.SetStateStub != nil { 1898 return fake.SetStateStub(arg1, arg2, arg3) 1899 } 1900 if specificReturn { 1901 return ret.result1 1902 } 1903 fakeReturns := fake.setStateReturns 1904 return fakeReturns.result1 1905 } 1906 1907 func (fake *TxSimulator) SetStateCallCount() int { 1908 fake.setStateMutex.RLock() 1909 defer fake.setStateMutex.RUnlock() 1910 return len(fake.setStateArgsForCall) 1911 } 1912 1913 func (fake *TxSimulator) SetStateCalls(stub func(string, string, []byte) error) { 1914 fake.setStateMutex.Lock() 1915 defer fake.setStateMutex.Unlock() 1916 fake.SetStateStub = stub 1917 } 1918 1919 func (fake *TxSimulator) SetStateArgsForCall(i int) (string, string, []byte) { 1920 fake.setStateMutex.RLock() 1921 defer fake.setStateMutex.RUnlock() 1922 argsForCall := fake.setStateArgsForCall[i] 1923 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 1924 } 1925 1926 func (fake *TxSimulator) SetStateReturns(result1 error) { 1927 fake.setStateMutex.Lock() 1928 defer fake.setStateMutex.Unlock() 1929 fake.SetStateStub = nil 1930 fake.setStateReturns = struct { 1931 result1 error 1932 }{result1} 1933 } 1934 1935 func (fake *TxSimulator) SetStateReturnsOnCall(i int, result1 error) { 1936 fake.setStateMutex.Lock() 1937 defer fake.setStateMutex.Unlock() 1938 fake.SetStateStub = nil 1939 if fake.setStateReturnsOnCall == nil { 1940 fake.setStateReturnsOnCall = make(map[int]struct { 1941 result1 error 1942 }) 1943 } 1944 fake.setStateReturnsOnCall[i] = struct { 1945 result1 error 1946 }{result1} 1947 } 1948 1949 func (fake *TxSimulator) SetStateMetadata(arg1 string, arg2 string, arg3 map[string][]byte) error { 1950 fake.setStateMetadataMutex.Lock() 1951 ret, specificReturn := fake.setStateMetadataReturnsOnCall[len(fake.setStateMetadataArgsForCall)] 1952 fake.setStateMetadataArgsForCall = append(fake.setStateMetadataArgsForCall, struct { 1953 arg1 string 1954 arg2 string 1955 arg3 map[string][]byte 1956 }{arg1, arg2, arg3}) 1957 fake.recordInvocation("SetStateMetadata", []interface{}{arg1, arg2, arg3}) 1958 fake.setStateMetadataMutex.Unlock() 1959 if fake.SetStateMetadataStub != nil { 1960 return fake.SetStateMetadataStub(arg1, arg2, arg3) 1961 } 1962 if specificReturn { 1963 return ret.result1 1964 } 1965 fakeReturns := fake.setStateMetadataReturns 1966 return fakeReturns.result1 1967 } 1968 1969 func (fake *TxSimulator) SetStateMetadataCallCount() int { 1970 fake.setStateMetadataMutex.RLock() 1971 defer fake.setStateMetadataMutex.RUnlock() 1972 return len(fake.setStateMetadataArgsForCall) 1973 } 1974 1975 func (fake *TxSimulator) SetStateMetadataCalls(stub func(string, string, map[string][]byte) error) { 1976 fake.setStateMetadataMutex.Lock() 1977 defer fake.setStateMetadataMutex.Unlock() 1978 fake.SetStateMetadataStub = stub 1979 } 1980 1981 func (fake *TxSimulator) SetStateMetadataArgsForCall(i int) (string, string, map[string][]byte) { 1982 fake.setStateMetadataMutex.RLock() 1983 defer fake.setStateMetadataMutex.RUnlock() 1984 argsForCall := fake.setStateMetadataArgsForCall[i] 1985 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 1986 } 1987 1988 func (fake *TxSimulator) SetStateMetadataReturns(result1 error) { 1989 fake.setStateMetadataMutex.Lock() 1990 defer fake.setStateMetadataMutex.Unlock() 1991 fake.SetStateMetadataStub = nil 1992 fake.setStateMetadataReturns = struct { 1993 result1 error 1994 }{result1} 1995 } 1996 1997 func (fake *TxSimulator) SetStateMetadataReturnsOnCall(i int, result1 error) { 1998 fake.setStateMetadataMutex.Lock() 1999 defer fake.setStateMetadataMutex.Unlock() 2000 fake.SetStateMetadataStub = nil 2001 if fake.setStateMetadataReturnsOnCall == nil { 2002 fake.setStateMetadataReturnsOnCall = make(map[int]struct { 2003 result1 error 2004 }) 2005 } 2006 fake.setStateMetadataReturnsOnCall[i] = struct { 2007 result1 error 2008 }{result1} 2009 } 2010 2011 func (fake *TxSimulator) SetStateMultipleKeys(arg1 string, arg2 map[string][]byte) error { 2012 fake.setStateMultipleKeysMutex.Lock() 2013 ret, specificReturn := fake.setStateMultipleKeysReturnsOnCall[len(fake.setStateMultipleKeysArgsForCall)] 2014 fake.setStateMultipleKeysArgsForCall = append(fake.setStateMultipleKeysArgsForCall, struct { 2015 arg1 string 2016 arg2 map[string][]byte 2017 }{arg1, arg2}) 2018 fake.recordInvocation("SetStateMultipleKeys", []interface{}{arg1, arg2}) 2019 fake.setStateMultipleKeysMutex.Unlock() 2020 if fake.SetStateMultipleKeysStub != nil { 2021 return fake.SetStateMultipleKeysStub(arg1, arg2) 2022 } 2023 if specificReturn { 2024 return ret.result1 2025 } 2026 fakeReturns := fake.setStateMultipleKeysReturns 2027 return fakeReturns.result1 2028 } 2029 2030 func (fake *TxSimulator) SetStateMultipleKeysCallCount() int { 2031 fake.setStateMultipleKeysMutex.RLock() 2032 defer fake.setStateMultipleKeysMutex.RUnlock() 2033 return len(fake.setStateMultipleKeysArgsForCall) 2034 } 2035 2036 func (fake *TxSimulator) SetStateMultipleKeysCalls(stub func(string, map[string][]byte) error) { 2037 fake.setStateMultipleKeysMutex.Lock() 2038 defer fake.setStateMultipleKeysMutex.Unlock() 2039 fake.SetStateMultipleKeysStub = stub 2040 } 2041 2042 func (fake *TxSimulator) SetStateMultipleKeysArgsForCall(i int) (string, map[string][]byte) { 2043 fake.setStateMultipleKeysMutex.RLock() 2044 defer fake.setStateMultipleKeysMutex.RUnlock() 2045 argsForCall := fake.setStateMultipleKeysArgsForCall[i] 2046 return argsForCall.arg1, argsForCall.arg2 2047 } 2048 2049 func (fake *TxSimulator) SetStateMultipleKeysReturns(result1 error) { 2050 fake.setStateMultipleKeysMutex.Lock() 2051 defer fake.setStateMultipleKeysMutex.Unlock() 2052 fake.SetStateMultipleKeysStub = nil 2053 fake.setStateMultipleKeysReturns = struct { 2054 result1 error 2055 }{result1} 2056 } 2057 2058 func (fake *TxSimulator) SetStateMultipleKeysReturnsOnCall(i int, result1 error) { 2059 fake.setStateMultipleKeysMutex.Lock() 2060 defer fake.setStateMultipleKeysMutex.Unlock() 2061 fake.SetStateMultipleKeysStub = nil 2062 if fake.setStateMultipleKeysReturnsOnCall == nil { 2063 fake.setStateMultipleKeysReturnsOnCall = make(map[int]struct { 2064 result1 error 2065 }) 2066 } 2067 fake.setStateMultipleKeysReturnsOnCall[i] = struct { 2068 result1 error 2069 }{result1} 2070 } 2071 2072 func (fake *TxSimulator) Invocations() map[string][][]interface{} { 2073 fake.invocationsMutex.RLock() 2074 defer fake.invocationsMutex.RUnlock() 2075 fake.deletePrivateDataMutex.RLock() 2076 defer fake.deletePrivateDataMutex.RUnlock() 2077 fake.deletePrivateDataMetadataMutex.RLock() 2078 defer fake.deletePrivateDataMetadataMutex.RUnlock() 2079 fake.deleteStateMutex.RLock() 2080 defer fake.deleteStateMutex.RUnlock() 2081 fake.deleteStateMetadataMutex.RLock() 2082 defer fake.deleteStateMetadataMutex.RUnlock() 2083 fake.doneMutex.RLock() 2084 defer fake.doneMutex.RUnlock() 2085 fake.executeQueryMutex.RLock() 2086 defer fake.executeQueryMutex.RUnlock() 2087 fake.executeQueryOnPrivateDataMutex.RLock() 2088 defer fake.executeQueryOnPrivateDataMutex.RUnlock() 2089 fake.executeQueryWithPaginationMutex.RLock() 2090 defer fake.executeQueryWithPaginationMutex.RUnlock() 2091 fake.executeUpdateMutex.RLock() 2092 defer fake.executeUpdateMutex.RUnlock() 2093 fake.getPrivateDataMutex.RLock() 2094 defer fake.getPrivateDataMutex.RUnlock() 2095 fake.getPrivateDataHashMutex.RLock() 2096 defer fake.getPrivateDataHashMutex.RUnlock() 2097 fake.getPrivateDataMetadataMutex.RLock() 2098 defer fake.getPrivateDataMetadataMutex.RUnlock() 2099 fake.getPrivateDataMetadataByHashMutex.RLock() 2100 defer fake.getPrivateDataMetadataByHashMutex.RUnlock() 2101 fake.getPrivateDataMultipleKeysMutex.RLock() 2102 defer fake.getPrivateDataMultipleKeysMutex.RUnlock() 2103 fake.getPrivateDataRangeScanIteratorMutex.RLock() 2104 defer fake.getPrivateDataRangeScanIteratorMutex.RUnlock() 2105 fake.getStateMutex.RLock() 2106 defer fake.getStateMutex.RUnlock() 2107 fake.getStateMetadataMutex.RLock() 2108 defer fake.getStateMetadataMutex.RUnlock() 2109 fake.getStateMultipleKeysMutex.RLock() 2110 defer fake.getStateMultipleKeysMutex.RUnlock() 2111 fake.getStateRangeScanIteratorMutex.RLock() 2112 defer fake.getStateRangeScanIteratorMutex.RUnlock() 2113 fake.getStateRangeScanIteratorWithPaginationMutex.RLock() 2114 defer fake.getStateRangeScanIteratorWithPaginationMutex.RUnlock() 2115 fake.getTxSimulationResultsMutex.RLock() 2116 defer fake.getTxSimulationResultsMutex.RUnlock() 2117 fake.setPrivateDataMutex.RLock() 2118 defer fake.setPrivateDataMutex.RUnlock() 2119 fake.setPrivateDataMetadataMutex.RLock() 2120 defer fake.setPrivateDataMetadataMutex.RUnlock() 2121 fake.setPrivateDataMultipleKeysMutex.RLock() 2122 defer fake.setPrivateDataMultipleKeysMutex.RUnlock() 2123 fake.setStateMutex.RLock() 2124 defer fake.setStateMutex.RUnlock() 2125 fake.setStateMetadataMutex.RLock() 2126 defer fake.setStateMetadataMutex.RUnlock() 2127 fake.setStateMultipleKeysMutex.RLock() 2128 defer fake.setStateMultipleKeysMutex.RUnlock() 2129 copiedInvocations := map[string][][]interface{}{} 2130 for key, value := range fake.invocations { 2131 copiedInvocations[key] = value 2132 } 2133 return copiedInvocations 2134 } 2135 2136 func (fake *TxSimulator) recordInvocation(key string, args []interface{}) { 2137 fake.invocationsMutex.Lock() 2138 defer fake.invocationsMutex.Unlock() 2139 if fake.invocations == nil { 2140 fake.invocations = map[string][][]interface{}{} 2141 } 2142 if fake.invocations[key] == nil { 2143 fake.invocations[key] = [][]interface{}{} 2144 } 2145 fake.invocations[key] = append(fake.invocations[key], args) 2146 }