github.com/enbility/spine-go@v0.7.0/mocks/DeviceLocalInterface.go

// Code generated by mockery v2.45.0. DO NOT EDIT.

package mocks

import (
	api "github.com/enbility/spine-go/api"
	mock "github.com/stretchr/testify/mock"

	model "github.com/enbility/spine-go/model"

	ship_goapi "github.com/enbility/ship-go/api"
)

// DeviceLocalInterface is an autogenerated mock type for the DeviceLocalInterface type
type DeviceLocalInterface struct {
	mock.Mock
}

type DeviceLocalInterface_Expecter struct {
	mock *mock.Mock
}

func (_m *DeviceLocalInterface) EXPECT() *DeviceLocalInterface_Expecter {
	return &DeviceLocalInterface_Expecter{mock: &_m.Mock}
}

// AddEntity provides a mock function with given fields: entity
func (_m *DeviceLocalInterface) AddEntity(entity api.EntityLocalInterface) {
	_m.Called(entity)
}

// DeviceLocalInterface_AddEntity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddEntity'
type DeviceLocalInterface_AddEntity_Call struct {
	*mock.Call
}

// AddEntity is a helper method to define mock.On call
//   - entity api.EntityLocalInterface
func (_e *DeviceLocalInterface_Expecter) AddEntity(entity interface{}) *DeviceLocalInterface_AddEntity_Call {
	return &DeviceLocalInterface_AddEntity_Call{Call: _e.mock.On("AddEntity", entity)}
}

func (_c *DeviceLocalInterface_AddEntity_Call) Run(run func(entity api.EntityLocalInterface)) *DeviceLocalInterface_AddEntity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(api.EntityLocalInterface))
	})
	return _c
}

func (_c *DeviceLocalInterface_AddEntity_Call) Return() *DeviceLocalInterface_AddEntity_Call {
	_c.Call.Return()
	return _c
}

func (_c *DeviceLocalInterface_AddEntity_Call) RunAndReturn(run func(api.EntityLocalInterface)) *DeviceLocalInterface_AddEntity_Call {
	_c.Call.Return(run)
	return _c
}

// AddRemoteDeviceForSki provides a mock function with given fields: ski, rDevice
func (_m *DeviceLocalInterface) AddRemoteDeviceForSki(ski string, rDevice api.DeviceRemoteInterface) {
	_m.Called(ski, rDevice)
}

// DeviceLocalInterface_AddRemoteDeviceForSki_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddRemoteDeviceForSki'
type DeviceLocalInterface_AddRemoteDeviceForSki_Call struct {
	*mock.Call
}

// AddRemoteDeviceForSki is a helper method to define mock.On call
//   - ski string
//   - rDevice api.DeviceRemoteInterface
func (_e *DeviceLocalInterface_Expecter) AddRemoteDeviceForSki(ski interface{}, rDevice interface{}) *DeviceLocalInterface_AddRemoteDeviceForSki_Call {
	return &DeviceLocalInterface_AddRemoteDeviceForSki_Call{Call: _e.mock.On("AddRemoteDeviceForSki", ski, rDevice)}
}

func (_c *DeviceLocalInterface_AddRemoteDeviceForSki_Call) Run(run func(ski string, rDevice api.DeviceRemoteInterface)) *DeviceLocalInterface_AddRemoteDeviceForSki_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(api.DeviceRemoteInterface))
	})
	return _c
}

func (_c *DeviceLocalInterface_AddRemoteDeviceForSki_Call) Return() *DeviceLocalInterface_AddRemoteDeviceForSki_Call {
	_c.Call.Return()
	return _c
}

func (_c *DeviceLocalInterface_AddRemoteDeviceForSki_Call) RunAndReturn(run func(string, api.DeviceRemoteInterface)) *DeviceLocalInterface_AddRemoteDeviceForSki_Call {
	_c.Call.Return(run)
	return _c
}

// Address provides a mock function with given fields:
func (_m *DeviceLocalInterface) Address() *model.AddressDeviceType {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Address")
	}

	var r0 *model.AddressDeviceType
	if rf, ok := ret.Get(0).(func() *model.AddressDeviceType); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.AddressDeviceType)
		}
	}

	return r0
}

// DeviceLocalInterface_Address_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Address'
type DeviceLocalInterface_Address_Call struct {
	*mock.Call
}

// Address is a helper method to define mock.On call
func (_e *DeviceLocalInterface_Expecter) Address() *DeviceLocalInterface_Address_Call {
	return &DeviceLocalInterface_Address_Call{Call: _e.mock.On("Address")}
}

func (_c *DeviceLocalInterface_Address_Call) Run(run func()) *DeviceLocalInterface_Address_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *DeviceLocalInterface_Address_Call) Return(_a0 *model.AddressDeviceType) *DeviceLocalInterface_Address_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_Address_Call) RunAndReturn(run func() *model.AddressDeviceType) *DeviceLocalInterface_Address_Call {
	_c.Call.Return(run)
	return _c
}

// BindingManager provides a mock function with given fields:
func (_m *DeviceLocalInterface) BindingManager() api.BindingManagerInterface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for BindingManager")
	}

	var r0 api.BindingManagerInterface
	if rf, ok := ret.Get(0).(func() api.BindingManagerInterface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(api.BindingManagerInterface)
		}
	}

	return r0
}

// DeviceLocalInterface_BindingManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'BindingManager'
type DeviceLocalInterface_BindingManager_Call struct {
	*mock.Call
}

// BindingManager is a helper method to define mock.On call
func (_e *DeviceLocalInterface_Expecter) BindingManager() *DeviceLocalInterface_BindingManager_Call {
	return &DeviceLocalInterface_BindingManager_Call{Call: _e.mock.On("BindingManager")}
}

func (_c *DeviceLocalInterface_BindingManager_Call) Run(run func()) *DeviceLocalInterface_BindingManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *DeviceLocalInterface_BindingManager_Call) Return(_a0 api.BindingManagerInterface) *DeviceLocalInterface_BindingManager_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_BindingManager_Call) RunAndReturn(run func() api.BindingManagerInterface) *DeviceLocalInterface_BindingManager_Call {
	_c.Call.Return(run)
	return _c
}

// CleanRemoteEntityCaches provides a mock function with given fields: remoteAddress
func (_m *DeviceLocalInterface) CleanRemoteEntityCaches(remoteAddress *model.EntityAddressType) {
	_m.Called(remoteAddress)
}

// DeviceLocalInterface_CleanRemoteEntityCaches_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CleanRemoteEntityCaches'
type DeviceLocalInterface_CleanRemoteEntityCaches_Call struct {
	*mock.Call
}

// CleanRemoteEntityCaches is a helper method to define mock.On call
//   - remoteAddress *model.EntityAddressType
func (_e *DeviceLocalInterface_Expecter) CleanRemoteEntityCaches(remoteAddress interface{}) *DeviceLocalInterface_CleanRemoteEntityCaches_Call {
	return &DeviceLocalInterface_CleanRemoteEntityCaches_Call{Call: _e.mock.On("CleanRemoteEntityCaches", remoteAddress)}
}

func (_c *DeviceLocalInterface_CleanRemoteEntityCaches_Call) Run(run func(remoteAddress *model.EntityAddressType)) *DeviceLocalInterface_CleanRemoteEntityCaches_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.EntityAddressType))
	})
	return _c
}

func (_c *DeviceLocalInterface_CleanRemoteEntityCaches_Call) Return() *DeviceLocalInterface_CleanRemoteEntityCaches_Call {
	_c.Call.Return()
	return _c
}

func (_c *DeviceLocalInterface_CleanRemoteEntityCaches_Call) RunAndReturn(run func(*model.EntityAddressType)) *DeviceLocalInterface_CleanRemoteEntityCaches_Call {
	_c.Call.Return(run)
	return _c
}

// DestinationData provides a mock function with given fields:
func (_m *DeviceLocalInterface) DestinationData() model.NodeManagementDestinationDataType {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for DestinationData")
	}

	var r0 model.NodeManagementDestinationDataType
	if rf, ok := ret.Get(0).(func() model.NodeManagementDestinationDataType); ok {
		r0 = rf()
	} else {
		r0 = ret.Get(0).(model.NodeManagementDestinationDataType)
	}

	return r0
}

// DeviceLocalInterface_DestinationData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DestinationData'
type DeviceLocalInterface_DestinationData_Call struct {
	*mock.Call
}

// DestinationData is a helper method to define mock.On call
func (_e *DeviceLocalInterface_Expecter) DestinationData() *DeviceLocalInterface_DestinationData_Call {
	return &DeviceLocalInterface_DestinationData_Call{Call: _e.mock.On("DestinationData")}
}

func (_c *DeviceLocalInterface_DestinationData_Call) Run(run func()) *DeviceLocalInterface_DestinationData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *DeviceLocalInterface_DestinationData_Call) Return(_a0 model.NodeManagementDestinationDataType) *DeviceLocalInterface_DestinationData_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_DestinationData_Call) RunAndReturn(run func() model.NodeManagementDestinationDataType) *DeviceLocalInterface_DestinationData_Call {
	_c.Call.Return(run)
	return _c
}

// DeviceType provides a mock function with given fields:
func (_m *DeviceLocalInterface) DeviceType() *model.DeviceTypeType {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for DeviceType")
	}

	var r0 *model.DeviceTypeType
	if rf, ok := ret.Get(0).(func() *model.DeviceTypeType); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.DeviceTypeType)
		}
	}

	return r0
}

// DeviceLocalInterface_DeviceType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'DeviceType'
type DeviceLocalInterface_DeviceType_Call struct {
	*mock.Call
}

// DeviceType is a helper method to define mock.On call
func (_e *DeviceLocalInterface_Expecter) DeviceType() *DeviceLocalInterface_DeviceType_Call {
	return &DeviceLocalInterface_DeviceType_Call{Call: _e.mock.On("DeviceType")}
}

func (_c *DeviceLocalInterface_DeviceType_Call) Run(run func()) *DeviceLocalInterface_DeviceType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *DeviceLocalInterface_DeviceType_Call) Return(_a0 *model.DeviceTypeType) *DeviceLocalInterface_DeviceType_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_DeviceType_Call) RunAndReturn(run func() *model.DeviceTypeType) *DeviceLocalInterface_DeviceType_Call {
	_c.Call.Return(run)
	return _c
}

// Entities provides a mock function with given fields:
func (_m *DeviceLocalInterface) Entities() []api.EntityLocalInterface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Entities")
	}

	var r0 []api.EntityLocalInterface
	if rf, ok := ret.Get(0).(func() []api.EntityLocalInterface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]api.EntityLocalInterface)
		}
	}

	return r0
}

// DeviceLocalInterface_Entities_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Entities'
type DeviceLocalInterface_Entities_Call struct {
	*mock.Call
}

// Entities is a helper method to define mock.On call
func (_e *DeviceLocalInterface_Expecter) Entities() *DeviceLocalInterface_Entities_Call {
	return &DeviceLocalInterface_Entities_Call{Call: _e.mock.On("Entities")}
}

func (_c *DeviceLocalInterface_Entities_Call) Run(run func()) *DeviceLocalInterface_Entities_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *DeviceLocalInterface_Entities_Call) Return(_a0 []api.EntityLocalInterface) *DeviceLocalInterface_Entities_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_Entities_Call) RunAndReturn(run func() []api.EntityLocalInterface) *DeviceLocalInterface_Entities_Call {
	_c.Call.Return(run)
	return _c
}

// Entity provides a mock function with given fields: id
func (_m *DeviceLocalInterface) Entity(id []model.AddressEntityType) api.EntityLocalInterface {
	ret := _m.Called(id)

	if len(ret) == 0 {
		panic("no return value specified for Entity")
	}

	var r0 api.EntityLocalInterface
	if rf, ok := ret.Get(0).(func([]model.AddressEntityType) api.EntityLocalInterface); ok {
		r0 = rf(id)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(api.EntityLocalInterface)
		}
	}

	return r0
}

// DeviceLocalInterface_Entity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Entity'
type DeviceLocalInterface_Entity_Call struct {
	*mock.Call
}

// Entity is a helper method to define mock.On call
//   - id []model.AddressEntityType
func (_e *DeviceLocalInterface_Expecter) Entity(id interface{}) *DeviceLocalInterface_Entity_Call {
	return &DeviceLocalInterface_Entity_Call{Call: _e.mock.On("Entity", id)}
}

func (_c *DeviceLocalInterface_Entity_Call) Run(run func(id []model.AddressEntityType)) *DeviceLocalInterface_Entity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].([]model.AddressEntityType))
	})
	return _c
}

func (_c *DeviceLocalInterface_Entity_Call) Return(_a0 api.EntityLocalInterface) *DeviceLocalInterface_Entity_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_Entity_Call) RunAndReturn(run func([]model.AddressEntityType) api.EntityLocalInterface) *DeviceLocalInterface_Entity_Call {
	_c.Call.Return(run)
	return _c
}

// EntityForType provides a mock function with given fields: entityType
func (_m *DeviceLocalInterface) EntityForType(entityType model.EntityTypeType) api.EntityLocalInterface {
	ret := _m.Called(entityType)

	if len(ret) == 0 {
		panic("no return value specified for EntityForType")
	}

	var r0 api.EntityLocalInterface
	if rf, ok := ret.Get(0).(func(model.EntityTypeType) api.EntityLocalInterface); ok {
		r0 = rf(entityType)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(api.EntityLocalInterface)
		}
	}

	return r0
}

// DeviceLocalInterface_EntityForType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EntityForType'
type DeviceLocalInterface_EntityForType_Call struct {
	*mock.Call
}

// EntityForType is a helper method to define mock.On call
//   - entityType model.EntityTypeType
func (_e *DeviceLocalInterface_Expecter) EntityForType(entityType interface{}) *DeviceLocalInterface_EntityForType_Call {
	return &DeviceLocalInterface_EntityForType_Call{Call: _e.mock.On("EntityForType", entityType)}
}

func (_c *DeviceLocalInterface_EntityForType_Call) Run(run func(entityType model.EntityTypeType)) *DeviceLocalInterface_EntityForType_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.EntityTypeType))
	})
	return _c
}

func (_c *DeviceLocalInterface_EntityForType_Call) Return(_a0 api.EntityLocalInterface) *DeviceLocalInterface_EntityForType_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_EntityForType_Call) RunAndReturn(run func(model.EntityTypeType) api.EntityLocalInterface) *DeviceLocalInterface_EntityForType_Call {
	_c.Call.Return(run)
	return _c
}

// FeatureByAddress provides a mock function with given fields: address
func (_m *DeviceLocalInterface) FeatureByAddress(address *model.FeatureAddressType) api.FeatureLocalInterface {
	ret := _m.Called(address)

	if len(ret) == 0 {
		panic("no return value specified for FeatureByAddress")
	}

	var r0 api.FeatureLocalInterface
	if rf, ok := ret.Get(0).(func(*model.FeatureAddressType) api.FeatureLocalInterface); ok {
		r0 = rf(address)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(api.FeatureLocalInterface)
		}
	}

	return r0
}

// DeviceLocalInterface_FeatureByAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FeatureByAddress'
type DeviceLocalInterface_FeatureByAddress_Call struct {
	*mock.Call
}

// FeatureByAddress is a helper method to define mock.On call
//   - address *model.FeatureAddressType
func (_e *DeviceLocalInterface_Expecter) FeatureByAddress(address interface{}) *DeviceLocalInterface_FeatureByAddress_Call {
	return &DeviceLocalInterface_FeatureByAddress_Call{Call: _e.mock.On("FeatureByAddress", address)}
}

func (_c *DeviceLocalInterface_FeatureByAddress_Call) Run(run func(address *model.FeatureAddressType)) *DeviceLocalInterface_FeatureByAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.FeatureAddressType))
	})
	return _c
}

func (_c *DeviceLocalInterface_FeatureByAddress_Call) Return(_a0 api.FeatureLocalInterface) *DeviceLocalInterface_FeatureByAddress_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_FeatureByAddress_Call) RunAndReturn(run func(*model.FeatureAddressType) api.FeatureLocalInterface) *DeviceLocalInterface_FeatureByAddress_Call {
	_c.Call.Return(run)
	return _c
}

// FeatureSet provides a mock function with given fields:
func (_m *DeviceLocalInterface) FeatureSet() *model.NetworkManagementFeatureSetType {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for FeatureSet")
	}

	var r0 *model.NetworkManagementFeatureSetType
	if rf, ok := ret.Get(0).(func() *model.NetworkManagementFeatureSetType); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.NetworkManagementFeatureSetType)
		}
	}

	return r0
}

// DeviceLocalInterface_FeatureSet_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FeatureSet'
type DeviceLocalInterface_FeatureSet_Call struct {
	*mock.Call
}

// FeatureSet is a helper method to define mock.On call
func (_e *DeviceLocalInterface_Expecter) FeatureSet() *DeviceLocalInterface_FeatureSet_Call {
	return &DeviceLocalInterface_FeatureSet_Call{Call: _e.mock.On("FeatureSet")}
}

func (_c *DeviceLocalInterface_FeatureSet_Call) Run(run func()) *DeviceLocalInterface_FeatureSet_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *DeviceLocalInterface_FeatureSet_Call) Return(_a0 *model.NetworkManagementFeatureSetType) *DeviceLocalInterface_FeatureSet_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_FeatureSet_Call) RunAndReturn(run func() *model.NetworkManagementFeatureSetType) *DeviceLocalInterface_FeatureSet_Call {
	_c.Call.Return(run)
	return _c
}

// HeartbeatManager provides a mock function with given fields:
func (_m *DeviceLocalInterface) HeartbeatManager() api.HeartbeatManagerInterface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for HeartbeatManager")
	}

	var r0 api.HeartbeatManagerInterface
	if rf, ok := ret.Get(0).(func() api.HeartbeatManagerInterface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(api.HeartbeatManagerInterface)
		}
	}

	return r0
}

// DeviceLocalInterface_HeartbeatManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'HeartbeatManager'
type DeviceLocalInterface_HeartbeatManager_Call struct {
	*mock.Call
}

// HeartbeatManager is a helper method to define mock.On call
func (_e *DeviceLocalInterface_Expecter) HeartbeatManager() *DeviceLocalInterface_HeartbeatManager_Call {
	return &DeviceLocalInterface_HeartbeatManager_Call{Call: _e.mock.On("HeartbeatManager")}
}

func (_c *DeviceLocalInterface_HeartbeatManager_Call) Run(run func()) *DeviceLocalInterface_HeartbeatManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *DeviceLocalInterface_HeartbeatManager_Call) Return(_a0 api.HeartbeatManagerInterface) *DeviceLocalInterface_HeartbeatManager_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_HeartbeatManager_Call) RunAndReturn(run func() api.HeartbeatManagerInterface) *DeviceLocalInterface_HeartbeatManager_Call {
	_c.Call.Return(run)
	return _c
}

// Information provides a mock function with given fields:
func (_m *DeviceLocalInterface) Information() *model.NodeManagementDetailedDiscoveryDeviceInformationType {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for Information")
	}

	var r0 *model.NodeManagementDetailedDiscoveryDeviceInformationType
	if rf, ok := ret.Get(0).(func() *model.NodeManagementDetailedDiscoveryDeviceInformationType); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.NodeManagementDetailedDiscoveryDeviceInformationType)
		}
	}

	return r0
}

// DeviceLocalInterface_Information_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Information'
type DeviceLocalInterface_Information_Call struct {
	*mock.Call
}

// Information is a helper method to define mock.On call
func (_e *DeviceLocalInterface_Expecter) Information() *DeviceLocalInterface_Information_Call {
	return &DeviceLocalInterface_Information_Call{Call: _e.mock.On("Information")}
}

func (_c *DeviceLocalInterface_Information_Call) Run(run func()) *DeviceLocalInterface_Information_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *DeviceLocalInterface_Information_Call) Return(_a0 *model.NodeManagementDetailedDiscoveryDeviceInformationType) *DeviceLocalInterface_Information_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_Information_Call) RunAndReturn(run func() *model.NodeManagementDetailedDiscoveryDeviceInformationType) *DeviceLocalInterface_Information_Call {
	_c.Call.Return(run)
	return _c
}

// NodeManagement provides a mock function with given fields:
func (_m *DeviceLocalInterface) NodeManagement() api.NodeManagementInterface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for NodeManagement")
	}

	var r0 api.NodeManagementInterface
	if rf, ok := ret.Get(0).(func() api.NodeManagementInterface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(api.NodeManagementInterface)
		}
	}

	return r0
}

// DeviceLocalInterface_NodeManagement_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NodeManagement'
type DeviceLocalInterface_NodeManagement_Call struct {
	*mock.Call
}

// NodeManagement is a helper method to define mock.On call
func (_e *DeviceLocalInterface_Expecter) NodeManagement() *DeviceLocalInterface_NodeManagement_Call {
	return &DeviceLocalInterface_NodeManagement_Call{Call: _e.mock.On("NodeManagement")}
}

func (_c *DeviceLocalInterface_NodeManagement_Call) Run(run func()) *DeviceLocalInterface_NodeManagement_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *DeviceLocalInterface_NodeManagement_Call) Return(_a0 api.NodeManagementInterface) *DeviceLocalInterface_NodeManagement_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_NodeManagement_Call) RunAndReturn(run func() api.NodeManagementInterface) *DeviceLocalInterface_NodeManagement_Call {
	_c.Call.Return(run)
	return _c
}

// NotifySubscribers provides a mock function with given fields: featureAddress, cmd
func (_m *DeviceLocalInterface) NotifySubscribers(featureAddress *model.FeatureAddressType, cmd model.CmdType) {
	_m.Called(featureAddress, cmd)
}

// DeviceLocalInterface_NotifySubscribers_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'NotifySubscribers'
type DeviceLocalInterface_NotifySubscribers_Call struct {
	*mock.Call
}

// NotifySubscribers is a helper method to define mock.On call
//   - featureAddress *model.FeatureAddressType
//   - cmd model.CmdType
func (_e *DeviceLocalInterface_Expecter) NotifySubscribers(featureAddress interface{}, cmd interface{}) *DeviceLocalInterface_NotifySubscribers_Call {
	return &DeviceLocalInterface_NotifySubscribers_Call{Call: _e.mock.On("NotifySubscribers", featureAddress, cmd)}
}

func (_c *DeviceLocalInterface_NotifySubscribers_Call) Run(run func(featureAddress *model.FeatureAddressType, cmd model.CmdType)) *DeviceLocalInterface_NotifySubscribers_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(*model.FeatureAddressType), args[1].(model.CmdType))
	})
	return _c
}

func (_c *DeviceLocalInterface_NotifySubscribers_Call) Return() *DeviceLocalInterface_NotifySubscribers_Call {
	_c.Call.Return()
	return _c
}

func (_c *DeviceLocalInterface_NotifySubscribers_Call) RunAndReturn(run func(*model.FeatureAddressType, model.CmdType)) *DeviceLocalInterface_NotifySubscribers_Call {
	_c.Call.Return(run)
	return _c
}

// ProcessCmd provides a mock function with given fields: datagram, remoteDevice
func (_m *DeviceLocalInterface) ProcessCmd(datagram model.DatagramType, remoteDevice api.DeviceRemoteInterface) error {
	ret := _m.Called(datagram, remoteDevice)

	if len(ret) == 0 {
		panic("no return value specified for ProcessCmd")
	}

	var r0 error
	if rf, ok := ret.Get(0).(func(model.DatagramType, api.DeviceRemoteInterface) error); ok {
		r0 = rf(datagram, remoteDevice)
	} else {
		r0 = ret.Error(0)
	}

	return r0
}

// DeviceLocalInterface_ProcessCmd_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProcessCmd'
type DeviceLocalInterface_ProcessCmd_Call struct {
	*mock.Call
}

// ProcessCmd is a helper method to define mock.On call
//   - datagram model.DatagramType
//   - remoteDevice api.DeviceRemoteInterface
func (_e *DeviceLocalInterface_Expecter) ProcessCmd(datagram interface{}, remoteDevice interface{}) *DeviceLocalInterface_ProcessCmd_Call {
	return &DeviceLocalInterface_ProcessCmd_Call{Call: _e.mock.On("ProcessCmd", datagram, remoteDevice)}
}

func (_c *DeviceLocalInterface_ProcessCmd_Call) Run(run func(datagram model.DatagramType, remoteDevice api.DeviceRemoteInterface)) *DeviceLocalInterface_ProcessCmd_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.DatagramType), args[1].(api.DeviceRemoteInterface))
	})
	return _c
}

func (_c *DeviceLocalInterface_ProcessCmd_Call) Return(_a0 error) *DeviceLocalInterface_ProcessCmd_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_ProcessCmd_Call) RunAndReturn(run func(model.DatagramType, api.DeviceRemoteInterface) error) *DeviceLocalInterface_ProcessCmd_Call {
	_c.Call.Return(run)
	return _c
}

// RemoteDeviceForAddress provides a mock function with given fields: address
func (_m *DeviceLocalInterface) RemoteDeviceForAddress(address model.AddressDeviceType) api.DeviceRemoteInterface {
	ret := _m.Called(address)

	if len(ret) == 0 {
		panic("no return value specified for RemoteDeviceForAddress")
	}

	var r0 api.DeviceRemoteInterface
	if rf, ok := ret.Get(0).(func(model.AddressDeviceType) api.DeviceRemoteInterface); ok {
		r0 = rf(address)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(api.DeviceRemoteInterface)
		}
	}

	return r0
}

// DeviceLocalInterface_RemoteDeviceForAddress_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoteDeviceForAddress'
type DeviceLocalInterface_RemoteDeviceForAddress_Call struct {
	*mock.Call
}

// RemoteDeviceForAddress is a helper method to define mock.On call
//   - address model.AddressDeviceType
func (_e *DeviceLocalInterface_Expecter) RemoteDeviceForAddress(address interface{}) *DeviceLocalInterface_RemoteDeviceForAddress_Call {
	return &DeviceLocalInterface_RemoteDeviceForAddress_Call{Call: _e.mock.On("RemoteDeviceForAddress", address)}
}

func (_c *DeviceLocalInterface_RemoteDeviceForAddress_Call) Run(run func(address model.AddressDeviceType)) *DeviceLocalInterface_RemoteDeviceForAddress_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(model.AddressDeviceType))
	})
	return _c
}

func (_c *DeviceLocalInterface_RemoteDeviceForAddress_Call) Return(_a0 api.DeviceRemoteInterface) *DeviceLocalInterface_RemoteDeviceForAddress_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_RemoteDeviceForAddress_Call) RunAndReturn(run func(model.AddressDeviceType) api.DeviceRemoteInterface) *DeviceLocalInterface_RemoteDeviceForAddress_Call {
	_c.Call.Return(run)
	return _c
}

// RemoteDeviceForSki provides a mock function with given fields: ski
func (_m *DeviceLocalInterface) RemoteDeviceForSki(ski string) api.DeviceRemoteInterface {
	ret := _m.Called(ski)

	if len(ret) == 0 {
		panic("no return value specified for RemoteDeviceForSki")
	}

	var r0 api.DeviceRemoteInterface
	if rf, ok := ret.Get(0).(func(string) api.DeviceRemoteInterface); ok {
		r0 = rf(ski)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(api.DeviceRemoteInterface)
		}
	}

	return r0
}

// DeviceLocalInterface_RemoteDeviceForSki_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoteDeviceForSki'
type DeviceLocalInterface_RemoteDeviceForSki_Call struct {
	*mock.Call
}

// RemoteDeviceForSki is a helper method to define mock.On call
//   - ski string
func (_e *DeviceLocalInterface_Expecter) RemoteDeviceForSki(ski interface{}) *DeviceLocalInterface_RemoteDeviceForSki_Call {
	return &DeviceLocalInterface_RemoteDeviceForSki_Call{Call: _e.mock.On("RemoteDeviceForSki", ski)}
}

func (_c *DeviceLocalInterface_RemoteDeviceForSki_Call) Run(run func(ski string)) *DeviceLocalInterface_RemoteDeviceForSki_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *DeviceLocalInterface_RemoteDeviceForSki_Call) Return(_a0 api.DeviceRemoteInterface) *DeviceLocalInterface_RemoteDeviceForSki_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_RemoteDeviceForSki_Call) RunAndReturn(run func(string) api.DeviceRemoteInterface) *DeviceLocalInterface_RemoteDeviceForSki_Call {
	_c.Call.Return(run)
	return _c
}

// RemoteDevices provides a mock function with given fields:
func (_m *DeviceLocalInterface) RemoteDevices() []api.DeviceRemoteInterface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for RemoteDevices")
	}

	var r0 []api.DeviceRemoteInterface
	if rf, ok := ret.Get(0).(func() []api.DeviceRemoteInterface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).([]api.DeviceRemoteInterface)
		}
	}

	return r0
}

// DeviceLocalInterface_RemoteDevices_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoteDevices'
type DeviceLocalInterface_RemoteDevices_Call struct {
	*mock.Call
}

// RemoteDevices is a helper method to define mock.On call
func (_e *DeviceLocalInterface_Expecter) RemoteDevices() *DeviceLocalInterface_RemoteDevices_Call {
	return &DeviceLocalInterface_RemoteDevices_Call{Call: _e.mock.On("RemoteDevices")}
}

func (_c *DeviceLocalInterface_RemoteDevices_Call) Run(run func()) *DeviceLocalInterface_RemoteDevices_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *DeviceLocalInterface_RemoteDevices_Call) Return(_a0 []api.DeviceRemoteInterface) *DeviceLocalInterface_RemoteDevices_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_RemoteDevices_Call) RunAndReturn(run func() []api.DeviceRemoteInterface) *DeviceLocalInterface_RemoteDevices_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveEntity provides a mock function with given fields: entity
func (_m *DeviceLocalInterface) RemoveEntity(entity api.EntityLocalInterface) {
	_m.Called(entity)
}

// DeviceLocalInterface_RemoveEntity_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveEntity'
type DeviceLocalInterface_RemoveEntity_Call struct {
	*mock.Call
}

// RemoveEntity is a helper method to define mock.On call
//   - entity api.EntityLocalInterface
func (_e *DeviceLocalInterface_Expecter) RemoveEntity(entity interface{}) *DeviceLocalInterface_RemoveEntity_Call {
	return &DeviceLocalInterface_RemoveEntity_Call{Call: _e.mock.On("RemoveEntity", entity)}
}

func (_c *DeviceLocalInterface_RemoveEntity_Call) Run(run func(entity api.EntityLocalInterface)) *DeviceLocalInterface_RemoveEntity_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(api.EntityLocalInterface))
	})
	return _c
}

func (_c *DeviceLocalInterface_RemoveEntity_Call) Return() *DeviceLocalInterface_RemoveEntity_Call {
	_c.Call.Return()
	return _c
}

func (_c *DeviceLocalInterface_RemoveEntity_Call) RunAndReturn(run func(api.EntityLocalInterface)) *DeviceLocalInterface_RemoveEntity_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveRemoteDevice provides a mock function with given fields: ski
func (_m *DeviceLocalInterface) RemoveRemoteDevice(ski string) {
	_m.Called(ski)
}

// DeviceLocalInterface_RemoveRemoteDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRemoteDevice'
type DeviceLocalInterface_RemoveRemoteDevice_Call struct {
	*mock.Call
}

// RemoveRemoteDevice is a helper method to define mock.On call
//   - ski string
func (_e *DeviceLocalInterface_Expecter) RemoveRemoteDevice(ski interface{}) *DeviceLocalInterface_RemoveRemoteDevice_Call {
	return &DeviceLocalInterface_RemoveRemoteDevice_Call{Call: _e.mock.On("RemoveRemoteDevice", ski)}
}

func (_c *DeviceLocalInterface_RemoveRemoteDevice_Call) Run(run func(ski string)) *DeviceLocalInterface_RemoveRemoteDevice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *DeviceLocalInterface_RemoveRemoteDevice_Call) Return() *DeviceLocalInterface_RemoveRemoteDevice_Call {
	_c.Call.Return()
	return _c
}

func (_c *DeviceLocalInterface_RemoveRemoteDevice_Call) RunAndReturn(run func(string)) *DeviceLocalInterface_RemoveRemoteDevice_Call {
	_c.Call.Return(run)
	return _c
}

// RemoveRemoteDeviceConnection provides a mock function with given fields: ski
func (_m *DeviceLocalInterface) RemoveRemoteDeviceConnection(ski string) {
	_m.Called(ski)
}

// DeviceLocalInterface_RemoveRemoteDeviceConnection_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RemoveRemoteDeviceConnection'
type DeviceLocalInterface_RemoveRemoteDeviceConnection_Call struct {
	*mock.Call
}

// RemoveRemoteDeviceConnection is a helper method to define mock.On call
//   - ski string
func (_e *DeviceLocalInterface_Expecter) RemoveRemoteDeviceConnection(ski interface{}) *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call {
	return &DeviceLocalInterface_RemoveRemoteDeviceConnection_Call{Call: _e.mock.On("RemoveRemoteDeviceConnection", ski)}
}

func (_c *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call) Run(run func(ski string)) *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string))
	})
	return _c
}

func (_c *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call) Return() *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call {
	_c.Call.Return()
	return _c
}

func (_c *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call) RunAndReturn(run func(string)) *DeviceLocalInterface_RemoveRemoteDeviceConnection_Call {
	_c.Call.Return(run)
	return _c
}

// RequestRemoteDetailedDiscoveryData provides a mock function with given fields: rDevice
func (_m *DeviceLocalInterface) RequestRemoteDetailedDiscoveryData(rDevice api.DeviceRemoteInterface) (*model.MsgCounterType, *model.ErrorType) {
	ret := _m.Called(rDevice)

	if len(ret) == 0 {
		panic("no return value specified for RequestRemoteDetailedDiscoveryData")
	}

	var r0 *model.MsgCounterType
	var r1 *model.ErrorType
	if rf, ok := ret.Get(0).(func(api.DeviceRemoteInterface) (*model.MsgCounterType, *model.ErrorType)); ok {
		return rf(rDevice)
	}
	if rf, ok := ret.Get(0).(func(api.DeviceRemoteInterface) *model.MsgCounterType); ok {
		r0 = rf(rDevice)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(*model.MsgCounterType)
		}
	}

	if rf, ok := ret.Get(1).(func(api.DeviceRemoteInterface) *model.ErrorType); ok {
		r1 = rf(rDevice)
	} else {
		if ret.Get(1) != nil {
			r1 = ret.Get(1).(*model.ErrorType)
		}
	}

	return r0, r1
}

// DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'RequestRemoteDetailedDiscoveryData'
type DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call struct {
	*mock.Call
}

// RequestRemoteDetailedDiscoveryData is a helper method to define mock.On call
//   - rDevice api.DeviceRemoteInterface
func (_e *DeviceLocalInterface_Expecter) RequestRemoteDetailedDiscoveryData(rDevice interface{}) *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call {
	return &DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call{Call: _e.mock.On("RequestRemoteDetailedDiscoveryData", rDevice)}
}

func (_c *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call) Run(run func(rDevice api.DeviceRemoteInterface)) *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(api.DeviceRemoteInterface))
	})
	return _c
}

func (_c *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call) Return(_a0 *model.MsgCounterType, _a1 *model.ErrorType) *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call {
	_c.Call.Return(_a0, _a1)
	return _c
}

func (_c *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call) RunAndReturn(run func(api.DeviceRemoteInterface) (*model.MsgCounterType, *model.ErrorType)) *DeviceLocalInterface_RequestRemoteDetailedDiscoveryData_Call {
	_c.Call.Return(run)
	return _c
}

// SetupRemoteDevice provides a mock function with given fields: ski, writeI
func (_m *DeviceLocalInterface) SetupRemoteDevice(ski string, writeI ship_goapi.ShipConnectionDataWriterInterface) ship_goapi.ShipConnectionDataReaderInterface {
	ret := _m.Called(ski, writeI)

	if len(ret) == 0 {
		panic("no return value specified for SetupRemoteDevice")
	}

	var r0 ship_goapi.ShipConnectionDataReaderInterface
	if rf, ok := ret.Get(0).(func(string, ship_goapi.ShipConnectionDataWriterInterface) ship_goapi.ShipConnectionDataReaderInterface); ok {
		r0 = rf(ski, writeI)
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(ship_goapi.ShipConnectionDataReaderInterface)
		}
	}

	return r0
}

// DeviceLocalInterface_SetupRemoteDevice_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetupRemoteDevice'
type DeviceLocalInterface_SetupRemoteDevice_Call struct {
	*mock.Call
}

// SetupRemoteDevice is a helper method to define mock.On call
//   - ski string
//   - writeI ship_goapi.ShipConnectionDataWriterInterface
func (_e *DeviceLocalInterface_Expecter) SetupRemoteDevice(ski interface{}, writeI interface{}) *DeviceLocalInterface_SetupRemoteDevice_Call {
	return &DeviceLocalInterface_SetupRemoteDevice_Call{Call: _e.mock.On("SetupRemoteDevice", ski, writeI)}
}

func (_c *DeviceLocalInterface_SetupRemoteDevice_Call) Run(run func(ski string, writeI ship_goapi.ShipConnectionDataWriterInterface)) *DeviceLocalInterface_SetupRemoteDevice_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run(args[0].(string), args[1].(ship_goapi.ShipConnectionDataWriterInterface))
	})
	return _c
}

func (_c *DeviceLocalInterface_SetupRemoteDevice_Call) Return(_a0 ship_goapi.ShipConnectionDataReaderInterface) *DeviceLocalInterface_SetupRemoteDevice_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_SetupRemoteDevice_Call) RunAndReturn(run func(string, ship_goapi.ShipConnectionDataWriterInterface) ship_goapi.ShipConnectionDataReaderInterface) *DeviceLocalInterface_SetupRemoteDevice_Call {
	_c.Call.Return(run)
	return _c
}

// SubscriptionManager provides a mock function with given fields:
func (_m *DeviceLocalInterface) SubscriptionManager() api.SubscriptionManagerInterface {
	ret := _m.Called()

	if len(ret) == 0 {
		panic("no return value specified for SubscriptionManager")
	}

	var r0 api.SubscriptionManagerInterface
	if rf, ok := ret.Get(0).(func() api.SubscriptionManagerInterface); ok {
		r0 = rf()
	} else {
		if ret.Get(0) != nil {
			r0 = ret.Get(0).(api.SubscriptionManagerInterface)
		}
	}

	return r0
}

// DeviceLocalInterface_SubscriptionManager_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SubscriptionManager'
type DeviceLocalInterface_SubscriptionManager_Call struct {
	*mock.Call
}

// SubscriptionManager is a helper method to define mock.On call
func (_e *DeviceLocalInterface_Expecter) SubscriptionManager() *DeviceLocalInterface_SubscriptionManager_Call {
	return &DeviceLocalInterface_SubscriptionManager_Call{Call: _e.mock.On("SubscriptionManager")}
}

func (_c *DeviceLocalInterface_SubscriptionManager_Call) Run(run func()) *DeviceLocalInterface_SubscriptionManager_Call {
	_c.Call.Run(func(args mock.Arguments) {
		run()
	})
	return _c
}

func (_c *DeviceLocalInterface_SubscriptionManager_Call) Return(_a0 api.SubscriptionManagerInterface) *DeviceLocalInterface_SubscriptionManager_Call {
	_c.Call.Return(_a0)
	return _c
}

func (_c *DeviceLocalInterface_SubscriptionManager_Call) RunAndReturn(run func() api.SubscriptionManagerInterface) *DeviceLocalInterface_SubscriptionManager_Call {
	_c.Call.Return(run)
	return _c
}

// NewDeviceLocalInterface creates a new instance of DeviceLocalInterface. It also registers a testing interface on the mock and a cleanup function to assert the mocks expectations.
// The first argument is typically a *testing.T value.
func NewDeviceLocalInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *DeviceLocalInterface {
	mock := &DeviceLocalInterface{}
	mock.Mock.Test(t)

	t.Cleanup(func() { mock.AssertExpectations(t) })

	return mock
}