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  }