github.com/enbility/spine-go@v0.7.0/mocks/SenderInterface.go (about) 1 // Code generated by mockery v2.45.0. DO NOT EDIT. 2 3 package mocks 4 5 import ( 6 model "github.com/enbility/spine-go/model" 7 mock "github.com/stretchr/testify/mock" 8 ) 9 10 // SenderInterface is an autogenerated mock type for the SenderInterface type 11 type SenderInterface struct { 12 mock.Mock 13 } 14 15 type SenderInterface_Expecter struct { 16 mock *mock.Mock 17 } 18 19 func (_m *SenderInterface) EXPECT() *SenderInterface_Expecter { 20 return &SenderInterface_Expecter{mock: &_m.Mock} 21 } 22 23 // Bind provides a mock function with given fields: senderAddress, destinationAddress, serverFeatureType 24 func (_m *SenderInterface) Bind(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, serverFeatureType model.FeatureTypeType) (*model.MsgCounterType, error) { 25 ret := _m.Called(senderAddress, destinationAddress, serverFeatureType) 26 27 if len(ret) == 0 { 28 panic("no return value specified for Bind") 29 } 30 31 var r0 *model.MsgCounterType 32 var r1 error 33 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) (*model.MsgCounterType, error)); ok { 34 return rf(senderAddress, destinationAddress, serverFeatureType) 35 } 36 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) *model.MsgCounterType); ok { 37 r0 = rf(senderAddress, destinationAddress, serverFeatureType) 38 } else { 39 if ret.Get(0) != nil { 40 r0 = ret.Get(0).(*model.MsgCounterType) 41 } 42 } 43 44 if rf, ok := ret.Get(1).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) error); ok { 45 r1 = rf(senderAddress, destinationAddress, serverFeatureType) 46 } else { 47 r1 = ret.Error(1) 48 } 49 50 return r0, r1 51 } 52 53 // SenderInterface_Bind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Bind' 54 type SenderInterface_Bind_Call struct { 55 *mock.Call 56 } 57 58 // Bind is a helper method to define mock.On call 59 // - senderAddress *model.FeatureAddressType 60 // - destinationAddress *model.FeatureAddressType 61 // - serverFeatureType model.FeatureTypeType 62 func (_e *SenderInterface_Expecter) Bind(senderAddress interface{}, destinationAddress interface{}, serverFeatureType interface{}) *SenderInterface_Bind_Call { 63 return &SenderInterface_Bind_Call{Call: _e.mock.On("Bind", senderAddress, destinationAddress, serverFeatureType)} 64 } 65 66 func (_c *SenderInterface_Bind_Call) Run(run func(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, serverFeatureType model.FeatureTypeType)) *SenderInterface_Bind_Call { 67 _c.Call.Run(func(args mock.Arguments) { 68 run(args[0].(*model.FeatureAddressType), args[1].(*model.FeatureAddressType), args[2].(model.FeatureTypeType)) 69 }) 70 return _c 71 } 72 73 func (_c *SenderInterface_Bind_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Bind_Call { 74 _c.Call.Return(_a0, _a1) 75 return _c 76 } 77 78 func (_c *SenderInterface_Bind_Call) RunAndReturn(run func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) (*model.MsgCounterType, error)) *SenderInterface_Bind_Call { 79 _c.Call.Return(run) 80 return _c 81 } 82 83 // DatagramForMsgCounter provides a mock function with given fields: msgCounter 84 func (_m *SenderInterface) DatagramForMsgCounter(msgCounter model.MsgCounterType) (model.DatagramType, error) { 85 ret := _m.Called(msgCounter) 86 87 if len(ret) == 0 { 88 panic("no return value specified for DatagramForMsgCounter") 89 } 90 91 var r0 model.DatagramType 92 var r1 error 93 if rf, ok := ret.Get(0).(func(model.MsgCounterType) (model.DatagramType, error)); ok { 94 return rf(msgCounter) 95 } 96 if rf, ok := ret.Get(0).(func(model.MsgCounterType) model.DatagramType); ok { 97 r0 = rf(msgCounter) 98 } else { 99 r0 = ret.Get(0).(model.DatagramType) 100 } 101 102 if rf, ok := ret.Get(1).(func(model.MsgCounterType) error); ok { 103 r1 = rf(msgCounter) 104 } else { 105 r1 = ret.Error(1) 106 } 107 108 return r0, r1 109 } 110 111 // SenderInterface_DatagramForMsgCounter_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DatagramForMsgCounter' 112 type SenderInterface_DatagramForMsgCounter_Call struct { 113 *mock.Call 114 } 115 116 // DatagramForMsgCounter is a helper method to define mock.On call 117 // - msgCounter model.MsgCounterType 118 func (_e *SenderInterface_Expecter) DatagramForMsgCounter(msgCounter interface{}) *SenderInterface_DatagramForMsgCounter_Call { 119 return &SenderInterface_DatagramForMsgCounter_Call{Call: _e.mock.On("DatagramForMsgCounter", msgCounter)} 120 } 121 122 func (_c *SenderInterface_DatagramForMsgCounter_Call) Run(run func(msgCounter model.MsgCounterType)) *SenderInterface_DatagramForMsgCounter_Call { 123 _c.Call.Run(func(args mock.Arguments) { 124 run(args[0].(model.MsgCounterType)) 125 }) 126 return _c 127 } 128 129 func (_c *SenderInterface_DatagramForMsgCounter_Call) Return(_a0 model.DatagramType, _a1 error) *SenderInterface_DatagramForMsgCounter_Call { 130 _c.Call.Return(_a0, _a1) 131 return _c 132 } 133 134 func (_c *SenderInterface_DatagramForMsgCounter_Call) RunAndReturn(run func(model.MsgCounterType) (model.DatagramType, error)) *SenderInterface_DatagramForMsgCounter_Call { 135 _c.Call.Return(run) 136 return _c 137 } 138 139 // Notify provides a mock function with given fields: senderAddress, destinationAddress, cmd 140 func (_m *SenderInterface) Notify(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, cmd model.CmdType) (*model.MsgCounterType, error) { 141 ret := _m.Called(senderAddress, destinationAddress, cmd) 142 143 if len(ret) == 0 { 144 panic("no return value specified for Notify") 145 } 146 147 var r0 *model.MsgCounterType 148 var r1 error 149 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) (*model.MsgCounterType, error)); ok { 150 return rf(senderAddress, destinationAddress, cmd) 151 } 152 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) *model.MsgCounterType); ok { 153 r0 = rf(senderAddress, destinationAddress, cmd) 154 } else { 155 if ret.Get(0) != nil { 156 r0 = ret.Get(0).(*model.MsgCounterType) 157 } 158 } 159 160 if rf, ok := ret.Get(1).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) error); ok { 161 r1 = rf(senderAddress, destinationAddress, cmd) 162 } else { 163 r1 = ret.Error(1) 164 } 165 166 return r0, r1 167 } 168 169 // SenderInterface_Notify_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Notify' 170 type SenderInterface_Notify_Call struct { 171 *mock.Call 172 } 173 174 // Notify is a helper method to define mock.On call 175 // - senderAddress *model.FeatureAddressType 176 // - destinationAddress *model.FeatureAddressType 177 // - cmd model.CmdType 178 func (_e *SenderInterface_Expecter) Notify(senderAddress interface{}, destinationAddress interface{}, cmd interface{}) *SenderInterface_Notify_Call { 179 return &SenderInterface_Notify_Call{Call: _e.mock.On("Notify", senderAddress, destinationAddress, cmd)} 180 } 181 182 func (_c *SenderInterface_Notify_Call) Run(run func(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, cmd model.CmdType)) *SenderInterface_Notify_Call { 183 _c.Call.Run(func(args mock.Arguments) { 184 run(args[0].(*model.FeatureAddressType), args[1].(*model.FeatureAddressType), args[2].(model.CmdType)) 185 }) 186 return _c 187 } 188 189 func (_c *SenderInterface_Notify_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Notify_Call { 190 _c.Call.Return(_a0, _a1) 191 return _c 192 } 193 194 func (_c *SenderInterface_Notify_Call) RunAndReturn(run func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) (*model.MsgCounterType, error)) *SenderInterface_Notify_Call { 195 _c.Call.Return(run) 196 return _c 197 } 198 199 // ProcessResponseForMsgCounterReference provides a mock function with given fields: msgCounterRef 200 func (_m *SenderInterface) ProcessResponseForMsgCounterReference(msgCounterRef *model.MsgCounterType) { 201 _m.Called(msgCounterRef) 202 } 203 204 // SenderInterface_ProcessResponseForMsgCounterReference_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProcessResponseForMsgCounterReference' 205 type SenderInterface_ProcessResponseForMsgCounterReference_Call struct { 206 *mock.Call 207 } 208 209 // ProcessResponseForMsgCounterReference is a helper method to define mock.On call 210 // - msgCounterRef *model.MsgCounterType 211 func (_e *SenderInterface_Expecter) ProcessResponseForMsgCounterReference(msgCounterRef interface{}) *SenderInterface_ProcessResponseForMsgCounterReference_Call { 212 return &SenderInterface_ProcessResponseForMsgCounterReference_Call{Call: _e.mock.On("ProcessResponseForMsgCounterReference", msgCounterRef)} 213 } 214 215 func (_c *SenderInterface_ProcessResponseForMsgCounterReference_Call) Run(run func(msgCounterRef *model.MsgCounterType)) *SenderInterface_ProcessResponseForMsgCounterReference_Call { 216 _c.Call.Run(func(args mock.Arguments) { 217 run(args[0].(*model.MsgCounterType)) 218 }) 219 return _c 220 } 221 222 func (_c *SenderInterface_ProcessResponseForMsgCounterReference_Call) Return() *SenderInterface_ProcessResponseForMsgCounterReference_Call { 223 _c.Call.Return() 224 return _c 225 } 226 227 func (_c *SenderInterface_ProcessResponseForMsgCounterReference_Call) RunAndReturn(run func(*model.MsgCounterType)) *SenderInterface_ProcessResponseForMsgCounterReference_Call { 228 _c.Call.Return(run) 229 return _c 230 } 231 232 // Reply provides a mock function with given fields: requestHeader, senderAddress, cmd 233 func (_m *SenderInterface) Reply(requestHeader *model.HeaderType, senderAddress *model.FeatureAddressType, cmd model.CmdType) error { 234 ret := _m.Called(requestHeader, senderAddress, cmd) 235 236 if len(ret) == 0 { 237 panic("no return value specified for Reply") 238 } 239 240 var r0 error 241 if rf, ok := ret.Get(0).(func(*model.HeaderType, *model.FeatureAddressType, model.CmdType) error); ok { 242 r0 = rf(requestHeader, senderAddress, cmd) 243 } else { 244 r0 = ret.Error(0) 245 } 246 247 return r0 248 } 249 250 // SenderInterface_Reply_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Reply' 251 type SenderInterface_Reply_Call struct { 252 *mock.Call 253 } 254 255 // Reply is a helper method to define mock.On call 256 // - requestHeader *model.HeaderType 257 // - senderAddress *model.FeatureAddressType 258 // - cmd model.CmdType 259 func (_e *SenderInterface_Expecter) Reply(requestHeader interface{}, senderAddress interface{}, cmd interface{}) *SenderInterface_Reply_Call { 260 return &SenderInterface_Reply_Call{Call: _e.mock.On("Reply", requestHeader, senderAddress, cmd)} 261 } 262 263 func (_c *SenderInterface_Reply_Call) Run(run func(requestHeader *model.HeaderType, senderAddress *model.FeatureAddressType, cmd model.CmdType)) *SenderInterface_Reply_Call { 264 _c.Call.Run(func(args mock.Arguments) { 265 run(args[0].(*model.HeaderType), args[1].(*model.FeatureAddressType), args[2].(model.CmdType)) 266 }) 267 return _c 268 } 269 270 func (_c *SenderInterface_Reply_Call) Return(_a0 error) *SenderInterface_Reply_Call { 271 _c.Call.Return(_a0) 272 return _c 273 } 274 275 func (_c *SenderInterface_Reply_Call) RunAndReturn(run func(*model.HeaderType, *model.FeatureAddressType, model.CmdType) error) *SenderInterface_Reply_Call { 276 _c.Call.Return(run) 277 return _c 278 } 279 280 // Request provides a mock function with given fields: cmdClassifier, senderAddress, destinationAddress, ackRequest, cmd 281 func (_m *SenderInterface) Request(cmdClassifier model.CmdClassifierType, senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, ackRequest bool, cmd []model.CmdType) (*model.MsgCounterType, error) { 282 ret := _m.Called(cmdClassifier, senderAddress, destinationAddress, ackRequest, cmd) 283 284 if len(ret) == 0 { 285 panic("no return value specified for Request") 286 } 287 288 var r0 *model.MsgCounterType 289 var r1 error 290 if rf, ok := ret.Get(0).(func(model.CmdClassifierType, *model.FeatureAddressType, *model.FeatureAddressType, bool, []model.CmdType) (*model.MsgCounterType, error)); ok { 291 return rf(cmdClassifier, senderAddress, destinationAddress, ackRequest, cmd) 292 } 293 if rf, ok := ret.Get(0).(func(model.CmdClassifierType, *model.FeatureAddressType, *model.FeatureAddressType, bool, []model.CmdType) *model.MsgCounterType); ok { 294 r0 = rf(cmdClassifier, senderAddress, destinationAddress, ackRequest, cmd) 295 } else { 296 if ret.Get(0) != nil { 297 r0 = ret.Get(0).(*model.MsgCounterType) 298 } 299 } 300 301 if rf, ok := ret.Get(1).(func(model.CmdClassifierType, *model.FeatureAddressType, *model.FeatureAddressType, bool, []model.CmdType) error); ok { 302 r1 = rf(cmdClassifier, senderAddress, destinationAddress, ackRequest, cmd) 303 } else { 304 r1 = ret.Error(1) 305 } 306 307 return r0, r1 308 } 309 310 // SenderInterface_Request_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Request' 311 type SenderInterface_Request_Call struct { 312 *mock.Call 313 } 314 315 // Request is a helper method to define mock.On call 316 // - cmdClassifier model.CmdClassifierType 317 // - senderAddress *model.FeatureAddressType 318 // - destinationAddress *model.FeatureAddressType 319 // - ackRequest bool 320 // - cmd []model.CmdType 321 func (_e *SenderInterface_Expecter) Request(cmdClassifier interface{}, senderAddress interface{}, destinationAddress interface{}, ackRequest interface{}, cmd interface{}) *SenderInterface_Request_Call { 322 return &SenderInterface_Request_Call{Call: _e.mock.On("Request", cmdClassifier, senderAddress, destinationAddress, ackRequest, cmd)} 323 } 324 325 func (_c *SenderInterface_Request_Call) Run(run func(cmdClassifier model.CmdClassifierType, senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, ackRequest bool, cmd []model.CmdType)) *SenderInterface_Request_Call { 326 _c.Call.Run(func(args mock.Arguments) { 327 run(args[0].(model.CmdClassifierType), args[1].(*model.FeatureAddressType), args[2].(*model.FeatureAddressType), args[3].(bool), args[4].([]model.CmdType)) 328 }) 329 return _c 330 } 331 332 func (_c *SenderInterface_Request_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Request_Call { 333 _c.Call.Return(_a0, _a1) 334 return _c 335 } 336 337 func (_c *SenderInterface_Request_Call) RunAndReturn(run func(model.CmdClassifierType, *model.FeatureAddressType, *model.FeatureAddressType, bool, []model.CmdType) (*model.MsgCounterType, error)) *SenderInterface_Request_Call { 338 _c.Call.Return(run) 339 return _c 340 } 341 342 // ResultError provides a mock function with given fields: requestHeader, senderAddress, err 343 func (_m *SenderInterface) ResultError(requestHeader *model.HeaderType, senderAddress *model.FeatureAddressType, err *model.ErrorType) error { 344 ret := _m.Called(requestHeader, senderAddress, err) 345 346 if len(ret) == 0 { 347 panic("no return value specified for ResultError") 348 } 349 350 var r0 error 351 if rf, ok := ret.Get(0).(func(*model.HeaderType, *model.FeatureAddressType, *model.ErrorType) error); ok { 352 r0 = rf(requestHeader, senderAddress, err) 353 } else { 354 r0 = ret.Error(0) 355 } 356 357 return r0 358 } 359 360 // SenderInterface_ResultError_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResultError' 361 type SenderInterface_ResultError_Call struct { 362 *mock.Call 363 } 364 365 // ResultError is a helper method to define mock.On call 366 // - requestHeader *model.HeaderType 367 // - senderAddress *model.FeatureAddressType 368 // - err *model.ErrorType 369 func (_e *SenderInterface_Expecter) ResultError(requestHeader interface{}, senderAddress interface{}, err interface{}) *SenderInterface_ResultError_Call { 370 return &SenderInterface_ResultError_Call{Call: _e.mock.On("ResultError", requestHeader, senderAddress, err)} 371 } 372 373 func (_c *SenderInterface_ResultError_Call) Run(run func(requestHeader *model.HeaderType, senderAddress *model.FeatureAddressType, err *model.ErrorType)) *SenderInterface_ResultError_Call { 374 _c.Call.Run(func(args mock.Arguments) { 375 run(args[0].(*model.HeaderType), args[1].(*model.FeatureAddressType), args[2].(*model.ErrorType)) 376 }) 377 return _c 378 } 379 380 func (_c *SenderInterface_ResultError_Call) Return(_a0 error) *SenderInterface_ResultError_Call { 381 _c.Call.Return(_a0) 382 return _c 383 } 384 385 func (_c *SenderInterface_ResultError_Call) RunAndReturn(run func(*model.HeaderType, *model.FeatureAddressType, *model.ErrorType) error) *SenderInterface_ResultError_Call { 386 _c.Call.Return(run) 387 return _c 388 } 389 390 // ResultSuccess provides a mock function with given fields: requestHeader, senderAddress 391 func (_m *SenderInterface) ResultSuccess(requestHeader *model.HeaderType, senderAddress *model.FeatureAddressType) error { 392 ret := _m.Called(requestHeader, senderAddress) 393 394 if len(ret) == 0 { 395 panic("no return value specified for ResultSuccess") 396 } 397 398 var r0 error 399 if rf, ok := ret.Get(0).(func(*model.HeaderType, *model.FeatureAddressType) error); ok { 400 r0 = rf(requestHeader, senderAddress) 401 } else { 402 r0 = ret.Error(0) 403 } 404 405 return r0 406 } 407 408 // SenderInterface_ResultSuccess_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ResultSuccess' 409 type SenderInterface_ResultSuccess_Call struct { 410 *mock.Call 411 } 412 413 // ResultSuccess is a helper method to define mock.On call 414 // - requestHeader *model.HeaderType 415 // - senderAddress *model.FeatureAddressType 416 func (_e *SenderInterface_Expecter) ResultSuccess(requestHeader interface{}, senderAddress interface{}) *SenderInterface_ResultSuccess_Call { 417 return &SenderInterface_ResultSuccess_Call{Call: _e.mock.On("ResultSuccess", requestHeader, senderAddress)} 418 } 419 420 func (_c *SenderInterface_ResultSuccess_Call) Run(run func(requestHeader *model.HeaderType, senderAddress *model.FeatureAddressType)) *SenderInterface_ResultSuccess_Call { 421 _c.Call.Run(func(args mock.Arguments) { 422 run(args[0].(*model.HeaderType), args[1].(*model.FeatureAddressType)) 423 }) 424 return _c 425 } 426 427 func (_c *SenderInterface_ResultSuccess_Call) Return(_a0 error) *SenderInterface_ResultSuccess_Call { 428 _c.Call.Return(_a0) 429 return _c 430 } 431 432 func (_c *SenderInterface_ResultSuccess_Call) RunAndReturn(run func(*model.HeaderType, *model.FeatureAddressType) error) *SenderInterface_ResultSuccess_Call { 433 _c.Call.Return(run) 434 return _c 435 } 436 437 // Subscribe provides a mock function with given fields: senderAddress, destinationAddress, serverFeatureType 438 func (_m *SenderInterface) Subscribe(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, serverFeatureType model.FeatureTypeType) (*model.MsgCounterType, error) { 439 ret := _m.Called(senderAddress, destinationAddress, serverFeatureType) 440 441 if len(ret) == 0 { 442 panic("no return value specified for Subscribe") 443 } 444 445 var r0 *model.MsgCounterType 446 var r1 error 447 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) (*model.MsgCounterType, error)); ok { 448 return rf(senderAddress, destinationAddress, serverFeatureType) 449 } 450 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) *model.MsgCounterType); ok { 451 r0 = rf(senderAddress, destinationAddress, serverFeatureType) 452 } else { 453 if ret.Get(0) != nil { 454 r0 = ret.Get(0).(*model.MsgCounterType) 455 } 456 } 457 458 if rf, ok := ret.Get(1).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) error); ok { 459 r1 = rf(senderAddress, destinationAddress, serverFeatureType) 460 } else { 461 r1 = ret.Error(1) 462 } 463 464 return r0, r1 465 } 466 467 // SenderInterface_Subscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Subscribe' 468 type SenderInterface_Subscribe_Call struct { 469 *mock.Call 470 } 471 472 // Subscribe is a helper method to define mock.On call 473 // - senderAddress *model.FeatureAddressType 474 // - destinationAddress *model.FeatureAddressType 475 // - serverFeatureType model.FeatureTypeType 476 func (_e *SenderInterface_Expecter) Subscribe(senderAddress interface{}, destinationAddress interface{}, serverFeatureType interface{}) *SenderInterface_Subscribe_Call { 477 return &SenderInterface_Subscribe_Call{Call: _e.mock.On("Subscribe", senderAddress, destinationAddress, serverFeatureType)} 478 } 479 480 func (_c *SenderInterface_Subscribe_Call) Run(run func(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, serverFeatureType model.FeatureTypeType)) *SenderInterface_Subscribe_Call { 481 _c.Call.Run(func(args mock.Arguments) { 482 run(args[0].(*model.FeatureAddressType), args[1].(*model.FeatureAddressType), args[2].(model.FeatureTypeType)) 483 }) 484 return _c 485 } 486 487 func (_c *SenderInterface_Subscribe_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Subscribe_Call { 488 _c.Call.Return(_a0, _a1) 489 return _c 490 } 491 492 func (_c *SenderInterface_Subscribe_Call) RunAndReturn(run func(*model.FeatureAddressType, *model.FeatureAddressType, model.FeatureTypeType) (*model.MsgCounterType, error)) *SenderInterface_Subscribe_Call { 493 _c.Call.Return(run) 494 return _c 495 } 496 497 // Unbind provides a mock function with given fields: senderAddress, destinationAddress 498 func (_m *SenderInterface) Unbind(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType) (*model.MsgCounterType, error) { 499 ret := _m.Called(senderAddress, destinationAddress) 500 501 if len(ret) == 0 { 502 panic("no return value specified for Unbind") 503 } 504 505 var r0 *model.MsgCounterType 506 var r1 error 507 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType) (*model.MsgCounterType, error)); ok { 508 return rf(senderAddress, destinationAddress) 509 } 510 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType) *model.MsgCounterType); ok { 511 r0 = rf(senderAddress, destinationAddress) 512 } else { 513 if ret.Get(0) != nil { 514 r0 = ret.Get(0).(*model.MsgCounterType) 515 } 516 } 517 518 if rf, ok := ret.Get(1).(func(*model.FeatureAddressType, *model.FeatureAddressType) error); ok { 519 r1 = rf(senderAddress, destinationAddress) 520 } else { 521 r1 = ret.Error(1) 522 } 523 524 return r0, r1 525 } 526 527 // SenderInterface_Unbind_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unbind' 528 type SenderInterface_Unbind_Call struct { 529 *mock.Call 530 } 531 532 // Unbind is a helper method to define mock.On call 533 // - senderAddress *model.FeatureAddressType 534 // - destinationAddress *model.FeatureAddressType 535 func (_e *SenderInterface_Expecter) Unbind(senderAddress interface{}, destinationAddress interface{}) *SenderInterface_Unbind_Call { 536 return &SenderInterface_Unbind_Call{Call: _e.mock.On("Unbind", senderAddress, destinationAddress)} 537 } 538 539 func (_c *SenderInterface_Unbind_Call) Run(run func(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType)) *SenderInterface_Unbind_Call { 540 _c.Call.Run(func(args mock.Arguments) { 541 run(args[0].(*model.FeatureAddressType), args[1].(*model.FeatureAddressType)) 542 }) 543 return _c 544 } 545 546 func (_c *SenderInterface_Unbind_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Unbind_Call { 547 _c.Call.Return(_a0, _a1) 548 return _c 549 } 550 551 func (_c *SenderInterface_Unbind_Call) RunAndReturn(run func(*model.FeatureAddressType, *model.FeatureAddressType) (*model.MsgCounterType, error)) *SenderInterface_Unbind_Call { 552 _c.Call.Return(run) 553 return _c 554 } 555 556 // Unsubscribe provides a mock function with given fields: senderAddress, destinationAddress 557 func (_m *SenderInterface) Unsubscribe(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType) (*model.MsgCounterType, error) { 558 ret := _m.Called(senderAddress, destinationAddress) 559 560 if len(ret) == 0 { 561 panic("no return value specified for Unsubscribe") 562 } 563 564 var r0 *model.MsgCounterType 565 var r1 error 566 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType) (*model.MsgCounterType, error)); ok { 567 return rf(senderAddress, destinationAddress) 568 } 569 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType) *model.MsgCounterType); ok { 570 r0 = rf(senderAddress, destinationAddress) 571 } else { 572 if ret.Get(0) != nil { 573 r0 = ret.Get(0).(*model.MsgCounterType) 574 } 575 } 576 577 if rf, ok := ret.Get(1).(func(*model.FeatureAddressType, *model.FeatureAddressType) error); ok { 578 r1 = rf(senderAddress, destinationAddress) 579 } else { 580 r1 = ret.Error(1) 581 } 582 583 return r0, r1 584 } 585 586 // SenderInterface_Unsubscribe_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Unsubscribe' 587 type SenderInterface_Unsubscribe_Call struct { 588 *mock.Call 589 } 590 591 // Unsubscribe is a helper method to define mock.On call 592 // - senderAddress *model.FeatureAddressType 593 // - destinationAddress *model.FeatureAddressType 594 func (_e *SenderInterface_Expecter) Unsubscribe(senderAddress interface{}, destinationAddress interface{}) *SenderInterface_Unsubscribe_Call { 595 return &SenderInterface_Unsubscribe_Call{Call: _e.mock.On("Unsubscribe", senderAddress, destinationAddress)} 596 } 597 598 func (_c *SenderInterface_Unsubscribe_Call) Run(run func(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType)) *SenderInterface_Unsubscribe_Call { 599 _c.Call.Run(func(args mock.Arguments) { 600 run(args[0].(*model.FeatureAddressType), args[1].(*model.FeatureAddressType)) 601 }) 602 return _c 603 } 604 605 func (_c *SenderInterface_Unsubscribe_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Unsubscribe_Call { 606 _c.Call.Return(_a0, _a1) 607 return _c 608 } 609 610 func (_c *SenderInterface_Unsubscribe_Call) RunAndReturn(run func(*model.FeatureAddressType, *model.FeatureAddressType) (*model.MsgCounterType, error)) *SenderInterface_Unsubscribe_Call { 611 _c.Call.Return(run) 612 return _c 613 } 614 615 // Write provides a mock function with given fields: senderAddress, destinationAddress, cmd 616 func (_m *SenderInterface) Write(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, cmd model.CmdType) (*model.MsgCounterType, error) { 617 ret := _m.Called(senderAddress, destinationAddress, cmd) 618 619 if len(ret) == 0 { 620 panic("no return value specified for Write") 621 } 622 623 var r0 *model.MsgCounterType 624 var r1 error 625 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) (*model.MsgCounterType, error)); ok { 626 return rf(senderAddress, destinationAddress, cmd) 627 } 628 if rf, ok := ret.Get(0).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) *model.MsgCounterType); ok { 629 r0 = rf(senderAddress, destinationAddress, cmd) 630 } else { 631 if ret.Get(0) != nil { 632 r0 = ret.Get(0).(*model.MsgCounterType) 633 } 634 } 635 636 if rf, ok := ret.Get(1).(func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) error); ok { 637 r1 = rf(senderAddress, destinationAddress, cmd) 638 } else { 639 r1 = ret.Error(1) 640 } 641 642 return r0, r1 643 } 644 645 // SenderInterface_Write_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Write' 646 type SenderInterface_Write_Call struct { 647 *mock.Call 648 } 649 650 // Write is a helper method to define mock.On call 651 // - senderAddress *model.FeatureAddressType 652 // - destinationAddress *model.FeatureAddressType 653 // - cmd model.CmdType 654 func (_e *SenderInterface_Expecter) Write(senderAddress interface{}, destinationAddress interface{}, cmd interface{}) *SenderInterface_Write_Call { 655 return &SenderInterface_Write_Call{Call: _e.mock.On("Write", senderAddress, destinationAddress, cmd)} 656 } 657 658 func (_c *SenderInterface_Write_Call) Run(run func(senderAddress *model.FeatureAddressType, destinationAddress *model.FeatureAddressType, cmd model.CmdType)) *SenderInterface_Write_Call { 659 _c.Call.Run(func(args mock.Arguments) { 660 run(args[0].(*model.FeatureAddressType), args[1].(*model.FeatureAddressType), args[2].(model.CmdType)) 661 }) 662 return _c 663 } 664 665 func (_c *SenderInterface_Write_Call) Return(_a0 *model.MsgCounterType, _a1 error) *SenderInterface_Write_Call { 666 _c.Call.Return(_a0, _a1) 667 return _c 668 } 669 670 func (_c *SenderInterface_Write_Call) RunAndReturn(run func(*model.FeatureAddressType, *model.FeatureAddressType, model.CmdType) (*model.MsgCounterType, error)) *SenderInterface_Write_Call { 671 _c.Call.Return(run) 672 return _c 673 } 674 675 // NewSenderInterface creates a new instance of SenderInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. 676 // The first argument is typically a *testing.T value. 677 func NewSenderInterface(t interface { 678 mock.TestingT 679 Cleanup(func()) 680 }) *SenderInterface { 681 mock := &SenderInterface{} 682 mock.Mock.Test(t) 683 684 t.Cleanup(func() { mock.AssertExpectations(t) }) 685 686 return mock 687 }