github.com/enbility/spine-go@v0.7.0/mocks/FeatureRemoteInterface.go (about)

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