github.com/osdi23p228/fabric@v0.0.0-20221218062954-77808885f5db/core/common/privdata/mock/query_executor.go (about) 1 // Code generated by counterfeiter. DO NOT EDIT. 2 package mock 3 4 import ( 5 "sync" 6 7 "github.com/osdi23p228/fabric/common/ledger" 8 ledgera "github.com/osdi23p228/fabric/core/ledger" 9 ) 10 11 type QueryExecutor struct { 12 DoneStub func() 13 doneMutex sync.RWMutex 14 doneArgsForCall []struct { 15 } 16 ExecuteQueryStub func(string, string) (ledger.ResultsIterator, error) 17 executeQueryMutex sync.RWMutex 18 executeQueryArgsForCall []struct { 19 arg1 string 20 arg2 string 21 } 22 executeQueryReturns struct { 23 result1 ledger.ResultsIterator 24 result2 error 25 } 26 executeQueryReturnsOnCall map[int]struct { 27 result1 ledger.ResultsIterator 28 result2 error 29 } 30 ExecuteQueryOnPrivateDataStub func(string, string, string) (ledger.ResultsIterator, error) 31 executeQueryOnPrivateDataMutex sync.RWMutex 32 executeQueryOnPrivateDataArgsForCall []struct { 33 arg1 string 34 arg2 string 35 arg3 string 36 } 37 executeQueryOnPrivateDataReturns struct { 38 result1 ledger.ResultsIterator 39 result2 error 40 } 41 executeQueryOnPrivateDataReturnsOnCall map[int]struct { 42 result1 ledger.ResultsIterator 43 result2 error 44 } 45 ExecuteQueryWithPaginationStub func(string, string, string, int32) (ledgera.QueryResultsIterator, error) 46 executeQueryWithPaginationMutex sync.RWMutex 47 executeQueryWithPaginationArgsForCall []struct { 48 arg1 string 49 arg2 string 50 arg3 string 51 arg4 int32 52 } 53 executeQueryWithPaginationReturns struct { 54 result1 ledgera.QueryResultsIterator 55 result2 error 56 } 57 executeQueryWithPaginationReturnsOnCall map[int]struct { 58 result1 ledgera.QueryResultsIterator 59 result2 error 60 } 61 GetPrivateDataStub func(string, string, string) ([]byte, error) 62 getPrivateDataMutex sync.RWMutex 63 getPrivateDataArgsForCall []struct { 64 arg1 string 65 arg2 string 66 arg3 string 67 } 68 getPrivateDataReturns struct { 69 result1 []byte 70 result2 error 71 } 72 getPrivateDataReturnsOnCall map[int]struct { 73 result1 []byte 74 result2 error 75 } 76 GetPrivateDataHashStub func(string, string, string) ([]byte, error) 77 getPrivateDataHashMutex sync.RWMutex 78 getPrivateDataHashArgsForCall []struct { 79 arg1 string 80 arg2 string 81 arg3 string 82 } 83 getPrivateDataHashReturns struct { 84 result1 []byte 85 result2 error 86 } 87 getPrivateDataHashReturnsOnCall map[int]struct { 88 result1 []byte 89 result2 error 90 } 91 GetPrivateDataMetadataStub func(string, string, string) (map[string][]byte, error) 92 getPrivateDataMetadataMutex sync.RWMutex 93 getPrivateDataMetadataArgsForCall []struct { 94 arg1 string 95 arg2 string 96 arg3 string 97 } 98 getPrivateDataMetadataReturns struct { 99 result1 map[string][]byte 100 result2 error 101 } 102 getPrivateDataMetadataReturnsOnCall map[int]struct { 103 result1 map[string][]byte 104 result2 error 105 } 106 GetPrivateDataMetadataByHashStub func(string, string, []byte) (map[string][]byte, error) 107 getPrivateDataMetadataByHashMutex sync.RWMutex 108 getPrivateDataMetadataByHashArgsForCall []struct { 109 arg1 string 110 arg2 string 111 arg3 []byte 112 } 113 getPrivateDataMetadataByHashReturns struct { 114 result1 map[string][]byte 115 result2 error 116 } 117 getPrivateDataMetadataByHashReturnsOnCall map[int]struct { 118 result1 map[string][]byte 119 result2 error 120 } 121 GetPrivateDataMultipleKeysStub func(string, string, []string) ([][]byte, error) 122 getPrivateDataMultipleKeysMutex sync.RWMutex 123 getPrivateDataMultipleKeysArgsForCall []struct { 124 arg1 string 125 arg2 string 126 arg3 []string 127 } 128 getPrivateDataMultipleKeysReturns struct { 129 result1 [][]byte 130 result2 error 131 } 132 getPrivateDataMultipleKeysReturnsOnCall map[int]struct { 133 result1 [][]byte 134 result2 error 135 } 136 GetPrivateDataRangeScanIteratorStub func(string, string, string, string) (ledger.ResultsIterator, error) 137 getPrivateDataRangeScanIteratorMutex sync.RWMutex 138 getPrivateDataRangeScanIteratorArgsForCall []struct { 139 arg1 string 140 arg2 string 141 arg3 string 142 arg4 string 143 } 144 getPrivateDataRangeScanIteratorReturns struct { 145 result1 ledger.ResultsIterator 146 result2 error 147 } 148 getPrivateDataRangeScanIteratorReturnsOnCall map[int]struct { 149 result1 ledger.ResultsIterator 150 result2 error 151 } 152 GetStateStub func(string, string) ([]byte, error) 153 getStateMutex sync.RWMutex 154 getStateArgsForCall []struct { 155 arg1 string 156 arg2 string 157 } 158 getStateReturns struct { 159 result1 []byte 160 result2 error 161 } 162 getStateReturnsOnCall map[int]struct { 163 result1 []byte 164 result2 error 165 } 166 GetStateMetadataStub func(string, string) (map[string][]byte, error) 167 getStateMetadataMutex sync.RWMutex 168 getStateMetadataArgsForCall []struct { 169 arg1 string 170 arg2 string 171 } 172 getStateMetadataReturns struct { 173 result1 map[string][]byte 174 result2 error 175 } 176 getStateMetadataReturnsOnCall map[int]struct { 177 result1 map[string][]byte 178 result2 error 179 } 180 GetStateMultipleKeysStub func(string, []string) ([][]byte, error) 181 getStateMultipleKeysMutex sync.RWMutex 182 getStateMultipleKeysArgsForCall []struct { 183 arg1 string 184 arg2 []string 185 } 186 getStateMultipleKeysReturns struct { 187 result1 [][]byte 188 result2 error 189 } 190 getStateMultipleKeysReturnsOnCall map[int]struct { 191 result1 [][]byte 192 result2 error 193 } 194 GetStateRangeScanIteratorStub func(string, string, string) (ledger.ResultsIterator, error) 195 getStateRangeScanIteratorMutex sync.RWMutex 196 getStateRangeScanIteratorArgsForCall []struct { 197 arg1 string 198 arg2 string 199 arg3 string 200 } 201 getStateRangeScanIteratorReturns struct { 202 result1 ledger.ResultsIterator 203 result2 error 204 } 205 getStateRangeScanIteratorReturnsOnCall map[int]struct { 206 result1 ledger.ResultsIterator 207 result2 error 208 } 209 GetStateRangeScanIteratorWithPaginationStub func(string, string, string, int32) (ledgera.QueryResultsIterator, error) 210 getStateRangeScanIteratorWithPaginationMutex sync.RWMutex 211 getStateRangeScanIteratorWithPaginationArgsForCall []struct { 212 arg1 string 213 arg2 string 214 arg3 string 215 arg4 int32 216 } 217 getStateRangeScanIteratorWithPaginationReturns struct { 218 result1 ledgera.QueryResultsIterator 219 result2 error 220 } 221 getStateRangeScanIteratorWithPaginationReturnsOnCall map[int]struct { 222 result1 ledgera.QueryResultsIterator 223 result2 error 224 } 225 invocations map[string][][]interface{} 226 invocationsMutex sync.RWMutex 227 } 228 229 func (fake *QueryExecutor) Done() { 230 fake.doneMutex.Lock() 231 fake.doneArgsForCall = append(fake.doneArgsForCall, struct { 232 }{}) 233 fake.recordInvocation("Done", []interface{}{}) 234 fake.doneMutex.Unlock() 235 if fake.DoneStub != nil { 236 fake.DoneStub() 237 } 238 } 239 240 func (fake *QueryExecutor) DoneCallCount() int { 241 fake.doneMutex.RLock() 242 defer fake.doneMutex.RUnlock() 243 return len(fake.doneArgsForCall) 244 } 245 246 func (fake *QueryExecutor) DoneCalls(stub func()) { 247 fake.doneMutex.Lock() 248 defer fake.doneMutex.Unlock() 249 fake.DoneStub = stub 250 } 251 252 func (fake *QueryExecutor) ExecuteQuery(arg1 string, arg2 string) (ledger.ResultsIterator, error) { 253 fake.executeQueryMutex.Lock() 254 ret, specificReturn := fake.executeQueryReturnsOnCall[len(fake.executeQueryArgsForCall)] 255 fake.executeQueryArgsForCall = append(fake.executeQueryArgsForCall, struct { 256 arg1 string 257 arg2 string 258 }{arg1, arg2}) 259 fake.recordInvocation("ExecuteQuery", []interface{}{arg1, arg2}) 260 fake.executeQueryMutex.Unlock() 261 if fake.ExecuteQueryStub != nil { 262 return fake.ExecuteQueryStub(arg1, arg2) 263 } 264 if specificReturn { 265 return ret.result1, ret.result2 266 } 267 fakeReturns := fake.executeQueryReturns 268 return fakeReturns.result1, fakeReturns.result2 269 } 270 271 func (fake *QueryExecutor) ExecuteQueryCallCount() int { 272 fake.executeQueryMutex.RLock() 273 defer fake.executeQueryMutex.RUnlock() 274 return len(fake.executeQueryArgsForCall) 275 } 276 277 func (fake *QueryExecutor) ExecuteQueryCalls(stub func(string, string) (ledger.ResultsIterator, error)) { 278 fake.executeQueryMutex.Lock() 279 defer fake.executeQueryMutex.Unlock() 280 fake.ExecuteQueryStub = stub 281 } 282 283 func (fake *QueryExecutor) ExecuteQueryArgsForCall(i int) (string, string) { 284 fake.executeQueryMutex.RLock() 285 defer fake.executeQueryMutex.RUnlock() 286 argsForCall := fake.executeQueryArgsForCall[i] 287 return argsForCall.arg1, argsForCall.arg2 288 } 289 290 func (fake *QueryExecutor) ExecuteQueryReturns(result1 ledger.ResultsIterator, result2 error) { 291 fake.executeQueryMutex.Lock() 292 defer fake.executeQueryMutex.Unlock() 293 fake.ExecuteQueryStub = nil 294 fake.executeQueryReturns = struct { 295 result1 ledger.ResultsIterator 296 result2 error 297 }{result1, result2} 298 } 299 300 func (fake *QueryExecutor) ExecuteQueryReturnsOnCall(i int, result1 ledger.ResultsIterator, result2 error) { 301 fake.executeQueryMutex.Lock() 302 defer fake.executeQueryMutex.Unlock() 303 fake.ExecuteQueryStub = nil 304 if fake.executeQueryReturnsOnCall == nil { 305 fake.executeQueryReturnsOnCall = make(map[int]struct { 306 result1 ledger.ResultsIterator 307 result2 error 308 }) 309 } 310 fake.executeQueryReturnsOnCall[i] = struct { 311 result1 ledger.ResultsIterator 312 result2 error 313 }{result1, result2} 314 } 315 316 func (fake *QueryExecutor) ExecuteQueryOnPrivateData(arg1 string, arg2 string, arg3 string) (ledger.ResultsIterator, error) { 317 fake.executeQueryOnPrivateDataMutex.Lock() 318 ret, specificReturn := fake.executeQueryOnPrivateDataReturnsOnCall[len(fake.executeQueryOnPrivateDataArgsForCall)] 319 fake.executeQueryOnPrivateDataArgsForCall = append(fake.executeQueryOnPrivateDataArgsForCall, struct { 320 arg1 string 321 arg2 string 322 arg3 string 323 }{arg1, arg2, arg3}) 324 fake.recordInvocation("ExecuteQueryOnPrivateData", []interface{}{arg1, arg2, arg3}) 325 fake.executeQueryOnPrivateDataMutex.Unlock() 326 if fake.ExecuteQueryOnPrivateDataStub != nil { 327 return fake.ExecuteQueryOnPrivateDataStub(arg1, arg2, arg3) 328 } 329 if specificReturn { 330 return ret.result1, ret.result2 331 } 332 fakeReturns := fake.executeQueryOnPrivateDataReturns 333 return fakeReturns.result1, fakeReturns.result2 334 } 335 336 func (fake *QueryExecutor) ExecuteQueryOnPrivateDataCallCount() int { 337 fake.executeQueryOnPrivateDataMutex.RLock() 338 defer fake.executeQueryOnPrivateDataMutex.RUnlock() 339 return len(fake.executeQueryOnPrivateDataArgsForCall) 340 } 341 342 func (fake *QueryExecutor) ExecuteQueryOnPrivateDataCalls(stub func(string, string, string) (ledger.ResultsIterator, error)) { 343 fake.executeQueryOnPrivateDataMutex.Lock() 344 defer fake.executeQueryOnPrivateDataMutex.Unlock() 345 fake.ExecuteQueryOnPrivateDataStub = stub 346 } 347 348 func (fake *QueryExecutor) ExecuteQueryOnPrivateDataArgsForCall(i int) (string, string, string) { 349 fake.executeQueryOnPrivateDataMutex.RLock() 350 defer fake.executeQueryOnPrivateDataMutex.RUnlock() 351 argsForCall := fake.executeQueryOnPrivateDataArgsForCall[i] 352 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 353 } 354 355 func (fake *QueryExecutor) ExecuteQueryOnPrivateDataReturns(result1 ledger.ResultsIterator, result2 error) { 356 fake.executeQueryOnPrivateDataMutex.Lock() 357 defer fake.executeQueryOnPrivateDataMutex.Unlock() 358 fake.ExecuteQueryOnPrivateDataStub = nil 359 fake.executeQueryOnPrivateDataReturns = struct { 360 result1 ledger.ResultsIterator 361 result2 error 362 }{result1, result2} 363 } 364 365 func (fake *QueryExecutor) ExecuteQueryOnPrivateDataReturnsOnCall(i int, result1 ledger.ResultsIterator, result2 error) { 366 fake.executeQueryOnPrivateDataMutex.Lock() 367 defer fake.executeQueryOnPrivateDataMutex.Unlock() 368 fake.ExecuteQueryOnPrivateDataStub = nil 369 if fake.executeQueryOnPrivateDataReturnsOnCall == nil { 370 fake.executeQueryOnPrivateDataReturnsOnCall = make(map[int]struct { 371 result1 ledger.ResultsIterator 372 result2 error 373 }) 374 } 375 fake.executeQueryOnPrivateDataReturnsOnCall[i] = struct { 376 result1 ledger.ResultsIterator 377 result2 error 378 }{result1, result2} 379 } 380 381 func (fake *QueryExecutor) ExecuteQueryWithPagination(arg1 string, arg2 string, arg3 string, arg4 int32) (ledgera.QueryResultsIterator, error) { 382 fake.executeQueryWithPaginationMutex.Lock() 383 ret, specificReturn := fake.executeQueryWithPaginationReturnsOnCall[len(fake.executeQueryWithPaginationArgsForCall)] 384 fake.executeQueryWithPaginationArgsForCall = append(fake.executeQueryWithPaginationArgsForCall, struct { 385 arg1 string 386 arg2 string 387 arg3 string 388 arg4 int32 389 }{arg1, arg2, arg3, arg4}) 390 fake.recordInvocation("ExecuteQueryWithPagination", []interface{}{arg1, arg2, arg3, arg4}) 391 fake.executeQueryWithPaginationMutex.Unlock() 392 if fake.ExecuteQueryWithPaginationStub != nil { 393 return fake.ExecuteQueryWithPaginationStub(arg1, arg2, arg3, arg4) 394 } 395 if specificReturn { 396 return ret.result1, ret.result2 397 } 398 fakeReturns := fake.executeQueryWithPaginationReturns 399 return fakeReturns.result1, fakeReturns.result2 400 } 401 402 func (fake *QueryExecutor) ExecuteQueryWithPaginationCallCount() int { 403 fake.executeQueryWithPaginationMutex.RLock() 404 defer fake.executeQueryWithPaginationMutex.RUnlock() 405 return len(fake.executeQueryWithPaginationArgsForCall) 406 } 407 408 func (fake *QueryExecutor) ExecuteQueryWithPaginationCalls(stub func(string, string, string, int32) (ledgera.QueryResultsIterator, error)) { 409 fake.executeQueryWithPaginationMutex.Lock() 410 defer fake.executeQueryWithPaginationMutex.Unlock() 411 fake.ExecuteQueryWithPaginationStub = stub 412 } 413 414 func (fake *QueryExecutor) ExecuteQueryWithPaginationArgsForCall(i int) (string, string, string, int32) { 415 fake.executeQueryWithPaginationMutex.RLock() 416 defer fake.executeQueryWithPaginationMutex.RUnlock() 417 argsForCall := fake.executeQueryWithPaginationArgsForCall[i] 418 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 419 } 420 421 func (fake *QueryExecutor) ExecuteQueryWithPaginationReturns(result1 ledgera.QueryResultsIterator, result2 error) { 422 fake.executeQueryWithPaginationMutex.Lock() 423 defer fake.executeQueryWithPaginationMutex.Unlock() 424 fake.ExecuteQueryWithPaginationStub = nil 425 fake.executeQueryWithPaginationReturns = struct { 426 result1 ledgera.QueryResultsIterator 427 result2 error 428 }{result1, result2} 429 } 430 431 func (fake *QueryExecutor) ExecuteQueryWithPaginationReturnsOnCall(i int, result1 ledgera.QueryResultsIterator, result2 error) { 432 fake.executeQueryWithPaginationMutex.Lock() 433 defer fake.executeQueryWithPaginationMutex.Unlock() 434 fake.ExecuteQueryWithPaginationStub = nil 435 if fake.executeQueryWithPaginationReturnsOnCall == nil { 436 fake.executeQueryWithPaginationReturnsOnCall = make(map[int]struct { 437 result1 ledgera.QueryResultsIterator 438 result2 error 439 }) 440 } 441 fake.executeQueryWithPaginationReturnsOnCall[i] = struct { 442 result1 ledgera.QueryResultsIterator 443 result2 error 444 }{result1, result2} 445 } 446 447 func (fake *QueryExecutor) GetPrivateData(arg1 string, arg2 string, arg3 string) ([]byte, error) { 448 fake.getPrivateDataMutex.Lock() 449 ret, specificReturn := fake.getPrivateDataReturnsOnCall[len(fake.getPrivateDataArgsForCall)] 450 fake.getPrivateDataArgsForCall = append(fake.getPrivateDataArgsForCall, struct { 451 arg1 string 452 arg2 string 453 arg3 string 454 }{arg1, arg2, arg3}) 455 fake.recordInvocation("GetPrivateData", []interface{}{arg1, arg2, arg3}) 456 fake.getPrivateDataMutex.Unlock() 457 if fake.GetPrivateDataStub != nil { 458 return fake.GetPrivateDataStub(arg1, arg2, arg3) 459 } 460 if specificReturn { 461 return ret.result1, ret.result2 462 } 463 fakeReturns := fake.getPrivateDataReturns 464 return fakeReturns.result1, fakeReturns.result2 465 } 466 467 func (fake *QueryExecutor) GetPrivateDataCallCount() int { 468 fake.getPrivateDataMutex.RLock() 469 defer fake.getPrivateDataMutex.RUnlock() 470 return len(fake.getPrivateDataArgsForCall) 471 } 472 473 func (fake *QueryExecutor) GetPrivateDataCalls(stub func(string, string, string) ([]byte, error)) { 474 fake.getPrivateDataMutex.Lock() 475 defer fake.getPrivateDataMutex.Unlock() 476 fake.GetPrivateDataStub = stub 477 } 478 479 func (fake *QueryExecutor) GetPrivateDataArgsForCall(i int) (string, string, string) { 480 fake.getPrivateDataMutex.RLock() 481 defer fake.getPrivateDataMutex.RUnlock() 482 argsForCall := fake.getPrivateDataArgsForCall[i] 483 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 484 } 485 486 func (fake *QueryExecutor) GetPrivateDataReturns(result1 []byte, result2 error) { 487 fake.getPrivateDataMutex.Lock() 488 defer fake.getPrivateDataMutex.Unlock() 489 fake.GetPrivateDataStub = nil 490 fake.getPrivateDataReturns = struct { 491 result1 []byte 492 result2 error 493 }{result1, result2} 494 } 495 496 func (fake *QueryExecutor) GetPrivateDataReturnsOnCall(i int, result1 []byte, result2 error) { 497 fake.getPrivateDataMutex.Lock() 498 defer fake.getPrivateDataMutex.Unlock() 499 fake.GetPrivateDataStub = nil 500 if fake.getPrivateDataReturnsOnCall == nil { 501 fake.getPrivateDataReturnsOnCall = make(map[int]struct { 502 result1 []byte 503 result2 error 504 }) 505 } 506 fake.getPrivateDataReturnsOnCall[i] = struct { 507 result1 []byte 508 result2 error 509 }{result1, result2} 510 } 511 512 func (fake *QueryExecutor) GetPrivateDataHash(arg1 string, arg2 string, arg3 string) ([]byte, error) { 513 fake.getPrivateDataHashMutex.Lock() 514 ret, specificReturn := fake.getPrivateDataHashReturnsOnCall[len(fake.getPrivateDataHashArgsForCall)] 515 fake.getPrivateDataHashArgsForCall = append(fake.getPrivateDataHashArgsForCall, struct { 516 arg1 string 517 arg2 string 518 arg3 string 519 }{arg1, arg2, arg3}) 520 fake.recordInvocation("GetPrivateDataHash", []interface{}{arg1, arg2, arg3}) 521 fake.getPrivateDataHashMutex.Unlock() 522 if fake.GetPrivateDataHashStub != nil { 523 return fake.GetPrivateDataHashStub(arg1, arg2, arg3) 524 } 525 if specificReturn { 526 return ret.result1, ret.result2 527 } 528 fakeReturns := fake.getPrivateDataHashReturns 529 return fakeReturns.result1, fakeReturns.result2 530 } 531 532 func (fake *QueryExecutor) GetPrivateDataHashCallCount() int { 533 fake.getPrivateDataHashMutex.RLock() 534 defer fake.getPrivateDataHashMutex.RUnlock() 535 return len(fake.getPrivateDataHashArgsForCall) 536 } 537 538 func (fake *QueryExecutor) GetPrivateDataHashCalls(stub func(string, string, string) ([]byte, error)) { 539 fake.getPrivateDataHashMutex.Lock() 540 defer fake.getPrivateDataHashMutex.Unlock() 541 fake.GetPrivateDataHashStub = stub 542 } 543 544 func (fake *QueryExecutor) GetPrivateDataHashArgsForCall(i int) (string, string, string) { 545 fake.getPrivateDataHashMutex.RLock() 546 defer fake.getPrivateDataHashMutex.RUnlock() 547 argsForCall := fake.getPrivateDataHashArgsForCall[i] 548 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 549 } 550 551 func (fake *QueryExecutor) GetPrivateDataHashReturns(result1 []byte, result2 error) { 552 fake.getPrivateDataHashMutex.Lock() 553 defer fake.getPrivateDataHashMutex.Unlock() 554 fake.GetPrivateDataHashStub = nil 555 fake.getPrivateDataHashReturns = struct { 556 result1 []byte 557 result2 error 558 }{result1, result2} 559 } 560 561 func (fake *QueryExecutor) GetPrivateDataHashReturnsOnCall(i int, result1 []byte, result2 error) { 562 fake.getPrivateDataHashMutex.Lock() 563 defer fake.getPrivateDataHashMutex.Unlock() 564 fake.GetPrivateDataHashStub = nil 565 if fake.getPrivateDataHashReturnsOnCall == nil { 566 fake.getPrivateDataHashReturnsOnCall = make(map[int]struct { 567 result1 []byte 568 result2 error 569 }) 570 } 571 fake.getPrivateDataHashReturnsOnCall[i] = struct { 572 result1 []byte 573 result2 error 574 }{result1, result2} 575 } 576 577 func (fake *QueryExecutor) GetPrivateDataMetadata(arg1 string, arg2 string, arg3 string) (map[string][]byte, error) { 578 fake.getPrivateDataMetadataMutex.Lock() 579 ret, specificReturn := fake.getPrivateDataMetadataReturnsOnCall[len(fake.getPrivateDataMetadataArgsForCall)] 580 fake.getPrivateDataMetadataArgsForCall = append(fake.getPrivateDataMetadataArgsForCall, struct { 581 arg1 string 582 arg2 string 583 arg3 string 584 }{arg1, arg2, arg3}) 585 fake.recordInvocation("GetPrivateDataMetadata", []interface{}{arg1, arg2, arg3}) 586 fake.getPrivateDataMetadataMutex.Unlock() 587 if fake.GetPrivateDataMetadataStub != nil { 588 return fake.GetPrivateDataMetadataStub(arg1, arg2, arg3) 589 } 590 if specificReturn { 591 return ret.result1, ret.result2 592 } 593 fakeReturns := fake.getPrivateDataMetadataReturns 594 return fakeReturns.result1, fakeReturns.result2 595 } 596 597 func (fake *QueryExecutor) GetPrivateDataMetadataCallCount() int { 598 fake.getPrivateDataMetadataMutex.RLock() 599 defer fake.getPrivateDataMetadataMutex.RUnlock() 600 return len(fake.getPrivateDataMetadataArgsForCall) 601 } 602 603 func (fake *QueryExecutor) GetPrivateDataMetadataCalls(stub func(string, string, string) (map[string][]byte, error)) { 604 fake.getPrivateDataMetadataMutex.Lock() 605 defer fake.getPrivateDataMetadataMutex.Unlock() 606 fake.GetPrivateDataMetadataStub = stub 607 } 608 609 func (fake *QueryExecutor) GetPrivateDataMetadataArgsForCall(i int) (string, string, string) { 610 fake.getPrivateDataMetadataMutex.RLock() 611 defer fake.getPrivateDataMetadataMutex.RUnlock() 612 argsForCall := fake.getPrivateDataMetadataArgsForCall[i] 613 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 614 } 615 616 func (fake *QueryExecutor) GetPrivateDataMetadataReturns(result1 map[string][]byte, result2 error) { 617 fake.getPrivateDataMetadataMutex.Lock() 618 defer fake.getPrivateDataMetadataMutex.Unlock() 619 fake.GetPrivateDataMetadataStub = nil 620 fake.getPrivateDataMetadataReturns = struct { 621 result1 map[string][]byte 622 result2 error 623 }{result1, result2} 624 } 625 626 func (fake *QueryExecutor) GetPrivateDataMetadataReturnsOnCall(i int, result1 map[string][]byte, result2 error) { 627 fake.getPrivateDataMetadataMutex.Lock() 628 defer fake.getPrivateDataMetadataMutex.Unlock() 629 fake.GetPrivateDataMetadataStub = nil 630 if fake.getPrivateDataMetadataReturnsOnCall == nil { 631 fake.getPrivateDataMetadataReturnsOnCall = make(map[int]struct { 632 result1 map[string][]byte 633 result2 error 634 }) 635 } 636 fake.getPrivateDataMetadataReturnsOnCall[i] = struct { 637 result1 map[string][]byte 638 result2 error 639 }{result1, result2} 640 } 641 642 func (fake *QueryExecutor) GetPrivateDataMetadataByHash(arg1 string, arg2 string, arg3 []byte) (map[string][]byte, error) { 643 var arg3Copy []byte 644 if arg3 != nil { 645 arg3Copy = make([]byte, len(arg3)) 646 copy(arg3Copy, arg3) 647 } 648 fake.getPrivateDataMetadataByHashMutex.Lock() 649 ret, specificReturn := fake.getPrivateDataMetadataByHashReturnsOnCall[len(fake.getPrivateDataMetadataByHashArgsForCall)] 650 fake.getPrivateDataMetadataByHashArgsForCall = append(fake.getPrivateDataMetadataByHashArgsForCall, struct { 651 arg1 string 652 arg2 string 653 arg3 []byte 654 }{arg1, arg2, arg3Copy}) 655 fake.recordInvocation("GetPrivateDataMetadataByHash", []interface{}{arg1, arg2, arg3Copy}) 656 fake.getPrivateDataMetadataByHashMutex.Unlock() 657 if fake.GetPrivateDataMetadataByHashStub != nil { 658 return fake.GetPrivateDataMetadataByHashStub(arg1, arg2, arg3) 659 } 660 if specificReturn { 661 return ret.result1, ret.result2 662 } 663 fakeReturns := fake.getPrivateDataMetadataByHashReturns 664 return fakeReturns.result1, fakeReturns.result2 665 } 666 667 func (fake *QueryExecutor) GetPrivateDataMetadataByHashCallCount() int { 668 fake.getPrivateDataMetadataByHashMutex.RLock() 669 defer fake.getPrivateDataMetadataByHashMutex.RUnlock() 670 return len(fake.getPrivateDataMetadataByHashArgsForCall) 671 } 672 673 func (fake *QueryExecutor) GetPrivateDataMetadataByHashCalls(stub func(string, string, []byte) (map[string][]byte, error)) { 674 fake.getPrivateDataMetadataByHashMutex.Lock() 675 defer fake.getPrivateDataMetadataByHashMutex.Unlock() 676 fake.GetPrivateDataMetadataByHashStub = stub 677 } 678 679 func (fake *QueryExecutor) GetPrivateDataMetadataByHashArgsForCall(i int) (string, string, []byte) { 680 fake.getPrivateDataMetadataByHashMutex.RLock() 681 defer fake.getPrivateDataMetadataByHashMutex.RUnlock() 682 argsForCall := fake.getPrivateDataMetadataByHashArgsForCall[i] 683 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 684 } 685 686 func (fake *QueryExecutor) GetPrivateDataMetadataByHashReturns(result1 map[string][]byte, result2 error) { 687 fake.getPrivateDataMetadataByHashMutex.Lock() 688 defer fake.getPrivateDataMetadataByHashMutex.Unlock() 689 fake.GetPrivateDataMetadataByHashStub = nil 690 fake.getPrivateDataMetadataByHashReturns = struct { 691 result1 map[string][]byte 692 result2 error 693 }{result1, result2} 694 } 695 696 func (fake *QueryExecutor) GetPrivateDataMetadataByHashReturnsOnCall(i int, result1 map[string][]byte, result2 error) { 697 fake.getPrivateDataMetadataByHashMutex.Lock() 698 defer fake.getPrivateDataMetadataByHashMutex.Unlock() 699 fake.GetPrivateDataMetadataByHashStub = nil 700 if fake.getPrivateDataMetadataByHashReturnsOnCall == nil { 701 fake.getPrivateDataMetadataByHashReturnsOnCall = make(map[int]struct { 702 result1 map[string][]byte 703 result2 error 704 }) 705 } 706 fake.getPrivateDataMetadataByHashReturnsOnCall[i] = struct { 707 result1 map[string][]byte 708 result2 error 709 }{result1, result2} 710 } 711 712 func (fake *QueryExecutor) GetPrivateDataMultipleKeys(arg1 string, arg2 string, arg3 []string) ([][]byte, error) { 713 var arg3Copy []string 714 if arg3 != nil { 715 arg3Copy = make([]string, len(arg3)) 716 copy(arg3Copy, arg3) 717 } 718 fake.getPrivateDataMultipleKeysMutex.Lock() 719 ret, specificReturn := fake.getPrivateDataMultipleKeysReturnsOnCall[len(fake.getPrivateDataMultipleKeysArgsForCall)] 720 fake.getPrivateDataMultipleKeysArgsForCall = append(fake.getPrivateDataMultipleKeysArgsForCall, struct { 721 arg1 string 722 arg2 string 723 arg3 []string 724 }{arg1, arg2, arg3Copy}) 725 fake.recordInvocation("GetPrivateDataMultipleKeys", []interface{}{arg1, arg2, arg3Copy}) 726 fake.getPrivateDataMultipleKeysMutex.Unlock() 727 if fake.GetPrivateDataMultipleKeysStub != nil { 728 return fake.GetPrivateDataMultipleKeysStub(arg1, arg2, arg3) 729 } 730 if specificReturn { 731 return ret.result1, ret.result2 732 } 733 fakeReturns := fake.getPrivateDataMultipleKeysReturns 734 return fakeReturns.result1, fakeReturns.result2 735 } 736 737 func (fake *QueryExecutor) GetPrivateDataMultipleKeysCallCount() int { 738 fake.getPrivateDataMultipleKeysMutex.RLock() 739 defer fake.getPrivateDataMultipleKeysMutex.RUnlock() 740 return len(fake.getPrivateDataMultipleKeysArgsForCall) 741 } 742 743 func (fake *QueryExecutor) GetPrivateDataMultipleKeysCalls(stub func(string, string, []string) ([][]byte, error)) { 744 fake.getPrivateDataMultipleKeysMutex.Lock() 745 defer fake.getPrivateDataMultipleKeysMutex.Unlock() 746 fake.GetPrivateDataMultipleKeysStub = stub 747 } 748 749 func (fake *QueryExecutor) GetPrivateDataMultipleKeysArgsForCall(i int) (string, string, []string) { 750 fake.getPrivateDataMultipleKeysMutex.RLock() 751 defer fake.getPrivateDataMultipleKeysMutex.RUnlock() 752 argsForCall := fake.getPrivateDataMultipleKeysArgsForCall[i] 753 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 754 } 755 756 func (fake *QueryExecutor) GetPrivateDataMultipleKeysReturns(result1 [][]byte, result2 error) { 757 fake.getPrivateDataMultipleKeysMutex.Lock() 758 defer fake.getPrivateDataMultipleKeysMutex.Unlock() 759 fake.GetPrivateDataMultipleKeysStub = nil 760 fake.getPrivateDataMultipleKeysReturns = struct { 761 result1 [][]byte 762 result2 error 763 }{result1, result2} 764 } 765 766 func (fake *QueryExecutor) GetPrivateDataMultipleKeysReturnsOnCall(i int, result1 [][]byte, result2 error) { 767 fake.getPrivateDataMultipleKeysMutex.Lock() 768 defer fake.getPrivateDataMultipleKeysMutex.Unlock() 769 fake.GetPrivateDataMultipleKeysStub = nil 770 if fake.getPrivateDataMultipleKeysReturnsOnCall == nil { 771 fake.getPrivateDataMultipleKeysReturnsOnCall = make(map[int]struct { 772 result1 [][]byte 773 result2 error 774 }) 775 } 776 fake.getPrivateDataMultipleKeysReturnsOnCall[i] = struct { 777 result1 [][]byte 778 result2 error 779 }{result1, result2} 780 } 781 782 func (fake *QueryExecutor) GetPrivateDataRangeScanIterator(arg1 string, arg2 string, arg3 string, arg4 string) (ledger.ResultsIterator, error) { 783 fake.getPrivateDataRangeScanIteratorMutex.Lock() 784 ret, specificReturn := fake.getPrivateDataRangeScanIteratorReturnsOnCall[len(fake.getPrivateDataRangeScanIteratorArgsForCall)] 785 fake.getPrivateDataRangeScanIteratorArgsForCall = append(fake.getPrivateDataRangeScanIteratorArgsForCall, struct { 786 arg1 string 787 arg2 string 788 arg3 string 789 arg4 string 790 }{arg1, arg2, arg3, arg4}) 791 fake.recordInvocation("GetPrivateDataRangeScanIterator", []interface{}{arg1, arg2, arg3, arg4}) 792 fake.getPrivateDataRangeScanIteratorMutex.Unlock() 793 if fake.GetPrivateDataRangeScanIteratorStub != nil { 794 return fake.GetPrivateDataRangeScanIteratorStub(arg1, arg2, arg3, arg4) 795 } 796 if specificReturn { 797 return ret.result1, ret.result2 798 } 799 fakeReturns := fake.getPrivateDataRangeScanIteratorReturns 800 return fakeReturns.result1, fakeReturns.result2 801 } 802 803 func (fake *QueryExecutor) GetPrivateDataRangeScanIteratorCallCount() int { 804 fake.getPrivateDataRangeScanIteratorMutex.RLock() 805 defer fake.getPrivateDataRangeScanIteratorMutex.RUnlock() 806 return len(fake.getPrivateDataRangeScanIteratorArgsForCall) 807 } 808 809 func (fake *QueryExecutor) GetPrivateDataRangeScanIteratorCalls(stub func(string, string, string, string) (ledger.ResultsIterator, error)) { 810 fake.getPrivateDataRangeScanIteratorMutex.Lock() 811 defer fake.getPrivateDataRangeScanIteratorMutex.Unlock() 812 fake.GetPrivateDataRangeScanIteratorStub = stub 813 } 814 815 func (fake *QueryExecutor) GetPrivateDataRangeScanIteratorArgsForCall(i int) (string, string, string, string) { 816 fake.getPrivateDataRangeScanIteratorMutex.RLock() 817 defer fake.getPrivateDataRangeScanIteratorMutex.RUnlock() 818 argsForCall := fake.getPrivateDataRangeScanIteratorArgsForCall[i] 819 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 820 } 821 822 func (fake *QueryExecutor) GetPrivateDataRangeScanIteratorReturns(result1 ledger.ResultsIterator, result2 error) { 823 fake.getPrivateDataRangeScanIteratorMutex.Lock() 824 defer fake.getPrivateDataRangeScanIteratorMutex.Unlock() 825 fake.GetPrivateDataRangeScanIteratorStub = nil 826 fake.getPrivateDataRangeScanIteratorReturns = struct { 827 result1 ledger.ResultsIterator 828 result2 error 829 }{result1, result2} 830 } 831 832 func (fake *QueryExecutor) GetPrivateDataRangeScanIteratorReturnsOnCall(i int, result1 ledger.ResultsIterator, result2 error) { 833 fake.getPrivateDataRangeScanIteratorMutex.Lock() 834 defer fake.getPrivateDataRangeScanIteratorMutex.Unlock() 835 fake.GetPrivateDataRangeScanIteratorStub = nil 836 if fake.getPrivateDataRangeScanIteratorReturnsOnCall == nil { 837 fake.getPrivateDataRangeScanIteratorReturnsOnCall = make(map[int]struct { 838 result1 ledger.ResultsIterator 839 result2 error 840 }) 841 } 842 fake.getPrivateDataRangeScanIteratorReturnsOnCall[i] = struct { 843 result1 ledger.ResultsIterator 844 result2 error 845 }{result1, result2} 846 } 847 848 func (fake *QueryExecutor) GetState(arg1 string, arg2 string) ([]byte, error) { 849 fake.getStateMutex.Lock() 850 ret, specificReturn := fake.getStateReturnsOnCall[len(fake.getStateArgsForCall)] 851 fake.getStateArgsForCall = append(fake.getStateArgsForCall, struct { 852 arg1 string 853 arg2 string 854 }{arg1, arg2}) 855 fake.recordInvocation("GetState", []interface{}{arg1, arg2}) 856 fake.getStateMutex.Unlock() 857 if fake.GetStateStub != nil { 858 return fake.GetStateStub(arg1, arg2) 859 } 860 if specificReturn { 861 return ret.result1, ret.result2 862 } 863 fakeReturns := fake.getStateReturns 864 return fakeReturns.result1, fakeReturns.result2 865 } 866 867 func (fake *QueryExecutor) GetStateCallCount() int { 868 fake.getStateMutex.RLock() 869 defer fake.getStateMutex.RUnlock() 870 return len(fake.getStateArgsForCall) 871 } 872 873 func (fake *QueryExecutor) GetStateCalls(stub func(string, string) ([]byte, error)) { 874 fake.getStateMutex.Lock() 875 defer fake.getStateMutex.Unlock() 876 fake.GetStateStub = stub 877 } 878 879 func (fake *QueryExecutor) GetStateArgsForCall(i int) (string, string) { 880 fake.getStateMutex.RLock() 881 defer fake.getStateMutex.RUnlock() 882 argsForCall := fake.getStateArgsForCall[i] 883 return argsForCall.arg1, argsForCall.arg2 884 } 885 886 func (fake *QueryExecutor) GetStateReturns(result1 []byte, result2 error) { 887 fake.getStateMutex.Lock() 888 defer fake.getStateMutex.Unlock() 889 fake.GetStateStub = nil 890 fake.getStateReturns = struct { 891 result1 []byte 892 result2 error 893 }{result1, result2} 894 } 895 896 func (fake *QueryExecutor) GetStateReturnsOnCall(i int, result1 []byte, result2 error) { 897 fake.getStateMutex.Lock() 898 defer fake.getStateMutex.Unlock() 899 fake.GetStateStub = nil 900 if fake.getStateReturnsOnCall == nil { 901 fake.getStateReturnsOnCall = make(map[int]struct { 902 result1 []byte 903 result2 error 904 }) 905 } 906 fake.getStateReturnsOnCall[i] = struct { 907 result1 []byte 908 result2 error 909 }{result1, result2} 910 } 911 912 func (fake *QueryExecutor) GetStateMetadata(arg1 string, arg2 string) (map[string][]byte, error) { 913 fake.getStateMetadataMutex.Lock() 914 ret, specificReturn := fake.getStateMetadataReturnsOnCall[len(fake.getStateMetadataArgsForCall)] 915 fake.getStateMetadataArgsForCall = append(fake.getStateMetadataArgsForCall, struct { 916 arg1 string 917 arg2 string 918 }{arg1, arg2}) 919 fake.recordInvocation("GetStateMetadata", []interface{}{arg1, arg2}) 920 fake.getStateMetadataMutex.Unlock() 921 if fake.GetStateMetadataStub != nil { 922 return fake.GetStateMetadataStub(arg1, arg2) 923 } 924 if specificReturn { 925 return ret.result1, ret.result2 926 } 927 fakeReturns := fake.getStateMetadataReturns 928 return fakeReturns.result1, fakeReturns.result2 929 } 930 931 func (fake *QueryExecutor) GetStateMetadataCallCount() int { 932 fake.getStateMetadataMutex.RLock() 933 defer fake.getStateMetadataMutex.RUnlock() 934 return len(fake.getStateMetadataArgsForCall) 935 } 936 937 func (fake *QueryExecutor) GetStateMetadataCalls(stub func(string, string) (map[string][]byte, error)) { 938 fake.getStateMetadataMutex.Lock() 939 defer fake.getStateMetadataMutex.Unlock() 940 fake.GetStateMetadataStub = stub 941 } 942 943 func (fake *QueryExecutor) GetStateMetadataArgsForCall(i int) (string, string) { 944 fake.getStateMetadataMutex.RLock() 945 defer fake.getStateMetadataMutex.RUnlock() 946 argsForCall := fake.getStateMetadataArgsForCall[i] 947 return argsForCall.arg1, argsForCall.arg2 948 } 949 950 func (fake *QueryExecutor) GetStateMetadataReturns(result1 map[string][]byte, result2 error) { 951 fake.getStateMetadataMutex.Lock() 952 defer fake.getStateMetadataMutex.Unlock() 953 fake.GetStateMetadataStub = nil 954 fake.getStateMetadataReturns = struct { 955 result1 map[string][]byte 956 result2 error 957 }{result1, result2} 958 } 959 960 func (fake *QueryExecutor) GetStateMetadataReturnsOnCall(i int, result1 map[string][]byte, result2 error) { 961 fake.getStateMetadataMutex.Lock() 962 defer fake.getStateMetadataMutex.Unlock() 963 fake.GetStateMetadataStub = nil 964 if fake.getStateMetadataReturnsOnCall == nil { 965 fake.getStateMetadataReturnsOnCall = make(map[int]struct { 966 result1 map[string][]byte 967 result2 error 968 }) 969 } 970 fake.getStateMetadataReturnsOnCall[i] = struct { 971 result1 map[string][]byte 972 result2 error 973 }{result1, result2} 974 } 975 976 func (fake *QueryExecutor) GetStateMultipleKeys(arg1 string, arg2 []string) ([][]byte, error) { 977 var arg2Copy []string 978 if arg2 != nil { 979 arg2Copy = make([]string, len(arg2)) 980 copy(arg2Copy, arg2) 981 } 982 fake.getStateMultipleKeysMutex.Lock() 983 ret, specificReturn := fake.getStateMultipleKeysReturnsOnCall[len(fake.getStateMultipleKeysArgsForCall)] 984 fake.getStateMultipleKeysArgsForCall = append(fake.getStateMultipleKeysArgsForCall, struct { 985 arg1 string 986 arg2 []string 987 }{arg1, arg2Copy}) 988 fake.recordInvocation("GetStateMultipleKeys", []interface{}{arg1, arg2Copy}) 989 fake.getStateMultipleKeysMutex.Unlock() 990 if fake.GetStateMultipleKeysStub != nil { 991 return fake.GetStateMultipleKeysStub(arg1, arg2) 992 } 993 if specificReturn { 994 return ret.result1, ret.result2 995 } 996 fakeReturns := fake.getStateMultipleKeysReturns 997 return fakeReturns.result1, fakeReturns.result2 998 } 999 1000 func (fake *QueryExecutor) GetStateMultipleKeysCallCount() int { 1001 fake.getStateMultipleKeysMutex.RLock() 1002 defer fake.getStateMultipleKeysMutex.RUnlock() 1003 return len(fake.getStateMultipleKeysArgsForCall) 1004 } 1005 1006 func (fake *QueryExecutor) GetStateMultipleKeysCalls(stub func(string, []string) ([][]byte, error)) { 1007 fake.getStateMultipleKeysMutex.Lock() 1008 defer fake.getStateMultipleKeysMutex.Unlock() 1009 fake.GetStateMultipleKeysStub = stub 1010 } 1011 1012 func (fake *QueryExecutor) GetStateMultipleKeysArgsForCall(i int) (string, []string) { 1013 fake.getStateMultipleKeysMutex.RLock() 1014 defer fake.getStateMultipleKeysMutex.RUnlock() 1015 argsForCall := fake.getStateMultipleKeysArgsForCall[i] 1016 return argsForCall.arg1, argsForCall.arg2 1017 } 1018 1019 func (fake *QueryExecutor) GetStateMultipleKeysReturns(result1 [][]byte, result2 error) { 1020 fake.getStateMultipleKeysMutex.Lock() 1021 defer fake.getStateMultipleKeysMutex.Unlock() 1022 fake.GetStateMultipleKeysStub = nil 1023 fake.getStateMultipleKeysReturns = struct { 1024 result1 [][]byte 1025 result2 error 1026 }{result1, result2} 1027 } 1028 1029 func (fake *QueryExecutor) GetStateMultipleKeysReturnsOnCall(i int, result1 [][]byte, result2 error) { 1030 fake.getStateMultipleKeysMutex.Lock() 1031 defer fake.getStateMultipleKeysMutex.Unlock() 1032 fake.GetStateMultipleKeysStub = nil 1033 if fake.getStateMultipleKeysReturnsOnCall == nil { 1034 fake.getStateMultipleKeysReturnsOnCall = make(map[int]struct { 1035 result1 [][]byte 1036 result2 error 1037 }) 1038 } 1039 fake.getStateMultipleKeysReturnsOnCall[i] = struct { 1040 result1 [][]byte 1041 result2 error 1042 }{result1, result2} 1043 } 1044 1045 func (fake *QueryExecutor) GetStateRangeScanIterator(arg1 string, arg2 string, arg3 string) (ledger.ResultsIterator, error) { 1046 fake.getStateRangeScanIteratorMutex.Lock() 1047 ret, specificReturn := fake.getStateRangeScanIteratorReturnsOnCall[len(fake.getStateRangeScanIteratorArgsForCall)] 1048 fake.getStateRangeScanIteratorArgsForCall = append(fake.getStateRangeScanIteratorArgsForCall, struct { 1049 arg1 string 1050 arg2 string 1051 arg3 string 1052 }{arg1, arg2, arg3}) 1053 fake.recordInvocation("GetStateRangeScanIterator", []interface{}{arg1, arg2, arg3}) 1054 fake.getStateRangeScanIteratorMutex.Unlock() 1055 if fake.GetStateRangeScanIteratorStub != nil { 1056 return fake.GetStateRangeScanIteratorStub(arg1, arg2, arg3) 1057 } 1058 if specificReturn { 1059 return ret.result1, ret.result2 1060 } 1061 fakeReturns := fake.getStateRangeScanIteratorReturns 1062 return fakeReturns.result1, fakeReturns.result2 1063 } 1064 1065 func (fake *QueryExecutor) GetStateRangeScanIteratorCallCount() int { 1066 fake.getStateRangeScanIteratorMutex.RLock() 1067 defer fake.getStateRangeScanIteratorMutex.RUnlock() 1068 return len(fake.getStateRangeScanIteratorArgsForCall) 1069 } 1070 1071 func (fake *QueryExecutor) GetStateRangeScanIteratorCalls(stub func(string, string, string) (ledger.ResultsIterator, error)) { 1072 fake.getStateRangeScanIteratorMutex.Lock() 1073 defer fake.getStateRangeScanIteratorMutex.Unlock() 1074 fake.GetStateRangeScanIteratorStub = stub 1075 } 1076 1077 func (fake *QueryExecutor) GetStateRangeScanIteratorArgsForCall(i int) (string, string, string) { 1078 fake.getStateRangeScanIteratorMutex.RLock() 1079 defer fake.getStateRangeScanIteratorMutex.RUnlock() 1080 argsForCall := fake.getStateRangeScanIteratorArgsForCall[i] 1081 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3 1082 } 1083 1084 func (fake *QueryExecutor) GetStateRangeScanIteratorReturns(result1 ledger.ResultsIterator, result2 error) { 1085 fake.getStateRangeScanIteratorMutex.Lock() 1086 defer fake.getStateRangeScanIteratorMutex.Unlock() 1087 fake.GetStateRangeScanIteratorStub = nil 1088 fake.getStateRangeScanIteratorReturns = struct { 1089 result1 ledger.ResultsIterator 1090 result2 error 1091 }{result1, result2} 1092 } 1093 1094 func (fake *QueryExecutor) GetStateRangeScanIteratorReturnsOnCall(i int, result1 ledger.ResultsIterator, result2 error) { 1095 fake.getStateRangeScanIteratorMutex.Lock() 1096 defer fake.getStateRangeScanIteratorMutex.Unlock() 1097 fake.GetStateRangeScanIteratorStub = nil 1098 if fake.getStateRangeScanIteratorReturnsOnCall == nil { 1099 fake.getStateRangeScanIteratorReturnsOnCall = make(map[int]struct { 1100 result1 ledger.ResultsIterator 1101 result2 error 1102 }) 1103 } 1104 fake.getStateRangeScanIteratorReturnsOnCall[i] = struct { 1105 result1 ledger.ResultsIterator 1106 result2 error 1107 }{result1, result2} 1108 } 1109 1110 func (fake *QueryExecutor) GetStateRangeScanIteratorWithPagination(arg1 string, arg2 string, arg3 string, arg4 int32) (ledgera.QueryResultsIterator, error) { 1111 fake.getStateRangeScanIteratorWithPaginationMutex.Lock() 1112 ret, specificReturn := fake.getStateRangeScanIteratorWithPaginationReturnsOnCall[len(fake.getStateRangeScanIteratorWithPaginationArgsForCall)] 1113 fake.getStateRangeScanIteratorWithPaginationArgsForCall = append(fake.getStateRangeScanIteratorWithPaginationArgsForCall, struct { 1114 arg1 string 1115 arg2 string 1116 arg3 string 1117 arg4 int32 1118 }{arg1, arg2, arg3, arg4}) 1119 fake.recordInvocation("GetStateRangeScanIteratorWithPagination", []interface{}{arg1, arg2, arg3, arg4}) 1120 fake.getStateRangeScanIteratorWithPaginationMutex.Unlock() 1121 if fake.GetStateRangeScanIteratorWithPaginationStub != nil { 1122 return fake.GetStateRangeScanIteratorWithPaginationStub(arg1, arg2, arg3, arg4) 1123 } 1124 if specificReturn { 1125 return ret.result1, ret.result2 1126 } 1127 fakeReturns := fake.getStateRangeScanIteratorWithPaginationReturns 1128 return fakeReturns.result1, fakeReturns.result2 1129 } 1130 1131 func (fake *QueryExecutor) GetStateRangeScanIteratorWithPaginationCallCount() int { 1132 fake.getStateRangeScanIteratorWithPaginationMutex.RLock() 1133 defer fake.getStateRangeScanIteratorWithPaginationMutex.RUnlock() 1134 return len(fake.getStateRangeScanIteratorWithPaginationArgsForCall) 1135 } 1136 1137 func (fake *QueryExecutor) GetStateRangeScanIteratorWithPaginationCalls(stub func(string, string, string, int32) (ledgera.QueryResultsIterator, error)) { 1138 fake.getStateRangeScanIteratorWithPaginationMutex.Lock() 1139 defer fake.getStateRangeScanIteratorWithPaginationMutex.Unlock() 1140 fake.GetStateRangeScanIteratorWithPaginationStub = stub 1141 } 1142 1143 func (fake *QueryExecutor) GetStateRangeScanIteratorWithPaginationArgsForCall(i int) (string, string, string, int32) { 1144 fake.getStateRangeScanIteratorWithPaginationMutex.RLock() 1145 defer fake.getStateRangeScanIteratorWithPaginationMutex.RUnlock() 1146 argsForCall := fake.getStateRangeScanIteratorWithPaginationArgsForCall[i] 1147 return argsForCall.arg1, argsForCall.arg2, argsForCall.arg3, argsForCall.arg4 1148 } 1149 1150 func (fake *QueryExecutor) GetStateRangeScanIteratorWithPaginationReturns(result1 ledgera.QueryResultsIterator, result2 error) { 1151 fake.getStateRangeScanIteratorWithPaginationMutex.Lock() 1152 defer fake.getStateRangeScanIteratorWithPaginationMutex.Unlock() 1153 fake.GetStateRangeScanIteratorWithPaginationStub = nil 1154 fake.getStateRangeScanIteratorWithPaginationReturns = struct { 1155 result1 ledgera.QueryResultsIterator 1156 result2 error 1157 }{result1, result2} 1158 } 1159 1160 func (fake *QueryExecutor) GetStateRangeScanIteratorWithPaginationReturnsOnCall(i int, result1 ledgera.QueryResultsIterator, result2 error) { 1161 fake.getStateRangeScanIteratorWithPaginationMutex.Lock() 1162 defer fake.getStateRangeScanIteratorWithPaginationMutex.Unlock() 1163 fake.GetStateRangeScanIteratorWithPaginationStub = nil 1164 if fake.getStateRangeScanIteratorWithPaginationReturnsOnCall == nil { 1165 fake.getStateRangeScanIteratorWithPaginationReturnsOnCall = make(map[int]struct { 1166 result1 ledgera.QueryResultsIterator 1167 result2 error 1168 }) 1169 } 1170 fake.getStateRangeScanIteratorWithPaginationReturnsOnCall[i] = struct { 1171 result1 ledgera.QueryResultsIterator 1172 result2 error 1173 }{result1, result2} 1174 } 1175 1176 func (fake *QueryExecutor) Invocations() map[string][][]interface{} { 1177 fake.invocationsMutex.RLock() 1178 defer fake.invocationsMutex.RUnlock() 1179 fake.doneMutex.RLock() 1180 defer fake.doneMutex.RUnlock() 1181 fake.executeQueryMutex.RLock() 1182 defer fake.executeQueryMutex.RUnlock() 1183 fake.executeQueryOnPrivateDataMutex.RLock() 1184 defer fake.executeQueryOnPrivateDataMutex.RUnlock() 1185 fake.executeQueryWithPaginationMutex.RLock() 1186 defer fake.executeQueryWithPaginationMutex.RUnlock() 1187 fake.getPrivateDataMutex.RLock() 1188 defer fake.getPrivateDataMutex.RUnlock() 1189 fake.getPrivateDataHashMutex.RLock() 1190 defer fake.getPrivateDataHashMutex.RUnlock() 1191 fake.getPrivateDataMetadataMutex.RLock() 1192 defer fake.getPrivateDataMetadataMutex.RUnlock() 1193 fake.getPrivateDataMetadataByHashMutex.RLock() 1194 defer fake.getPrivateDataMetadataByHashMutex.RUnlock() 1195 fake.getPrivateDataMultipleKeysMutex.RLock() 1196 defer fake.getPrivateDataMultipleKeysMutex.RUnlock() 1197 fake.getPrivateDataRangeScanIteratorMutex.RLock() 1198 defer fake.getPrivateDataRangeScanIteratorMutex.RUnlock() 1199 fake.getStateMutex.RLock() 1200 defer fake.getStateMutex.RUnlock() 1201 fake.getStateMetadataMutex.RLock() 1202 defer fake.getStateMetadataMutex.RUnlock() 1203 fake.getStateMultipleKeysMutex.RLock() 1204 defer fake.getStateMultipleKeysMutex.RUnlock() 1205 fake.getStateRangeScanIteratorMutex.RLock() 1206 defer fake.getStateRangeScanIteratorMutex.RUnlock() 1207 fake.getStateRangeScanIteratorWithPaginationMutex.RLock() 1208 defer fake.getStateRangeScanIteratorWithPaginationMutex.RUnlock() 1209 copiedInvocations := map[string][][]interface{}{} 1210 for key, value := range fake.invocations { 1211 copiedInvocations[key] = value 1212 } 1213 return copiedInvocations 1214 } 1215 1216 func (fake *QueryExecutor) recordInvocation(key string, args []interface{}) { 1217 fake.invocationsMutex.Lock() 1218 defer fake.invocationsMutex.Unlock() 1219 if fake.invocations == nil { 1220 fake.invocations = map[string][][]interface{}{} 1221 } 1222 if fake.invocations[key] == nil { 1223 fake.invocations[key] = [][]interface{}{} 1224 } 1225 fake.invocations[key] = append(fake.invocations[key], args) 1226 }