github.com/enbility/spine-go@v0.7.0/mocks/EntityLocalInterface.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  
    12  // EntityLocalInterface is an autogenerated mock type for the EntityLocalInterface type
    13  type EntityLocalInterface struct {
    14  	mock.Mock
    15  }
    16  
    17  type EntityLocalInterface_Expecter struct {
    18  	mock *mock.Mock
    19  }
    20  
    21  func (_m *EntityLocalInterface) EXPECT() *EntityLocalInterface_Expecter {
    22  	return &EntityLocalInterface_Expecter{mock: &_m.Mock}
    23  }
    24  
    25  // AddFeature provides a mock function with given fields: f
    26  func (_m *EntityLocalInterface) AddFeature(f api.FeatureLocalInterface) {
    27  	_m.Called(f)
    28  }
    29  
    30  // EntityLocalInterface_AddFeature_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeature'
    31  type EntityLocalInterface_AddFeature_Call struct {
    32  	*mock.Call
    33  }
    34  
    35  // AddFeature is a helper method to define mock.On call
    36  //   - f api.FeatureLocalInterface
    37  func (_e *EntityLocalInterface_Expecter) AddFeature(f interface{}) *EntityLocalInterface_AddFeature_Call {
    38  	return &EntityLocalInterface_AddFeature_Call{Call: _e.mock.On("AddFeature", f)}
    39  }
    40  
    41  func (_c *EntityLocalInterface_AddFeature_Call) Run(run func(f api.FeatureLocalInterface)) *EntityLocalInterface_AddFeature_Call {
    42  	_c.Call.Run(func(args mock.Arguments) {
    43  		run(args[0].(api.FeatureLocalInterface))
    44  	})
    45  	return _c
    46  }
    47  
    48  func (_c *EntityLocalInterface_AddFeature_Call) Return() *EntityLocalInterface_AddFeature_Call {
    49  	_c.Call.Return()
    50  	return _c
    51  }
    52  
    53  func (_c *EntityLocalInterface_AddFeature_Call) RunAndReturn(run func(api.FeatureLocalInterface)) *EntityLocalInterface_AddFeature_Call {
    54  	_c.Call.Return(run)
    55  	return _c
    56  }
    57  
    58  // AddUseCaseSupport provides a mock function with given fields: actor, useCaseName, useCaseVersion, useCaseDocumemtSubRevision, useCaseAvailable, scenarios
    59  func (_m *EntityLocalInterface) AddUseCaseSupport(actor model.UseCaseActorType, useCaseName model.UseCaseNameType, useCaseVersion model.SpecificationVersionType, useCaseDocumemtSubRevision string, useCaseAvailable bool, scenarios []model.UseCaseScenarioSupportType) {
    60  	_m.Called(actor, useCaseName, useCaseVersion, useCaseDocumemtSubRevision, useCaseAvailable, scenarios)
    61  }
    62  
    63  // EntityLocalInterface_AddUseCaseSupport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCaseSupport'
    64  type EntityLocalInterface_AddUseCaseSupport_Call struct {
    65  	*mock.Call
    66  }
    67  
    68  // AddUseCaseSupport is a helper method to define mock.On call
    69  //   - actor model.UseCaseActorType
    70  //   - useCaseName model.UseCaseNameType
    71  //   - useCaseVersion model.SpecificationVersionType
    72  //   - useCaseDocumemtSubRevision string
    73  //   - useCaseAvailable bool
    74  //   - scenarios []model.UseCaseScenarioSupportType
    75  func (_e *EntityLocalInterface_Expecter) AddUseCaseSupport(actor interface{}, useCaseName interface{}, useCaseVersion interface{}, useCaseDocumemtSubRevision interface{}, useCaseAvailable interface{}, scenarios interface{}) *EntityLocalInterface_AddUseCaseSupport_Call {
    76  	return &EntityLocalInterface_AddUseCaseSupport_Call{Call: _e.mock.On("AddUseCaseSupport", actor, useCaseName, useCaseVersion, useCaseDocumemtSubRevision, useCaseAvailable, scenarios)}
    77  }
    78  
    79  func (_c *EntityLocalInterface_AddUseCaseSupport_Call) Run(run func(actor model.UseCaseActorType, useCaseName model.UseCaseNameType, useCaseVersion model.SpecificationVersionType, useCaseDocumemtSubRevision string, useCaseAvailable bool, scenarios []model.UseCaseScenarioSupportType)) *EntityLocalInterface_AddUseCaseSupport_Call {
    80  	_c.Call.Run(func(args mock.Arguments) {
    81  		run(args[0].(model.UseCaseActorType), args[1].(model.UseCaseNameType), args[2].(model.SpecificationVersionType), args[3].(string), args[4].(bool), args[5].([]model.UseCaseScenarioSupportType))
    82  	})
    83  	return _c
    84  }
    85  
    86  func (_c *EntityLocalInterface_AddUseCaseSupport_Call) Return() *EntityLocalInterface_AddUseCaseSupport_Call {
    87  	_c.Call.Return()
    88  	return _c
    89  }
    90  
    91  func (_c *EntityLocalInterface_AddUseCaseSupport_Call) RunAndReturn(run func(model.UseCaseActorType, model.UseCaseNameType, model.SpecificationVersionType, string, bool, []model.UseCaseScenarioSupportType)) *EntityLocalInterface_AddUseCaseSupport_Call {
    92  	_c.Call.Return(run)
    93  	return _c
    94  }
    95  
    96  // Address provides a mock function with given fields:
    97  func (_m *EntityLocalInterface) Address() *model.EntityAddressType {
    98  	ret := _m.Called()
    99  
   100  	if len(ret) == 0 {
   101  		panic("no return value specified for Address")
   102  	}
   103  
   104  	var r0 *model.EntityAddressType
   105  	if rf, ok := ret.Get(0).(func() *model.EntityAddressType); ok {
   106  		r0 = rf()
   107  	} else {
   108  		if ret.Get(0) != nil {
   109  			r0 = ret.Get(0).(*model.EntityAddressType)
   110  		}
   111  	}
   112  
   113  	return r0
   114  }
   115  
   116  // EntityLocalInterface_Address_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Address'
   117  type EntityLocalInterface_Address_Call struct {
   118  	*mock.Call
   119  }
   120  
   121  // Address is a helper method to define mock.On call
   122  func (_e *EntityLocalInterface_Expecter) Address() *EntityLocalInterface_Address_Call {
   123  	return &EntityLocalInterface_Address_Call{Call: _e.mock.On("Address")}
   124  }
   125  
   126  func (_c *EntityLocalInterface_Address_Call) Run(run func()) *EntityLocalInterface_Address_Call {
   127  	_c.Call.Run(func(args mock.Arguments) {
   128  		run()
   129  	})
   130  	return _c
   131  }
   132  
   133  func (_c *EntityLocalInterface_Address_Call) Return(_a0 *model.EntityAddressType) *EntityLocalInterface_Address_Call {
   134  	_c.Call.Return(_a0)
   135  	return _c
   136  }
   137  
   138  func (_c *EntityLocalInterface_Address_Call) RunAndReturn(run func() *model.EntityAddressType) *EntityLocalInterface_Address_Call {
   139  	_c.Call.Return(run)
   140  	return _c
   141  }
   142  
   143  // Description provides a mock function with given fields:
   144  func (_m *EntityLocalInterface) Description() *model.DescriptionType {
   145  	ret := _m.Called()
   146  
   147  	if len(ret) == 0 {
   148  		panic("no return value specified for Description")
   149  	}
   150  
   151  	var r0 *model.DescriptionType
   152  	if rf, ok := ret.Get(0).(func() *model.DescriptionType); ok {
   153  		r0 = rf()
   154  	} else {
   155  		if ret.Get(0) != nil {
   156  			r0 = ret.Get(0).(*model.DescriptionType)
   157  		}
   158  	}
   159  
   160  	return r0
   161  }
   162  
   163  // EntityLocalInterface_Description_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Description'
   164  type EntityLocalInterface_Description_Call struct {
   165  	*mock.Call
   166  }
   167  
   168  // Description is a helper method to define mock.On call
   169  func (_e *EntityLocalInterface_Expecter) Description() *EntityLocalInterface_Description_Call {
   170  	return &EntityLocalInterface_Description_Call{Call: _e.mock.On("Description")}
   171  }
   172  
   173  func (_c *EntityLocalInterface_Description_Call) Run(run func()) *EntityLocalInterface_Description_Call {
   174  	_c.Call.Run(func(args mock.Arguments) {
   175  		run()
   176  	})
   177  	return _c
   178  }
   179  
   180  func (_c *EntityLocalInterface_Description_Call) Return(_a0 *model.DescriptionType) *EntityLocalInterface_Description_Call {
   181  	_c.Call.Return(_a0)
   182  	return _c
   183  }
   184  
   185  func (_c *EntityLocalInterface_Description_Call) RunAndReturn(run func() *model.DescriptionType) *EntityLocalInterface_Description_Call {
   186  	_c.Call.Return(run)
   187  	return _c
   188  }
   189  
   190  // Device provides a mock function with given fields:
   191  func (_m *EntityLocalInterface) Device() api.DeviceLocalInterface {
   192  	ret := _m.Called()
   193  
   194  	if len(ret) == 0 {
   195  		panic("no return value specified for Device")
   196  	}
   197  
   198  	var r0 api.DeviceLocalInterface
   199  	if rf, ok := ret.Get(0).(func() api.DeviceLocalInterface); ok {
   200  		r0 = rf()
   201  	} else {
   202  		if ret.Get(0) != nil {
   203  			r0 = ret.Get(0).(api.DeviceLocalInterface)
   204  		}
   205  	}
   206  
   207  	return r0
   208  }
   209  
   210  // EntityLocalInterface_Device_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Device'
   211  type EntityLocalInterface_Device_Call struct {
   212  	*mock.Call
   213  }
   214  
   215  // Device is a helper method to define mock.On call
   216  func (_e *EntityLocalInterface_Expecter) Device() *EntityLocalInterface_Device_Call {
   217  	return &EntityLocalInterface_Device_Call{Call: _e.mock.On("Device")}
   218  }
   219  
   220  func (_c *EntityLocalInterface_Device_Call) Run(run func()) *EntityLocalInterface_Device_Call {
   221  	_c.Call.Run(func(args mock.Arguments) {
   222  		run()
   223  	})
   224  	return _c
   225  }
   226  
   227  func (_c *EntityLocalInterface_Device_Call) Return(_a0 api.DeviceLocalInterface) *EntityLocalInterface_Device_Call {
   228  	_c.Call.Return(_a0)
   229  	return _c
   230  }
   231  
   232  func (_c *EntityLocalInterface_Device_Call) RunAndReturn(run func() api.DeviceLocalInterface) *EntityLocalInterface_Device_Call {
   233  	_c.Call.Return(run)
   234  	return _c
   235  }
   236  
   237  // EntityType provides a mock function with given fields:
   238  func (_m *EntityLocalInterface) EntityType() model.EntityTypeType {
   239  	ret := _m.Called()
   240  
   241  	if len(ret) == 0 {
   242  		panic("no return value specified for EntityType")
   243  	}
   244  
   245  	var r0 model.EntityTypeType
   246  	if rf, ok := ret.Get(0).(func() model.EntityTypeType); ok {
   247  		r0 = rf()
   248  	} else {
   249  		r0 = ret.Get(0).(model.EntityTypeType)
   250  	}
   251  
   252  	return r0
   253  }
   254  
   255  // EntityLocalInterface_EntityType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EntityType'
   256  type EntityLocalInterface_EntityType_Call struct {
   257  	*mock.Call
   258  }
   259  
   260  // EntityType is a helper method to define mock.On call
   261  func (_e *EntityLocalInterface_Expecter) EntityType() *EntityLocalInterface_EntityType_Call {
   262  	return &EntityLocalInterface_EntityType_Call{Call: _e.mock.On("EntityType")}
   263  }
   264  
   265  func (_c *EntityLocalInterface_EntityType_Call) Run(run func()) *EntityLocalInterface_EntityType_Call {
   266  	_c.Call.Run(func(args mock.Arguments) {
   267  		run()
   268  	})
   269  	return _c
   270  }
   271  
   272  func (_c *EntityLocalInterface_EntityType_Call) Return(_a0 model.EntityTypeType) *EntityLocalInterface_EntityType_Call {
   273  	_c.Call.Return(_a0)
   274  	return _c
   275  }
   276  
   277  func (_c *EntityLocalInterface_EntityType_Call) RunAndReturn(run func() model.EntityTypeType) *EntityLocalInterface_EntityType_Call {
   278  	_c.Call.Return(run)
   279  	return _c
   280  }
   281  
   282  // FeatureOfAddress provides a mock function with given fields: addressFeature
   283  func (_m *EntityLocalInterface) FeatureOfAddress(addressFeature *model.AddressFeatureType) api.FeatureLocalInterface {
   284  	ret := _m.Called(addressFeature)
   285  
   286  	if len(ret) == 0 {
   287  		panic("no return value specified for FeatureOfAddress")
   288  	}
   289  
   290  	var r0 api.FeatureLocalInterface
   291  	if rf, ok := ret.Get(0).(func(*model.AddressFeatureType) api.FeatureLocalInterface); ok {
   292  		r0 = rf(addressFeature)
   293  	} else {
   294  		if ret.Get(0) != nil {
   295  			r0 = ret.Get(0).(api.FeatureLocalInterface)
   296  		}
   297  	}
   298  
   299  	return r0
   300  }
   301  
   302  // EntityLocalInterface_FeatureOfAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FeatureOfAddress'
   303  type EntityLocalInterface_FeatureOfAddress_Call struct {
   304  	*mock.Call
   305  }
   306  
   307  // FeatureOfAddress is a helper method to define mock.On call
   308  //   - addressFeature *model.AddressFeatureType
   309  func (_e *EntityLocalInterface_Expecter) FeatureOfAddress(addressFeature interface{}) *EntityLocalInterface_FeatureOfAddress_Call {
   310  	return &EntityLocalInterface_FeatureOfAddress_Call{Call: _e.mock.On("FeatureOfAddress", addressFeature)}
   311  }
   312  
   313  func (_c *EntityLocalInterface_FeatureOfAddress_Call) Run(run func(addressFeature *model.AddressFeatureType)) *EntityLocalInterface_FeatureOfAddress_Call {
   314  	_c.Call.Run(func(args mock.Arguments) {
   315  		run(args[0].(*model.AddressFeatureType))
   316  	})
   317  	return _c
   318  }
   319  
   320  func (_c *EntityLocalInterface_FeatureOfAddress_Call) Return(_a0 api.FeatureLocalInterface) *EntityLocalInterface_FeatureOfAddress_Call {
   321  	_c.Call.Return(_a0)
   322  	return _c
   323  }
   324  
   325  func (_c *EntityLocalInterface_FeatureOfAddress_Call) RunAndReturn(run func(*model.AddressFeatureType) api.FeatureLocalInterface) *EntityLocalInterface_FeatureOfAddress_Call {
   326  	_c.Call.Return(run)
   327  	return _c
   328  }
   329  
   330  // FeatureOfTypeAndRole provides a mock function with given fields: featureType, role
   331  func (_m *EntityLocalInterface) FeatureOfTypeAndRole(featureType model.FeatureTypeType, role model.RoleType) api.FeatureLocalInterface {
   332  	ret := _m.Called(featureType, role)
   333  
   334  	if len(ret) == 0 {
   335  		panic("no return value specified for FeatureOfTypeAndRole")
   336  	}
   337  
   338  	var r0 api.FeatureLocalInterface
   339  	if rf, ok := ret.Get(0).(func(model.FeatureTypeType, model.RoleType) api.FeatureLocalInterface); ok {
   340  		r0 = rf(featureType, role)
   341  	} else {
   342  		if ret.Get(0) != nil {
   343  			r0 = ret.Get(0).(api.FeatureLocalInterface)
   344  		}
   345  	}
   346  
   347  	return r0
   348  }
   349  
   350  // EntityLocalInterface_FeatureOfTypeAndRole_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FeatureOfTypeAndRole'
   351  type EntityLocalInterface_FeatureOfTypeAndRole_Call struct {
   352  	*mock.Call
   353  }
   354  
   355  // FeatureOfTypeAndRole is a helper method to define mock.On call
   356  //   - featureType model.FeatureTypeType
   357  //   - role model.RoleType
   358  func (_e *EntityLocalInterface_Expecter) FeatureOfTypeAndRole(featureType interface{}, role interface{}) *EntityLocalInterface_FeatureOfTypeAndRole_Call {
   359  	return &EntityLocalInterface_FeatureOfTypeAndRole_Call{Call: _e.mock.On("FeatureOfTypeAndRole", featureType, role)}
   360  }
   361  
   362  func (_c *EntityLocalInterface_FeatureOfTypeAndRole_Call) Run(run func(featureType model.FeatureTypeType, role model.RoleType)) *EntityLocalInterface_FeatureOfTypeAndRole_Call {
   363  	_c.Call.Run(func(args mock.Arguments) {
   364  		run(args[0].(model.FeatureTypeType), args[1].(model.RoleType))
   365  	})
   366  	return _c
   367  }
   368  
   369  func (_c *EntityLocalInterface_FeatureOfTypeAndRole_Call) Return(_a0 api.FeatureLocalInterface) *EntityLocalInterface_FeatureOfTypeAndRole_Call {
   370  	_c.Call.Return(_a0)
   371  	return _c
   372  }
   373  
   374  func (_c *EntityLocalInterface_FeatureOfTypeAndRole_Call) RunAndReturn(run func(model.FeatureTypeType, model.RoleType) api.FeatureLocalInterface) *EntityLocalInterface_FeatureOfTypeAndRole_Call {
   375  	_c.Call.Return(run)
   376  	return _c
   377  }
   378  
   379  // Features provides a mock function with given fields:
   380  func (_m *EntityLocalInterface) Features() []api.FeatureLocalInterface {
   381  	ret := _m.Called()
   382  
   383  	if len(ret) == 0 {
   384  		panic("no return value specified for Features")
   385  	}
   386  
   387  	var r0 []api.FeatureLocalInterface
   388  	if rf, ok := ret.Get(0).(func() []api.FeatureLocalInterface); ok {
   389  		r0 = rf()
   390  	} else {
   391  		if ret.Get(0) != nil {
   392  			r0 = ret.Get(0).([]api.FeatureLocalInterface)
   393  		}
   394  	}
   395  
   396  	return r0
   397  }
   398  
   399  // EntityLocalInterface_Features_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Features'
   400  type EntityLocalInterface_Features_Call struct {
   401  	*mock.Call
   402  }
   403  
   404  // Features is a helper method to define mock.On call
   405  func (_e *EntityLocalInterface_Expecter) Features() *EntityLocalInterface_Features_Call {
   406  	return &EntityLocalInterface_Features_Call{Call: _e.mock.On("Features")}
   407  }
   408  
   409  func (_c *EntityLocalInterface_Features_Call) Run(run func()) *EntityLocalInterface_Features_Call {
   410  	_c.Call.Run(func(args mock.Arguments) {
   411  		run()
   412  	})
   413  	return _c
   414  }
   415  
   416  func (_c *EntityLocalInterface_Features_Call) Return(_a0 []api.FeatureLocalInterface) *EntityLocalInterface_Features_Call {
   417  	_c.Call.Return(_a0)
   418  	return _c
   419  }
   420  
   421  func (_c *EntityLocalInterface_Features_Call) RunAndReturn(run func() []api.FeatureLocalInterface) *EntityLocalInterface_Features_Call {
   422  	_c.Call.Return(run)
   423  	return _c
   424  }
   425  
   426  // GetOrAddFeature provides a mock function with given fields: featureType, role
   427  func (_m *EntityLocalInterface) GetOrAddFeature(featureType model.FeatureTypeType, role model.RoleType) api.FeatureLocalInterface {
   428  	ret := _m.Called(featureType, role)
   429  
   430  	if len(ret) == 0 {
   431  		panic("no return value specified for GetOrAddFeature")
   432  	}
   433  
   434  	var r0 api.FeatureLocalInterface
   435  	if rf, ok := ret.Get(0).(func(model.FeatureTypeType, model.RoleType) api.FeatureLocalInterface); ok {
   436  		r0 = rf(featureType, role)
   437  	} else {
   438  		if ret.Get(0) != nil {
   439  			r0 = ret.Get(0).(api.FeatureLocalInterface)
   440  		}
   441  	}
   442  
   443  	return r0
   444  }
   445  
   446  // EntityLocalInterface_GetOrAddFeature_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetOrAddFeature'
   447  type EntityLocalInterface_GetOrAddFeature_Call struct {
   448  	*mock.Call
   449  }
   450  
   451  // GetOrAddFeature is a helper method to define mock.On call
   452  //   - featureType model.FeatureTypeType
   453  //   - role model.RoleType
   454  func (_e *EntityLocalInterface_Expecter) GetOrAddFeature(featureType interface{}, role interface{}) *EntityLocalInterface_GetOrAddFeature_Call {
   455  	return &EntityLocalInterface_GetOrAddFeature_Call{Call: _e.mock.On("GetOrAddFeature", featureType, role)}
   456  }
   457  
   458  func (_c *EntityLocalInterface_GetOrAddFeature_Call) Run(run func(featureType model.FeatureTypeType, role model.RoleType)) *EntityLocalInterface_GetOrAddFeature_Call {
   459  	_c.Call.Run(func(args mock.Arguments) {
   460  		run(args[0].(model.FeatureTypeType), args[1].(model.RoleType))
   461  	})
   462  	return _c
   463  }
   464  
   465  func (_c *EntityLocalInterface_GetOrAddFeature_Call) Return(_a0 api.FeatureLocalInterface) *EntityLocalInterface_GetOrAddFeature_Call {
   466  	_c.Call.Return(_a0)
   467  	return _c
   468  }
   469  
   470  func (_c *EntityLocalInterface_GetOrAddFeature_Call) RunAndReturn(run func(model.FeatureTypeType, model.RoleType) api.FeatureLocalInterface) *EntityLocalInterface_GetOrAddFeature_Call {
   471  	_c.Call.Return(run)
   472  	return _c
   473  }
   474  
   475  // HasUseCaseSupport provides a mock function with given fields: actor, useCaseName
   476  func (_m *EntityLocalInterface) HasUseCaseSupport(actor model.UseCaseActorType, useCaseName model.UseCaseNameType) bool {
   477  	ret := _m.Called(actor, useCaseName)
   478  
   479  	if len(ret) == 0 {
   480  		panic("no return value specified for HasUseCaseSupport")
   481  	}
   482  
   483  	var r0 bool
   484  	if rf, ok := ret.Get(0).(func(model.UseCaseActorType, model.UseCaseNameType) bool); ok {
   485  		r0 = rf(actor, useCaseName)
   486  	} else {
   487  		r0 = ret.Get(0).(bool)
   488  	}
   489  
   490  	return r0
   491  }
   492  
   493  // EntityLocalInterface_HasUseCaseSupport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HasUseCaseSupport'
   494  type EntityLocalInterface_HasUseCaseSupport_Call struct {
   495  	*mock.Call
   496  }
   497  
   498  // HasUseCaseSupport is a helper method to define mock.On call
   499  //   - actor model.UseCaseActorType
   500  //   - useCaseName model.UseCaseNameType
   501  func (_e *EntityLocalInterface_Expecter) HasUseCaseSupport(actor interface{}, useCaseName interface{}) *EntityLocalInterface_HasUseCaseSupport_Call {
   502  	return &EntityLocalInterface_HasUseCaseSupport_Call{Call: _e.mock.On("HasUseCaseSupport", actor, useCaseName)}
   503  }
   504  
   505  func (_c *EntityLocalInterface_HasUseCaseSupport_Call) Run(run func(actor model.UseCaseActorType, useCaseName model.UseCaseNameType)) *EntityLocalInterface_HasUseCaseSupport_Call {
   506  	_c.Call.Run(func(args mock.Arguments) {
   507  		run(args[0].(model.UseCaseActorType), args[1].(model.UseCaseNameType))
   508  	})
   509  	return _c
   510  }
   511  
   512  func (_c *EntityLocalInterface_HasUseCaseSupport_Call) Return(_a0 bool) *EntityLocalInterface_HasUseCaseSupport_Call {
   513  	_c.Call.Return(_a0)
   514  	return _c
   515  }
   516  
   517  func (_c *EntityLocalInterface_HasUseCaseSupport_Call) RunAndReturn(run func(model.UseCaseActorType, model.UseCaseNameType) bool) *EntityLocalInterface_HasUseCaseSupport_Call {
   518  	_c.Call.Return(run)
   519  	return _c
   520  }
   521  
   522  // Information provides a mock function with given fields:
   523  func (_m *EntityLocalInterface) Information() *model.NodeManagementDetailedDiscoveryEntityInformationType {
   524  	ret := _m.Called()
   525  
   526  	if len(ret) == 0 {
   527  		panic("no return value specified for Information")
   528  	}
   529  
   530  	var r0 *model.NodeManagementDetailedDiscoveryEntityInformationType
   531  	if rf, ok := ret.Get(0).(func() *model.NodeManagementDetailedDiscoveryEntityInformationType); ok {
   532  		r0 = rf()
   533  	} else {
   534  		if ret.Get(0) != nil {
   535  			r0 = ret.Get(0).(*model.NodeManagementDetailedDiscoveryEntityInformationType)
   536  		}
   537  	}
   538  
   539  	return r0
   540  }
   541  
   542  // EntityLocalInterface_Information_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Information'
   543  type EntityLocalInterface_Information_Call struct {
   544  	*mock.Call
   545  }
   546  
   547  // Information is a helper method to define mock.On call
   548  func (_e *EntityLocalInterface_Expecter) Information() *EntityLocalInterface_Information_Call {
   549  	return &EntityLocalInterface_Information_Call{Call: _e.mock.On("Information")}
   550  }
   551  
   552  func (_c *EntityLocalInterface_Information_Call) Run(run func()) *EntityLocalInterface_Information_Call {
   553  	_c.Call.Run(func(args mock.Arguments) {
   554  		run()
   555  	})
   556  	return _c
   557  }
   558  
   559  func (_c *EntityLocalInterface_Information_Call) Return(_a0 *model.NodeManagementDetailedDiscoveryEntityInformationType) *EntityLocalInterface_Information_Call {
   560  	_c.Call.Return(_a0)
   561  	return _c
   562  }
   563  
   564  func (_c *EntityLocalInterface_Information_Call) RunAndReturn(run func() *model.NodeManagementDetailedDiscoveryEntityInformationType) *EntityLocalInterface_Information_Call {
   565  	_c.Call.Return(run)
   566  	return _c
   567  }
   568  
   569  // NextFeatureId provides a mock function with given fields:
   570  func (_m *EntityLocalInterface) NextFeatureId() uint {
   571  	ret := _m.Called()
   572  
   573  	if len(ret) == 0 {
   574  		panic("no return value specified for NextFeatureId")
   575  	}
   576  
   577  	var r0 uint
   578  	if rf, ok := ret.Get(0).(func() uint); ok {
   579  		r0 = rf()
   580  	} else {
   581  		r0 = ret.Get(0).(uint)
   582  	}
   583  
   584  	return r0
   585  }
   586  
   587  // EntityLocalInterface_NextFeatureId_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NextFeatureId'
   588  type EntityLocalInterface_NextFeatureId_Call struct {
   589  	*mock.Call
   590  }
   591  
   592  // NextFeatureId is a helper method to define mock.On call
   593  func (_e *EntityLocalInterface_Expecter) NextFeatureId() *EntityLocalInterface_NextFeatureId_Call {
   594  	return &EntityLocalInterface_NextFeatureId_Call{Call: _e.mock.On("NextFeatureId")}
   595  }
   596  
   597  func (_c *EntityLocalInterface_NextFeatureId_Call) Run(run func()) *EntityLocalInterface_NextFeatureId_Call {
   598  	_c.Call.Run(func(args mock.Arguments) {
   599  		run()
   600  	})
   601  	return _c
   602  }
   603  
   604  func (_c *EntityLocalInterface_NextFeatureId_Call) Return(_a0 uint) *EntityLocalInterface_NextFeatureId_Call {
   605  	_c.Call.Return(_a0)
   606  	return _c
   607  }
   608  
   609  func (_c *EntityLocalInterface_NextFeatureId_Call) RunAndReturn(run func() uint) *EntityLocalInterface_NextFeatureId_Call {
   610  	_c.Call.Return(run)
   611  	return _c
   612  }
   613  
   614  // RemoveAllBindings provides a mock function with given fields:
   615  func (_m *EntityLocalInterface) RemoveAllBindings() {
   616  	_m.Called()
   617  }
   618  
   619  // EntityLocalInterface_RemoveAllBindings_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllBindings'
   620  type EntityLocalInterface_RemoveAllBindings_Call struct {
   621  	*mock.Call
   622  }
   623  
   624  // RemoveAllBindings is a helper method to define mock.On call
   625  func (_e *EntityLocalInterface_Expecter) RemoveAllBindings() *EntityLocalInterface_RemoveAllBindings_Call {
   626  	return &EntityLocalInterface_RemoveAllBindings_Call{Call: _e.mock.On("RemoveAllBindings")}
   627  }
   628  
   629  func (_c *EntityLocalInterface_RemoveAllBindings_Call) Run(run func()) *EntityLocalInterface_RemoveAllBindings_Call {
   630  	_c.Call.Run(func(args mock.Arguments) {
   631  		run()
   632  	})
   633  	return _c
   634  }
   635  
   636  func (_c *EntityLocalInterface_RemoveAllBindings_Call) Return() *EntityLocalInterface_RemoveAllBindings_Call {
   637  	_c.Call.Return()
   638  	return _c
   639  }
   640  
   641  func (_c *EntityLocalInterface_RemoveAllBindings_Call) RunAndReturn(run func()) *EntityLocalInterface_RemoveAllBindings_Call {
   642  	_c.Call.Return(run)
   643  	return _c
   644  }
   645  
   646  // RemoveAllSubscriptions provides a mock function with given fields:
   647  func (_m *EntityLocalInterface) RemoveAllSubscriptions() {
   648  	_m.Called()
   649  }
   650  
   651  // EntityLocalInterface_RemoveAllSubscriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllSubscriptions'
   652  type EntityLocalInterface_RemoveAllSubscriptions_Call struct {
   653  	*mock.Call
   654  }
   655  
   656  // RemoveAllSubscriptions is a helper method to define mock.On call
   657  func (_e *EntityLocalInterface_Expecter) RemoveAllSubscriptions() *EntityLocalInterface_RemoveAllSubscriptions_Call {
   658  	return &EntityLocalInterface_RemoveAllSubscriptions_Call{Call: _e.mock.On("RemoveAllSubscriptions")}
   659  }
   660  
   661  func (_c *EntityLocalInterface_RemoveAllSubscriptions_Call) Run(run func()) *EntityLocalInterface_RemoveAllSubscriptions_Call {
   662  	_c.Call.Run(func(args mock.Arguments) {
   663  		run()
   664  	})
   665  	return _c
   666  }
   667  
   668  func (_c *EntityLocalInterface_RemoveAllSubscriptions_Call) Return() *EntityLocalInterface_RemoveAllSubscriptions_Call {
   669  	_c.Call.Return()
   670  	return _c
   671  }
   672  
   673  func (_c *EntityLocalInterface_RemoveAllSubscriptions_Call) RunAndReturn(run func()) *EntityLocalInterface_RemoveAllSubscriptions_Call {
   674  	_c.Call.Return(run)
   675  	return _c
   676  }
   677  
   678  // RemoveAllUseCaseSupports provides a mock function with given fields:
   679  func (_m *EntityLocalInterface) RemoveAllUseCaseSupports() {
   680  	_m.Called()
   681  }
   682  
   683  // EntityLocalInterface_RemoveAllUseCaseSupports_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveAllUseCaseSupports'
   684  type EntityLocalInterface_RemoveAllUseCaseSupports_Call struct {
   685  	*mock.Call
   686  }
   687  
   688  // RemoveAllUseCaseSupports is a helper method to define mock.On call
   689  func (_e *EntityLocalInterface_Expecter) RemoveAllUseCaseSupports() *EntityLocalInterface_RemoveAllUseCaseSupports_Call {
   690  	return &EntityLocalInterface_RemoveAllUseCaseSupports_Call{Call: _e.mock.On("RemoveAllUseCaseSupports")}
   691  }
   692  
   693  func (_c *EntityLocalInterface_RemoveAllUseCaseSupports_Call) Run(run func()) *EntityLocalInterface_RemoveAllUseCaseSupports_Call {
   694  	_c.Call.Run(func(args mock.Arguments) {
   695  		run()
   696  	})
   697  	return _c
   698  }
   699  
   700  func (_c *EntityLocalInterface_RemoveAllUseCaseSupports_Call) Return() *EntityLocalInterface_RemoveAllUseCaseSupports_Call {
   701  	_c.Call.Return()
   702  	return _c
   703  }
   704  
   705  func (_c *EntityLocalInterface_RemoveAllUseCaseSupports_Call) RunAndReturn(run func()) *EntityLocalInterface_RemoveAllUseCaseSupports_Call {
   706  	_c.Call.Return(run)
   707  	return _c
   708  }
   709  
   710  // RemoveUseCaseSupport provides a mock function with given fields: actor, useCaseName
   711  func (_m *EntityLocalInterface) RemoveUseCaseSupport(actor model.UseCaseActorType, useCaseName model.UseCaseNameType) {
   712  	_m.Called(actor, useCaseName)
   713  }
   714  
   715  // EntityLocalInterface_RemoveUseCaseSupport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveUseCaseSupport'
   716  type EntityLocalInterface_RemoveUseCaseSupport_Call struct {
   717  	*mock.Call
   718  }
   719  
   720  // RemoveUseCaseSupport is a helper method to define mock.On call
   721  //   - actor model.UseCaseActorType
   722  //   - useCaseName model.UseCaseNameType
   723  func (_e *EntityLocalInterface_Expecter) RemoveUseCaseSupport(actor interface{}, useCaseName interface{}) *EntityLocalInterface_RemoveUseCaseSupport_Call {
   724  	return &EntityLocalInterface_RemoveUseCaseSupport_Call{Call: _e.mock.On("RemoveUseCaseSupport", actor, useCaseName)}
   725  }
   726  
   727  func (_c *EntityLocalInterface_RemoveUseCaseSupport_Call) Run(run func(actor model.UseCaseActorType, useCaseName model.UseCaseNameType)) *EntityLocalInterface_RemoveUseCaseSupport_Call {
   728  	_c.Call.Run(func(args mock.Arguments) {
   729  		run(args[0].(model.UseCaseActorType), args[1].(model.UseCaseNameType))
   730  	})
   731  	return _c
   732  }
   733  
   734  func (_c *EntityLocalInterface_RemoveUseCaseSupport_Call) Return() *EntityLocalInterface_RemoveUseCaseSupport_Call {
   735  	_c.Call.Return()
   736  	return _c
   737  }
   738  
   739  func (_c *EntityLocalInterface_RemoveUseCaseSupport_Call) RunAndReturn(run func(model.UseCaseActorType, model.UseCaseNameType)) *EntityLocalInterface_RemoveUseCaseSupport_Call {
   740  	_c.Call.Return(run)
   741  	return _c
   742  }
   743  
   744  // SetDescription provides a mock function with given fields: d
   745  func (_m *EntityLocalInterface) SetDescription(d *model.DescriptionType) {
   746  	_m.Called(d)
   747  }
   748  
   749  // EntityLocalInterface_SetDescription_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetDescription'
   750  type EntityLocalInterface_SetDescription_Call struct {
   751  	*mock.Call
   752  }
   753  
   754  // SetDescription is a helper method to define mock.On call
   755  //   - d *model.DescriptionType
   756  func (_e *EntityLocalInterface_Expecter) SetDescription(d interface{}) *EntityLocalInterface_SetDescription_Call {
   757  	return &EntityLocalInterface_SetDescription_Call{Call: _e.mock.On("SetDescription", d)}
   758  }
   759  
   760  func (_c *EntityLocalInterface_SetDescription_Call) Run(run func(d *model.DescriptionType)) *EntityLocalInterface_SetDescription_Call {
   761  	_c.Call.Run(func(args mock.Arguments) {
   762  		run(args[0].(*model.DescriptionType))
   763  	})
   764  	return _c
   765  }
   766  
   767  func (_c *EntityLocalInterface_SetDescription_Call) Return() *EntityLocalInterface_SetDescription_Call {
   768  	_c.Call.Return()
   769  	return _c
   770  }
   771  
   772  func (_c *EntityLocalInterface_SetDescription_Call) RunAndReturn(run func(*model.DescriptionType)) *EntityLocalInterface_SetDescription_Call {
   773  	_c.Call.Return(run)
   774  	return _c
   775  }
   776  
   777  // SetUseCaseAvailability provides a mock function with given fields: actor, useCaseName, available
   778  func (_m *EntityLocalInterface) SetUseCaseAvailability(actor model.UseCaseActorType, useCaseName model.UseCaseNameType, available bool) {
   779  	_m.Called(actor, useCaseName, available)
   780  }
   781  
   782  // EntityLocalInterface_SetUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetUseCaseAvailability'
   783  type EntityLocalInterface_SetUseCaseAvailability_Call struct {
   784  	*mock.Call
   785  }
   786  
   787  // SetUseCaseAvailability is a helper method to define mock.On call
   788  //   - actor model.UseCaseActorType
   789  //   - useCaseName model.UseCaseNameType
   790  //   - available bool
   791  func (_e *EntityLocalInterface_Expecter) SetUseCaseAvailability(actor interface{}, useCaseName interface{}, available interface{}) *EntityLocalInterface_SetUseCaseAvailability_Call {
   792  	return &EntityLocalInterface_SetUseCaseAvailability_Call{Call: _e.mock.On("SetUseCaseAvailability", actor, useCaseName, available)}
   793  }
   794  
   795  func (_c *EntityLocalInterface_SetUseCaseAvailability_Call) Run(run func(actor model.UseCaseActorType, useCaseName model.UseCaseNameType, available bool)) *EntityLocalInterface_SetUseCaseAvailability_Call {
   796  	_c.Call.Run(func(args mock.Arguments) {
   797  		run(args[0].(model.UseCaseActorType), args[1].(model.UseCaseNameType), args[2].(bool))
   798  	})
   799  	return _c
   800  }
   801  
   802  func (_c *EntityLocalInterface_SetUseCaseAvailability_Call) Return() *EntityLocalInterface_SetUseCaseAvailability_Call {
   803  	_c.Call.Return()
   804  	return _c
   805  }
   806  
   807  func (_c *EntityLocalInterface_SetUseCaseAvailability_Call) RunAndReturn(run func(model.UseCaseActorType, model.UseCaseNameType, bool)) *EntityLocalInterface_SetUseCaseAvailability_Call {
   808  	_c.Call.Return(run)
   809  	return _c
   810  }
   811  
   812  // NewEntityLocalInterface creates a new instance of EntityLocalInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
   813  // The first argument is typically a *testing.T value.
   814  func NewEntityLocalInterface(t interface {
   815  	mock.TestingT
   816  	Cleanup(func())
   817  }) *EntityLocalInterface {
   818  	mock := &EntityLocalInterface{}
   819  	mock.Mock.Test(t)
   820  
   821  	t.Cleanup(func() { mock.AssertExpectations(t) })
   822  
   823  	return mock
   824  }