github.com/osdi23p228/fabric@v0.0.0-20221218062954-77808885f5db/core/chaincode/mock/peer_ledger.go (about)

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