github.com/true-sqn/fabric@v2.1.1+incompatible/core/ledger/mock/tx_simulator.go (about)

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