github.com/enbility/spine-go@v0.7.0/mocks/FunctionDataCmdInterface.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 // FunctionDataCmdInterface is an autogenerated mock type for the FunctionDataCmdInterface type 11 type FunctionDataCmdInterface struct { 12 mock.Mock 13 } 14 15 type FunctionDataCmdInterface_Expecter struct { 16 mock *mock.Mock 17 } 18 19 func (_m *FunctionDataCmdInterface) EXPECT() *FunctionDataCmdInterface_Expecter { 20 return &FunctionDataCmdInterface_Expecter{mock: &_m.Mock} 21 } 22 23 // DataCopyAny provides a mock function with given fields: 24 func (_m *FunctionDataCmdInterface) DataCopyAny() interface{} { 25 ret := _m.Called() 26 27 if len(ret) == 0 { 28 panic("no return value specified for DataCopyAny") 29 } 30 31 var r0 interface{} 32 if rf, ok := ret.Get(0).(func() interface{}); ok { 33 r0 = rf() 34 } else { 35 if ret.Get(0) != nil { 36 r0 = ret.Get(0).(interface{}) 37 } 38 } 39 40 return r0 41 } 42 43 // FunctionDataCmdInterface_DataCopyAny_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DataCopyAny' 44 type FunctionDataCmdInterface_DataCopyAny_Call struct { 45 *mock.Call 46 } 47 48 // DataCopyAny is a helper method to define mock.On call 49 func (_e *FunctionDataCmdInterface_Expecter) DataCopyAny() *FunctionDataCmdInterface_DataCopyAny_Call { 50 return &FunctionDataCmdInterface_DataCopyAny_Call{Call: _e.mock.On("DataCopyAny")} 51 } 52 53 func (_c *FunctionDataCmdInterface_DataCopyAny_Call) Run(run func()) *FunctionDataCmdInterface_DataCopyAny_Call { 54 _c.Call.Run(func(args mock.Arguments) { 55 run() 56 }) 57 return _c 58 } 59 60 func (_c *FunctionDataCmdInterface_DataCopyAny_Call) Return(_a0 interface{}) *FunctionDataCmdInterface_DataCopyAny_Call { 61 _c.Call.Return(_a0) 62 return _c 63 } 64 65 func (_c *FunctionDataCmdInterface_DataCopyAny_Call) RunAndReturn(run func() interface{}) *FunctionDataCmdInterface_DataCopyAny_Call { 66 _c.Call.Return(run) 67 return _c 68 } 69 70 // FunctionType provides a mock function with given fields: 71 func (_m *FunctionDataCmdInterface) FunctionType() model.FunctionType { 72 ret := _m.Called() 73 74 if len(ret) == 0 { 75 panic("no return value specified for FunctionType") 76 } 77 78 var r0 model.FunctionType 79 if rf, ok := ret.Get(0).(func() model.FunctionType); ok { 80 r0 = rf() 81 } else { 82 r0 = ret.Get(0).(model.FunctionType) 83 } 84 85 return r0 86 } 87 88 // FunctionDataCmdInterface_FunctionType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FunctionType' 89 type FunctionDataCmdInterface_FunctionType_Call struct { 90 *mock.Call 91 } 92 93 // FunctionType is a helper method to define mock.On call 94 func (_e *FunctionDataCmdInterface_Expecter) FunctionType() *FunctionDataCmdInterface_FunctionType_Call { 95 return &FunctionDataCmdInterface_FunctionType_Call{Call: _e.mock.On("FunctionType")} 96 } 97 98 func (_c *FunctionDataCmdInterface_FunctionType_Call) Run(run func()) *FunctionDataCmdInterface_FunctionType_Call { 99 _c.Call.Run(func(args mock.Arguments) { 100 run() 101 }) 102 return _c 103 } 104 105 func (_c *FunctionDataCmdInterface_FunctionType_Call) Return(_a0 model.FunctionType) *FunctionDataCmdInterface_FunctionType_Call { 106 _c.Call.Return(_a0) 107 return _c 108 } 109 110 func (_c *FunctionDataCmdInterface_FunctionType_Call) RunAndReturn(run func() model.FunctionType) *FunctionDataCmdInterface_FunctionType_Call { 111 _c.Call.Return(run) 112 return _c 113 } 114 115 // NotifyOrWriteCmdType provides a mock function with given fields: deleteSelector, partialSelector, partialWithoutSelector, deleteElements 116 func (_m *FunctionDataCmdInterface) NotifyOrWriteCmdType(deleteSelector interface{}, partialSelector interface{}, partialWithoutSelector bool, deleteElements interface{}) model.CmdType { 117 ret := _m.Called(deleteSelector, partialSelector, partialWithoutSelector, deleteElements) 118 119 if len(ret) == 0 { 120 panic("no return value specified for NotifyOrWriteCmdType") 121 } 122 123 var r0 model.CmdType 124 if rf, ok := ret.Get(0).(func(interface{}, interface{}, bool, interface{}) model.CmdType); ok { 125 r0 = rf(deleteSelector, partialSelector, partialWithoutSelector, deleteElements) 126 } else { 127 r0 = ret.Get(0).(model.CmdType) 128 } 129 130 return r0 131 } 132 133 // FunctionDataCmdInterface_NotifyOrWriteCmdType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotifyOrWriteCmdType' 134 type FunctionDataCmdInterface_NotifyOrWriteCmdType_Call struct { 135 *mock.Call 136 } 137 138 // NotifyOrWriteCmdType is a helper method to define mock.On call 139 // - deleteSelector interface{} 140 // - partialSelector interface{} 141 // - partialWithoutSelector bool 142 // - deleteElements interface{} 143 func (_e *FunctionDataCmdInterface_Expecter) NotifyOrWriteCmdType(deleteSelector interface{}, partialSelector interface{}, partialWithoutSelector interface{}, deleteElements interface{}) *FunctionDataCmdInterface_NotifyOrWriteCmdType_Call { 144 return &FunctionDataCmdInterface_NotifyOrWriteCmdType_Call{Call: _e.mock.On("NotifyOrWriteCmdType", deleteSelector, partialSelector, partialWithoutSelector, deleteElements)} 145 } 146 147 func (_c *FunctionDataCmdInterface_NotifyOrWriteCmdType_Call) Run(run func(deleteSelector interface{}, partialSelector interface{}, partialWithoutSelector bool, deleteElements interface{})) *FunctionDataCmdInterface_NotifyOrWriteCmdType_Call { 148 _c.Call.Run(func(args mock.Arguments) { 149 run(args[0].(interface{}), args[1].(interface{}), args[2].(bool), args[3].(interface{})) 150 }) 151 return _c 152 } 153 154 func (_c *FunctionDataCmdInterface_NotifyOrWriteCmdType_Call) Return(_a0 model.CmdType) *FunctionDataCmdInterface_NotifyOrWriteCmdType_Call { 155 _c.Call.Return(_a0) 156 return _c 157 } 158 159 func (_c *FunctionDataCmdInterface_NotifyOrWriteCmdType_Call) RunAndReturn(run func(interface{}, interface{}, bool, interface{}) model.CmdType) *FunctionDataCmdInterface_NotifyOrWriteCmdType_Call { 160 _c.Call.Return(run) 161 return _c 162 } 163 164 // ReadCmdType provides a mock function with given fields: partialSelector, elements 165 func (_m *FunctionDataCmdInterface) ReadCmdType(partialSelector interface{}, elements interface{}) model.CmdType { 166 ret := _m.Called(partialSelector, elements) 167 168 if len(ret) == 0 { 169 panic("no return value specified for ReadCmdType") 170 } 171 172 var r0 model.CmdType 173 if rf, ok := ret.Get(0).(func(interface{}, interface{}) model.CmdType); ok { 174 r0 = rf(partialSelector, elements) 175 } else { 176 r0 = ret.Get(0).(model.CmdType) 177 } 178 179 return r0 180 } 181 182 // FunctionDataCmdInterface_ReadCmdType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReadCmdType' 183 type FunctionDataCmdInterface_ReadCmdType_Call struct { 184 *mock.Call 185 } 186 187 // ReadCmdType is a helper method to define mock.On call 188 // - partialSelector interface{} 189 // - elements interface{} 190 func (_e *FunctionDataCmdInterface_Expecter) ReadCmdType(partialSelector interface{}, elements interface{}) *FunctionDataCmdInterface_ReadCmdType_Call { 191 return &FunctionDataCmdInterface_ReadCmdType_Call{Call: _e.mock.On("ReadCmdType", partialSelector, elements)} 192 } 193 194 func (_c *FunctionDataCmdInterface_ReadCmdType_Call) Run(run func(partialSelector interface{}, elements interface{})) *FunctionDataCmdInterface_ReadCmdType_Call { 195 _c.Call.Run(func(args mock.Arguments) { 196 run(args[0].(interface{}), args[1].(interface{})) 197 }) 198 return _c 199 } 200 201 func (_c *FunctionDataCmdInterface_ReadCmdType_Call) Return(_a0 model.CmdType) *FunctionDataCmdInterface_ReadCmdType_Call { 202 _c.Call.Return(_a0) 203 return _c 204 } 205 206 func (_c *FunctionDataCmdInterface_ReadCmdType_Call) RunAndReturn(run func(interface{}, interface{}) model.CmdType) *FunctionDataCmdInterface_ReadCmdType_Call { 207 _c.Call.Return(run) 208 return _c 209 } 210 211 // ReplyCmdType provides a mock function with given fields: partial 212 func (_m *FunctionDataCmdInterface) ReplyCmdType(partial bool) model.CmdType { 213 ret := _m.Called(partial) 214 215 if len(ret) == 0 { 216 panic("no return value specified for ReplyCmdType") 217 } 218 219 var r0 model.CmdType 220 if rf, ok := ret.Get(0).(func(bool) model.CmdType); ok { 221 r0 = rf(partial) 222 } else { 223 r0 = ret.Get(0).(model.CmdType) 224 } 225 226 return r0 227 } 228 229 // FunctionDataCmdInterface_ReplyCmdType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ReplyCmdType' 230 type FunctionDataCmdInterface_ReplyCmdType_Call struct { 231 *mock.Call 232 } 233 234 // ReplyCmdType is a helper method to define mock.On call 235 // - partial bool 236 func (_e *FunctionDataCmdInterface_Expecter) ReplyCmdType(partial interface{}) *FunctionDataCmdInterface_ReplyCmdType_Call { 237 return &FunctionDataCmdInterface_ReplyCmdType_Call{Call: _e.mock.On("ReplyCmdType", partial)} 238 } 239 240 func (_c *FunctionDataCmdInterface_ReplyCmdType_Call) Run(run func(partial bool)) *FunctionDataCmdInterface_ReplyCmdType_Call { 241 _c.Call.Run(func(args mock.Arguments) { 242 run(args[0].(bool)) 243 }) 244 return _c 245 } 246 247 func (_c *FunctionDataCmdInterface_ReplyCmdType_Call) Return(_a0 model.CmdType) *FunctionDataCmdInterface_ReplyCmdType_Call { 248 _c.Call.Return(_a0) 249 return _c 250 } 251 252 func (_c *FunctionDataCmdInterface_ReplyCmdType_Call) RunAndReturn(run func(bool) model.CmdType) *FunctionDataCmdInterface_ReplyCmdType_Call { 253 _c.Call.Return(run) 254 return _c 255 } 256 257 // SupportsPartialWrite provides a mock function with given fields: 258 func (_m *FunctionDataCmdInterface) SupportsPartialWrite() bool { 259 ret := _m.Called() 260 261 if len(ret) == 0 { 262 panic("no return value specified for SupportsPartialWrite") 263 } 264 265 var r0 bool 266 if rf, ok := ret.Get(0).(func() bool); ok { 267 r0 = rf() 268 } else { 269 r0 = ret.Get(0).(bool) 270 } 271 272 return r0 273 } 274 275 // FunctionDataCmdInterface_SupportsPartialWrite_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SupportsPartialWrite' 276 type FunctionDataCmdInterface_SupportsPartialWrite_Call struct { 277 *mock.Call 278 } 279 280 // SupportsPartialWrite is a helper method to define mock.On call 281 func (_e *FunctionDataCmdInterface_Expecter) SupportsPartialWrite() *FunctionDataCmdInterface_SupportsPartialWrite_Call { 282 return &FunctionDataCmdInterface_SupportsPartialWrite_Call{Call: _e.mock.On("SupportsPartialWrite")} 283 } 284 285 func (_c *FunctionDataCmdInterface_SupportsPartialWrite_Call) Run(run func()) *FunctionDataCmdInterface_SupportsPartialWrite_Call { 286 _c.Call.Run(func(args mock.Arguments) { 287 run() 288 }) 289 return _c 290 } 291 292 func (_c *FunctionDataCmdInterface_SupportsPartialWrite_Call) Return(_a0 bool) *FunctionDataCmdInterface_SupportsPartialWrite_Call { 293 _c.Call.Return(_a0) 294 return _c 295 } 296 297 func (_c *FunctionDataCmdInterface_SupportsPartialWrite_Call) RunAndReturn(run func() bool) *FunctionDataCmdInterface_SupportsPartialWrite_Call { 298 _c.Call.Return(run) 299 return _c 300 } 301 302 // UpdateDataAny provides a mock function with given fields: remoteWrite, persist, data, filterPartial, filterDelete 303 func (_m *FunctionDataCmdInterface) UpdateDataAny(remoteWrite bool, persist bool, data interface{}, filterPartial *model.FilterType, filterDelete *model.FilterType) (interface{}, *model.ErrorType) { 304 ret := _m.Called(remoteWrite, persist, data, filterPartial, filterDelete) 305 306 if len(ret) == 0 { 307 panic("no return value specified for UpdateDataAny") 308 } 309 310 var r0 interface{} 311 var r1 *model.ErrorType 312 if rf, ok := ret.Get(0).(func(bool, bool, interface{}, *model.FilterType, *model.FilterType) (interface{}, *model.ErrorType)); ok { 313 return rf(remoteWrite, persist, data, filterPartial, filterDelete) 314 } 315 if rf, ok := ret.Get(0).(func(bool, bool, interface{}, *model.FilterType, *model.FilterType) interface{}); ok { 316 r0 = rf(remoteWrite, persist, data, filterPartial, filterDelete) 317 } else { 318 if ret.Get(0) != nil { 319 r0 = ret.Get(0).(interface{}) 320 } 321 } 322 323 if rf, ok := ret.Get(1).(func(bool, bool, interface{}, *model.FilterType, *model.FilterType) *model.ErrorType); ok { 324 r1 = rf(remoteWrite, persist, data, filterPartial, filterDelete) 325 } else { 326 if ret.Get(1) != nil { 327 r1 = ret.Get(1).(*model.ErrorType) 328 } 329 } 330 331 return r0, r1 332 } 333 334 // FunctionDataCmdInterface_UpdateDataAny_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateDataAny' 335 type FunctionDataCmdInterface_UpdateDataAny_Call struct { 336 *mock.Call 337 } 338 339 // UpdateDataAny is a helper method to define mock.On call 340 // - remoteWrite bool 341 // - persist bool 342 // - data interface{} 343 // - filterPartial *model.FilterType 344 // - filterDelete *model.FilterType 345 func (_e *FunctionDataCmdInterface_Expecter) UpdateDataAny(remoteWrite interface{}, persist interface{}, data interface{}, filterPartial interface{}, filterDelete interface{}) *FunctionDataCmdInterface_UpdateDataAny_Call { 346 return &FunctionDataCmdInterface_UpdateDataAny_Call{Call: _e.mock.On("UpdateDataAny", remoteWrite, persist, data, filterPartial, filterDelete)} 347 } 348 349 func (_c *FunctionDataCmdInterface_UpdateDataAny_Call) Run(run func(remoteWrite bool, persist bool, data interface{}, filterPartial *model.FilterType, filterDelete *model.FilterType)) *FunctionDataCmdInterface_UpdateDataAny_Call { 350 _c.Call.Run(func(args mock.Arguments) { 351 run(args[0].(bool), args[1].(bool), args[2].(interface{}), args[3].(*model.FilterType), args[4].(*model.FilterType)) 352 }) 353 return _c 354 } 355 356 func (_c *FunctionDataCmdInterface_UpdateDataAny_Call) Return(_a0 interface{}, _a1 *model.ErrorType) *FunctionDataCmdInterface_UpdateDataAny_Call { 357 _c.Call.Return(_a0, _a1) 358 return _c 359 } 360 361 func (_c *FunctionDataCmdInterface_UpdateDataAny_Call) RunAndReturn(run func(bool, bool, interface{}, *model.FilterType, *model.FilterType) (interface{}, *model.ErrorType)) *FunctionDataCmdInterface_UpdateDataAny_Call { 362 _c.Call.Return(run) 363 return _c 364 } 365 366 // NewFunctionDataCmdInterface creates a new instance of FunctionDataCmdInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations. 367 // The first argument is typically a *testing.T value. 368 func NewFunctionDataCmdInterface(t interface { 369 mock.TestingT 370 Cleanup(func()) 371 }) *FunctionDataCmdInterface { 372 mock := &FunctionDataCmdInterface{} 373 mock.Mock.Test(t) 374 375 t.Cleanup(func() { mock.AssertExpectations(t) }) 376 377 return mock 378 }