github.com/baptiste-b-pegasys/quorum/v22@v22.4.2/core/mps/mock_interface.go (about) 1 // Code generated by MockGen. DO NOT EDIT. 2 // Source: interface.go 3 4 // Package mps is a generated GoMock package. 5 package mps 6 7 import ( 8 context "context" 9 reflect "reflect" 10 11 common "github.com/ethereum/go-ethereum/common" 12 state "github.com/ethereum/go-ethereum/core/state" 13 types "github.com/ethereum/go-ethereum/core/types" 14 trie "github.com/ethereum/go-ethereum/trie" 15 gomock "github.com/golang/mock/gomock" 16 ) 17 18 // MockPrivateStateManager is a mock of PrivateStateManager interface. 19 type MockPrivateStateManager struct { 20 ctrl *gomock.Controller 21 recorder *MockPrivateStateManagerMockRecorder 22 } 23 24 // MockPrivateStateManagerMockRecorder is the mock recorder for MockPrivateStateManager. 25 type MockPrivateStateManagerMockRecorder struct { 26 mock *MockPrivateStateManager 27 } 28 29 // NewMockPrivateStateManager creates a new mock instance. 30 func NewMockPrivateStateManager(ctrl *gomock.Controller) *MockPrivateStateManager { 31 mock := &MockPrivateStateManager{ctrl: ctrl} 32 mock.recorder = &MockPrivateStateManagerMockRecorder{mock} 33 return mock 34 } 35 36 // EXPECT returns an object that allows the caller to indicate expected use. 37 func (m *MockPrivateStateManager) EXPECT() *MockPrivateStateManagerMockRecorder { 38 return m.recorder 39 } 40 41 // CheckAt mocks base method. 42 func (m *MockPrivateStateManager) CheckAt(blockHash common.Hash) error { 43 m.ctrl.T.Helper() 44 ret := m.ctrl.Call(m, "CheckAt", blockHash) 45 ret0, _ := ret[0].(error) 46 return ret0 47 } 48 49 // CheckAt indicates an expected call of CheckAt. 50 func (mr *MockPrivateStateManagerMockRecorder) CheckAt(blockHash interface{}) *gomock.Call { 51 mr.mock.ctrl.T.Helper() 52 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CheckAt", reflect.TypeOf((*MockPrivateStateManager)(nil).CheckAt), blockHash) 53 } 54 55 // NotIncludeAny mocks base method. 56 func (m *MockPrivateStateManager) NotIncludeAny(psm *PrivateStateMetadata, managedParties ...string) bool { 57 m.ctrl.T.Helper() 58 varargs := []interface{}{psm} 59 for _, a := range managedParties { 60 varargs = append(varargs, a) 61 } 62 ret := m.ctrl.Call(m, "NotIncludeAny", varargs...) 63 ret0, _ := ret[0].(bool) 64 return ret0 65 } 66 67 // NotIncludeAny indicates an expected call of NotIncludeAny. 68 func (mr *MockPrivateStateManagerMockRecorder) NotIncludeAny(psm interface{}, managedParties ...interface{}) *gomock.Call { 69 mr.mock.ctrl.T.Helper() 70 varargs := append([]interface{}{psm}, managedParties...) 71 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotIncludeAny", reflect.TypeOf((*MockPrivateStateManager)(nil).NotIncludeAny), varargs...) 72 } 73 74 // PSIs mocks base method. 75 func (m *MockPrivateStateManager) PSIs() []types.PrivateStateIdentifier { 76 m.ctrl.T.Helper() 77 ret := m.ctrl.Call(m, "PSIs") 78 ret0, _ := ret[0].([]types.PrivateStateIdentifier) 79 return ret0 80 } 81 82 // PSIs indicates an expected call of PSIs. 83 func (mr *MockPrivateStateManagerMockRecorder) PSIs() *gomock.Call { 84 mr.mock.ctrl.T.Helper() 85 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PSIs", reflect.TypeOf((*MockPrivateStateManager)(nil).PSIs)) 86 } 87 88 // ResolveForManagedParty mocks base method. 89 func (m *MockPrivateStateManager) ResolveForManagedParty(managedParty string) (*PrivateStateMetadata, error) { 90 m.ctrl.T.Helper() 91 ret := m.ctrl.Call(m, "ResolveForManagedParty", managedParty) 92 ret0, _ := ret[0].(*PrivateStateMetadata) 93 ret1, _ := ret[1].(error) 94 return ret0, ret1 95 } 96 97 // ResolveForManagedParty indicates an expected call of ResolveForManagedParty. 98 func (mr *MockPrivateStateManagerMockRecorder) ResolveForManagedParty(managedParty interface{}) *gomock.Call { 99 mr.mock.ctrl.T.Helper() 100 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveForManagedParty", reflect.TypeOf((*MockPrivateStateManager)(nil).ResolveForManagedParty), managedParty) 101 } 102 103 // ResolveForUserContext mocks base method. 104 func (m *MockPrivateStateManager) ResolveForUserContext(ctx context.Context) (*PrivateStateMetadata, error) { 105 m.ctrl.T.Helper() 106 ret := m.ctrl.Call(m, "ResolveForUserContext", ctx) 107 ret0, _ := ret[0].(*PrivateStateMetadata) 108 ret1, _ := ret[1].(error) 109 return ret0, ret1 110 } 111 112 // ResolveForUserContext indicates an expected call of ResolveForUserContext. 113 func (mr *MockPrivateStateManagerMockRecorder) ResolveForUserContext(ctx interface{}) *gomock.Call { 114 mr.mock.ctrl.T.Helper() 115 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveForUserContext", reflect.TypeOf((*MockPrivateStateManager)(nil).ResolveForUserContext), ctx) 116 } 117 118 // StateRepository mocks base method. 119 func (m *MockPrivateStateManager) StateRepository(blockHash common.Hash) (PrivateStateRepository, error) { 120 m.ctrl.T.Helper() 121 ret := m.ctrl.Call(m, "StateRepository", blockHash) 122 ret0, _ := ret[0].(PrivateStateRepository) 123 ret1, _ := ret[1].(error) 124 return ret0, ret1 125 } 126 127 // StateRepository indicates an expected call of StateRepository. 128 func (mr *MockPrivateStateManagerMockRecorder) StateRepository(blockHash interface{}) *gomock.Call { 129 mr.mock.ctrl.T.Helper() 130 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StateRepository", reflect.TypeOf((*MockPrivateStateManager)(nil).StateRepository), blockHash) 131 } 132 133 // TrieDB mocks base method. 134 func (m *MockPrivateStateManager) TrieDB() *trie.Database { 135 m.ctrl.T.Helper() 136 ret := m.ctrl.Call(m, "TrieDB") 137 ret0, _ := ret[0].(*trie.Database) 138 return ret0 139 } 140 141 // TrieDB indicates an expected call of TrieDB. 142 func (mr *MockPrivateStateManagerMockRecorder) TrieDB() *gomock.Call { 143 mr.mock.ctrl.T.Helper() 144 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "TrieDB", reflect.TypeOf((*MockPrivateStateManager)(nil).TrieDB)) 145 } 146 147 // MockPrivateStateMetadataResolver is a mock of PrivateStateMetadataResolver interface. 148 type MockPrivateStateMetadataResolver struct { 149 ctrl *gomock.Controller 150 recorder *MockPrivateStateMetadataResolverMockRecorder 151 } 152 153 // MockPrivateStateMetadataResolverMockRecorder is the mock recorder for MockPrivateStateMetadataResolver. 154 type MockPrivateStateMetadataResolverMockRecorder struct { 155 mock *MockPrivateStateMetadataResolver 156 } 157 158 // NewMockPrivateStateMetadataResolver creates a new mock instance. 159 func NewMockPrivateStateMetadataResolver(ctrl *gomock.Controller) *MockPrivateStateMetadataResolver { 160 mock := &MockPrivateStateMetadataResolver{ctrl: ctrl} 161 mock.recorder = &MockPrivateStateMetadataResolverMockRecorder{mock} 162 return mock 163 } 164 165 // EXPECT returns an object that allows the caller to indicate expected use. 166 func (m *MockPrivateStateMetadataResolver) EXPECT() *MockPrivateStateMetadataResolverMockRecorder { 167 return m.recorder 168 } 169 170 // NotIncludeAny mocks base method. 171 func (m *MockPrivateStateMetadataResolver) NotIncludeAny(psm *PrivateStateMetadata, managedParties ...string) bool { 172 m.ctrl.T.Helper() 173 varargs := []interface{}{psm} 174 for _, a := range managedParties { 175 varargs = append(varargs, a) 176 } 177 ret := m.ctrl.Call(m, "NotIncludeAny", varargs...) 178 ret0, _ := ret[0].(bool) 179 return ret0 180 } 181 182 // NotIncludeAny indicates an expected call of NotIncludeAny. 183 func (mr *MockPrivateStateMetadataResolverMockRecorder) NotIncludeAny(psm interface{}, managedParties ...interface{}) *gomock.Call { 184 mr.mock.ctrl.T.Helper() 185 varargs := append([]interface{}{psm}, managedParties...) 186 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NotIncludeAny", reflect.TypeOf((*MockPrivateStateMetadataResolver)(nil).NotIncludeAny), varargs...) 187 } 188 189 // PSIs mocks base method. 190 func (m *MockPrivateStateMetadataResolver) PSIs() []types.PrivateStateIdentifier { 191 m.ctrl.T.Helper() 192 ret := m.ctrl.Call(m, "PSIs") 193 ret0, _ := ret[0].([]types.PrivateStateIdentifier) 194 return ret0 195 } 196 197 // PSIs indicates an expected call of PSIs. 198 func (mr *MockPrivateStateMetadataResolverMockRecorder) PSIs() *gomock.Call { 199 mr.mock.ctrl.T.Helper() 200 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PSIs", reflect.TypeOf((*MockPrivateStateMetadataResolver)(nil).PSIs)) 201 } 202 203 // ResolveForManagedParty mocks base method. 204 func (m *MockPrivateStateMetadataResolver) ResolveForManagedParty(managedParty string) (*PrivateStateMetadata, error) { 205 m.ctrl.T.Helper() 206 ret := m.ctrl.Call(m, "ResolveForManagedParty", managedParty) 207 ret0, _ := ret[0].(*PrivateStateMetadata) 208 ret1, _ := ret[1].(error) 209 return ret0, ret1 210 } 211 212 // ResolveForManagedParty indicates an expected call of ResolveForManagedParty. 213 func (mr *MockPrivateStateMetadataResolverMockRecorder) ResolveForManagedParty(managedParty interface{}) *gomock.Call { 214 mr.mock.ctrl.T.Helper() 215 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveForManagedParty", reflect.TypeOf((*MockPrivateStateMetadataResolver)(nil).ResolveForManagedParty), managedParty) 216 } 217 218 // ResolveForUserContext mocks base method. 219 func (m *MockPrivateStateMetadataResolver) ResolveForUserContext(ctx context.Context) (*PrivateStateMetadata, error) { 220 m.ctrl.T.Helper() 221 ret := m.ctrl.Call(m, "ResolveForUserContext", ctx) 222 ret0, _ := ret[0].(*PrivateStateMetadata) 223 ret1, _ := ret[1].(error) 224 return ret0, ret1 225 } 226 227 // ResolveForUserContext indicates an expected call of ResolveForUserContext. 228 func (mr *MockPrivateStateMetadataResolverMockRecorder) ResolveForUserContext(ctx interface{}) *gomock.Call { 229 mr.mock.ctrl.T.Helper() 230 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "ResolveForUserContext", reflect.TypeOf((*MockPrivateStateMetadataResolver)(nil).ResolveForUserContext), ctx) 231 } 232 233 // MockPrivateStateRepository is a mock of PrivateStateRepository interface. 234 type MockPrivateStateRepository struct { 235 ctrl *gomock.Controller 236 recorder *MockPrivateStateRepositoryMockRecorder 237 } 238 239 // MockPrivateStateRepositoryMockRecorder is the mock recorder for MockPrivateStateRepository. 240 type MockPrivateStateRepositoryMockRecorder struct { 241 mock *MockPrivateStateRepository 242 } 243 244 // NewMockPrivateStateRepository creates a new mock instance. 245 func NewMockPrivateStateRepository(ctrl *gomock.Controller) *MockPrivateStateRepository { 246 mock := &MockPrivateStateRepository{ctrl: ctrl} 247 mock.recorder = &MockPrivateStateRepositoryMockRecorder{mock} 248 return mock 249 } 250 251 // EXPECT returns an object that allows the caller to indicate expected use. 252 func (m *MockPrivateStateRepository) EXPECT() *MockPrivateStateRepositoryMockRecorder { 253 return m.recorder 254 } 255 256 // Commit mocks base method. 257 func (m *MockPrivateStateRepository) Commit(isEIP158 bool, block *types.Block) error { 258 m.ctrl.T.Helper() 259 ret := m.ctrl.Call(m, "Commit", isEIP158, block) 260 ret0, _ := ret[0].(error) 261 return ret0 262 } 263 264 // Commit indicates an expected call of Commit. 265 func (mr *MockPrivateStateRepositoryMockRecorder) Commit(isEIP158, block interface{}) *gomock.Call { 266 mr.mock.ctrl.T.Helper() 267 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Commit", reflect.TypeOf((*MockPrivateStateRepository)(nil).Commit), isEIP158, block) 268 } 269 270 // CommitAndWrite mocks base method. 271 func (m *MockPrivateStateRepository) CommitAndWrite(isEIP158 bool, block *types.Block) error { 272 m.ctrl.T.Helper() 273 ret := m.ctrl.Call(m, "CommitAndWrite", isEIP158, block) 274 ret0, _ := ret[0].(error) 275 return ret0 276 } 277 278 // CommitAndWrite indicates an expected call of CommitAndWrite. 279 func (mr *MockPrivateStateRepositoryMockRecorder) CommitAndWrite(isEIP158, block interface{}) *gomock.Call { 280 mr.mock.ctrl.T.Helper() 281 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CommitAndWrite", reflect.TypeOf((*MockPrivateStateRepository)(nil).CommitAndWrite), isEIP158, block) 282 } 283 284 // Copy mocks base method. 285 func (m *MockPrivateStateRepository) Copy() PrivateStateRepository { 286 m.ctrl.T.Helper() 287 ret := m.ctrl.Call(m, "Copy") 288 ret0, _ := ret[0].(PrivateStateRepository) 289 return ret0 290 } 291 292 // Copy indicates an expected call of Copy. 293 func (mr *MockPrivateStateRepositoryMockRecorder) Copy() *gomock.Call { 294 mr.mock.ctrl.T.Helper() 295 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Copy", reflect.TypeOf((*MockPrivateStateRepository)(nil).Copy)) 296 } 297 298 // DefaultState mocks base method. 299 func (m *MockPrivateStateRepository) DefaultState() (*state.StateDB, error) { 300 m.ctrl.T.Helper() 301 ret := m.ctrl.Call(m, "DefaultState") 302 ret0, _ := ret[0].(*state.StateDB) 303 ret1, _ := ret[1].(error) 304 return ret0, ret1 305 } 306 307 // DefaultState indicates an expected call of DefaultState. 308 func (mr *MockPrivateStateRepositoryMockRecorder) DefaultState() *gomock.Call { 309 mr.mock.ctrl.T.Helper() 310 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultState", reflect.TypeOf((*MockPrivateStateRepository)(nil).DefaultState)) 311 } 312 313 // DefaultStateMetadata mocks base method. 314 func (m *MockPrivateStateRepository) DefaultStateMetadata() *PrivateStateMetadata { 315 m.ctrl.T.Helper() 316 ret := m.ctrl.Call(m, "DefaultStateMetadata") 317 ret0, _ := ret[0].(*PrivateStateMetadata) 318 return ret0 319 } 320 321 // DefaultStateMetadata indicates an expected call of DefaultStateMetadata. 322 func (mr *MockPrivateStateRepositoryMockRecorder) DefaultStateMetadata() *gomock.Call { 323 mr.mock.ctrl.T.Helper() 324 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "DefaultStateMetadata", reflect.TypeOf((*MockPrivateStateRepository)(nil).DefaultStateMetadata)) 325 } 326 327 // IsMPS mocks base method. 328 func (m *MockPrivateStateRepository) IsMPS() bool { 329 m.ctrl.T.Helper() 330 ret := m.ctrl.Call(m, "IsMPS") 331 ret0, _ := ret[0].(bool) 332 return ret0 333 } 334 335 // IsMPS indicates an expected call of IsMPS. 336 func (mr *MockPrivateStateRepositoryMockRecorder) IsMPS() *gomock.Call { 337 mr.mock.ctrl.T.Helper() 338 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsMPS", reflect.TypeOf((*MockPrivateStateRepository)(nil).IsMPS)) 339 } 340 341 // MergeReceipts mocks base method. 342 func (m *MockPrivateStateRepository) MergeReceipts(pub, priv types.Receipts) types.Receipts { 343 m.ctrl.T.Helper() 344 ret := m.ctrl.Call(m, "MergeReceipts", pub, priv) 345 ret0, _ := ret[0].(types.Receipts) 346 return ret0 347 } 348 349 // MergeReceipts indicates an expected call of MergeReceipts. 350 func (mr *MockPrivateStateRepositoryMockRecorder) MergeReceipts(pub, priv interface{}) *gomock.Call { 351 mr.mock.ctrl.T.Helper() 352 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "MergeReceipts", reflect.TypeOf((*MockPrivateStateRepository)(nil).MergeReceipts), pub, priv) 353 } 354 355 // PrivateStateRoot mocks base method. 356 func (m *MockPrivateStateRepository) PrivateStateRoot(psi types.PrivateStateIdentifier) (common.Hash, error) { 357 m.ctrl.T.Helper() 358 ret := m.ctrl.Call(m, "PrivateStateRoot", psi) 359 ret0, _ := ret[0].(common.Hash) 360 ret1, _ := ret[1].(error) 361 return ret0, ret1 362 } 363 364 // PrivateStateRoot indicates an expected call of PrivateStateRoot. 365 func (mr *MockPrivateStateRepositoryMockRecorder) PrivateStateRoot(psi interface{}) *gomock.Call { 366 mr.mock.ctrl.T.Helper() 367 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrivateStateRoot", reflect.TypeOf((*MockPrivateStateRepository)(nil).PrivateStateRoot), psi) 368 } 369 370 // Reset mocks base method. 371 func (m *MockPrivateStateRepository) Reset() error { 372 m.ctrl.T.Helper() 373 ret := m.ctrl.Call(m, "Reset") 374 ret0, _ := ret[0].(error) 375 return ret0 376 } 377 378 // Reset indicates an expected call of Reset. 379 func (mr *MockPrivateStateRepositoryMockRecorder) Reset() *gomock.Call { 380 mr.mock.ctrl.T.Helper() 381 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Reset", reflect.TypeOf((*MockPrivateStateRepository)(nil).Reset)) 382 } 383 384 // StatePSI mocks base method. 385 func (m *MockPrivateStateRepository) StatePSI(psi types.PrivateStateIdentifier) (*state.StateDB, error) { 386 m.ctrl.T.Helper() 387 ret := m.ctrl.Call(m, "StatePSI", psi) 388 ret0, _ := ret[0].(*state.StateDB) 389 ret1, _ := ret[1].(error) 390 return ret0, ret1 391 } 392 393 // StatePSI indicates an expected call of StatePSI. 394 func (mr *MockPrivateStateRepositoryMockRecorder) StatePSI(psi interface{}) *gomock.Call { 395 mr.mock.ctrl.T.Helper() 396 return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "StatePSI", reflect.TypeOf((*MockPrivateStateRepository)(nil).StatePSI), psi) 397 }