mocks

package
v0.5.0 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 18, 2024 License: MIT Imports: 5 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type CemInterface 

type CemInterface struct {
	mock.Mock
}

CemInterface is an autogenerated mock type for the CemInterface type

func NewCemInterface 

func NewCemInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *CemInterface

NewCemInterface creates a new instance of CemInterface. 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 (*CemInterface) AddUseCase 

func (_m *CemInterface) AddUseCase(usecase api.UseCaseInterface)

AddUseCase provides a mock function with given fields: usecase

func (*CemInterface) EXPECT 

func (_m *CemInterface) EXPECT() *CemInterface_Expecter

func (*CemInterface) Setup 

func (_m *CemInterface) Setup() error

Setup provides a mock function with given fields:

func (*CemInterface) Shutdown 

func (_m *CemInterface) Shutdown()

Shutdown provides a mock function with given fields:

func (*CemInterface) Start 

func (_m *CemInterface) Start()

Start provides a mock function with given fields:

type CemInterface_AddUseCase_Call 

type CemInterface_AddUseCase_Call struct {
	*mock.Call
}

CemInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*CemInterface_AddUseCase_Call) Return 

func (_c *CemInterface_AddUseCase_Call) Return() *CemInterface_AddUseCase_Call

func (*CemInterface_AddUseCase_Call) Run 

func (_c *CemInterface_AddUseCase_Call) Run(run func(usecase api.UseCaseInterface)) *CemInterface_AddUseCase_Call

func (*CemInterface_AddUseCase_Call) RunAndReturn 

func (_c *CemInterface_AddUseCase_Call) RunAndReturn(run func(api.UseCaseInterface)) *CemInterface_AddUseCase_Call

type CemInterface_Expecter 

type CemInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*CemInterface_Expecter) AddUseCase 

func (_e *CemInterface_Expecter) AddUseCase(usecase interface{}) *CemInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

  • usecase api.UseCaseInterface

func (*CemInterface_Expecter) Setup 

func (_e *CemInterface_Expecter) Setup() *CemInterface_Setup_Call

Setup is a helper method to define mock.On call

func (*CemInterface_Expecter) Shutdown 

func (_e *CemInterface_Expecter) Shutdown() *CemInterface_Shutdown_Call

Shutdown is a helper method to define mock.On call

func (*CemInterface_Expecter) Start 

func (_e *CemInterface_Expecter) Start() *CemInterface_Start_Call

Start is a helper method to define mock.On call

type CemInterface_Setup_Call 

type CemInterface_Setup_Call struct {
	*mock.Call
}

CemInterface_Setup_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Setup'

func (*CemInterface_Setup_Call) Return 

func (_c *CemInterface_Setup_Call) Return(_a0 error) *CemInterface_Setup_Call

func (*CemInterface_Setup_Call) Run 

func (_c *CemInterface_Setup_Call) Run(run func()) *CemInterface_Setup_Call

func (*CemInterface_Setup_Call) RunAndReturn 

func (_c *CemInterface_Setup_Call) RunAndReturn(run func() error) *CemInterface_Setup_Call

type CemInterface_Shutdown_Call 

type CemInterface_Shutdown_Call struct {
	*mock.Call
}

CemInterface_Shutdown_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Shutdown'

func (*CemInterface_Shutdown_Call) Return 

func (_c *CemInterface_Shutdown_Call) Return() *CemInterface_Shutdown_Call

func (*CemInterface_Shutdown_Call) Run 

func (_c *CemInterface_Shutdown_Call) Run(run func()) *CemInterface_Shutdown_Call

func (*CemInterface_Shutdown_Call) RunAndReturn 

func (_c *CemInterface_Shutdown_Call) RunAndReturn(run func()) *CemInterface_Shutdown_Call

type CemInterface_Start_Call 

type CemInterface_Start_Call struct {
	*mock.Call
}

CemInterface_Start_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Start'

func (*CemInterface_Start_Call) Return 

func (_c *CemInterface_Start_Call) Return() *CemInterface_Start_Call

func (*CemInterface_Start_Call) Run 

func (_c *CemInterface_Start_Call) Run(run func()) *CemInterface_Start_Call

func (*CemInterface_Start_Call) RunAndReturn 

func (_c *CemInterface_Start_Call) RunAndReturn(run func()) *CemInterface_Start_Call

type DeviceEventCallback 

type DeviceEventCallback struct {
	mock.Mock
}

DeviceEventCallback is an autogenerated mock type for the DeviceEventCallback type

func NewDeviceEventCallback 

func NewDeviceEventCallback(t interface {
	mock.TestingT
	Cleanup(func())
}) *DeviceEventCallback

NewDeviceEventCallback creates a new instance of DeviceEventCallback. 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 (*DeviceEventCallback) EXPECT 

func (_m *DeviceEventCallback) EXPECT() *DeviceEventCallback_Expecter

func (*DeviceEventCallback) Execute 

func (_m *DeviceEventCallback) Execute(ski string, device api.DeviceRemoteInterface, event cemdapi.EventType)

Execute provides a mock function with given fields: ski, device, event

type DeviceEventCallback_Execute_Call 

type DeviceEventCallback_Execute_Call struct {
	*mock.Call
}

DeviceEventCallback_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'

func (*DeviceEventCallback_Execute_Call) Return 

func (_c *DeviceEventCallback_Execute_Call) Return() *DeviceEventCallback_Execute_Call

func (*DeviceEventCallback_Execute_Call) Run 

func (_c *DeviceEventCallback_Execute_Call) Run(run func(ski string, device api.DeviceRemoteInterface, event cemdapi.EventType)) *DeviceEventCallback_Execute_Call

func (*DeviceEventCallback_Execute_Call) RunAndReturn 

func (_c *DeviceEventCallback_Execute_Call) RunAndReturn(run func(string, api.DeviceRemoteInterface, cemdapi.EventType)) *DeviceEventCallback_Execute_Call

type DeviceEventCallback_Expecter 

type DeviceEventCallback_Expecter struct {
	// contains filtered or unexported fields
}

func (*DeviceEventCallback_Expecter) Execute 

func (_e *DeviceEventCallback_Expecter) Execute(ski interface{}, device interface{}, event interface{}) *DeviceEventCallback_Execute_Call

Execute is a helper method to define mock.On call

  • ski string
  • device api.DeviceRemoteInterface
  • event cemdapi.EventType

type EntityEventCallback 

type EntityEventCallback struct {
	mock.Mock
}

EntityEventCallback is an autogenerated mock type for the EntityEventCallback type

func NewEntityEventCallback 

func NewEntityEventCallback(t interface {
	mock.TestingT
	Cleanup(func())
}) *EntityEventCallback

NewEntityEventCallback creates a new instance of EntityEventCallback. 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 (*EntityEventCallback) EXPECT 

func (_m *EntityEventCallback) EXPECT() *EntityEventCallback_Expecter

func (*EntityEventCallback) Execute 

func (_m *EntityEventCallback) Execute(ski string, device api.DeviceRemoteInterface, entity api.EntityRemoteInterface, event cemdapi.EventType)

Execute provides a mock function with given fields: ski, device, entity, event

type EntityEventCallback_Execute_Call 

type EntityEventCallback_Execute_Call struct {
	*mock.Call
}

EntityEventCallback_Execute_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Execute'

func (*EntityEventCallback_Execute_Call) Return 

func (_c *EntityEventCallback_Execute_Call) Return() *EntityEventCallback_Execute_Call

func (*EntityEventCallback_Execute_Call) Run 

func (_c *EntityEventCallback_Execute_Call) Run(run func(ski string, device api.DeviceRemoteInterface, entity api.EntityRemoteInterface, event cemdapi.EventType)) *EntityEventCallback_Execute_Call

func (*EntityEventCallback_Execute_Call) RunAndReturn 

func (_c *EntityEventCallback_Execute_Call) RunAndReturn(run func(string, api.DeviceRemoteInterface, api.EntityRemoteInterface, cemdapi.EventType)) *EntityEventCallback_Execute_Call

type EntityEventCallback_Expecter 

type EntityEventCallback_Expecter struct {
	// contains filtered or unexported fields
}

func (*EntityEventCallback_Expecter) Execute 

func (_e *EntityEventCallback_Expecter) Execute(ski interface{}, device interface{}, entity interface{}, event interface{}) *EntityEventCallback_Execute_Call

Execute is a helper method to define mock.On call

  • ski string
  • device api.DeviceRemoteInterface
  • entity api.EntityRemoteInterface
  • event cemdapi.EventType

type UCCEVCInterface 

type UCCEVCInterface struct {
	mock.Mock
}

UCCEVCInterface is an autogenerated mock type for the UCCEVCInterface type

func NewUCCEVCInterface 

func NewUCCEVCInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCCEVCInterface

NewUCCEVCInterface creates a new instance of UCCEVCInterface. 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 (*UCCEVCInterface) AddFeatures 

func (_m *UCCEVCInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCCEVCInterface) AddUseCase 

func (_m *UCCEVCInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCCEVCInterface) ChargePlan 

func (_m *UCCEVCInterface) ChargePlan(entity api.EntityRemoteInterface) (cemdapi.ChargePlan, error)

ChargePlan provides a mock function with given fields: entity

func (*UCCEVCInterface) ChargePlanConstraints 

func (_m *UCCEVCInterface) ChargePlanConstraints(entity api.EntityRemoteInterface) ([]cemdapi.DurationSlotValue, error)

ChargePlanConstraints provides a mock function with given fields: entity

func (*UCCEVCInterface) ChargeStrategy 

func (_m *UCCEVCInterface) ChargeStrategy(remoteEntity api.EntityRemoteInterface) cemdapi.EVChargeStrategyType

ChargeStrategy provides a mock function with given fields: remoteEntity

func (*UCCEVCInterface) EXPECT 

func (_m *UCCEVCInterface) EXPECT() *UCCEVCInterface_Expecter

func (*UCCEVCInterface) EnergyDemand 

func (_m *UCCEVCInterface) EnergyDemand(remoteEntity api.EntityRemoteInterface) (cemdapi.Demand, error)

EnergyDemand provides a mock function with given fields: remoteEntity

func (*UCCEVCInterface) IncentiveConstraints 

func (_m *UCCEVCInterface) IncentiveConstraints(entity api.EntityRemoteInterface) (cemdapi.IncentiveSlotConstraints, error)

IncentiveConstraints provides a mock function with given fields: entity

func (*UCCEVCInterface) IsUseCaseSupported 

func (_m *UCCEVCInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCCEVCInterface) TimeSlotConstraints 

func (_m *UCCEVCInterface) TimeSlotConstraints(entity api.EntityRemoteInterface) (cemdapi.TimeSlotConstraints, error)

TimeSlotConstraints provides a mock function with given fields: entity

func (*UCCEVCInterface) UpdateUseCaseAvailability 

func (_m *UCCEVCInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCCEVCInterface) UseCaseName 

func (_m *UCCEVCInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

func (*UCCEVCInterface) WriteIncentiveTableDescriptions 

func (_m *UCCEVCInterface) WriteIncentiveTableDescriptions(entity api.EntityRemoteInterface, data []cemdapi.IncentiveTariffDescription) error

WriteIncentiveTableDescriptions provides a mock function with given fields: entity, data

func (*UCCEVCInterface) WriteIncentives 

func (_m *UCCEVCInterface) WriteIncentives(entity api.EntityRemoteInterface, data []cemdapi.DurationSlotValue) error

WriteIncentives provides a mock function with given fields: entity, data

func (*UCCEVCInterface) WritePowerLimits 

func (_m *UCCEVCInterface) WritePowerLimits(entity api.EntityRemoteInterface, data []cemdapi.DurationSlotValue) error

WritePowerLimits provides a mock function with given fields: entity, data

type UCCEVCInterface_AddFeatures_Call 

type UCCEVCInterface_AddFeatures_Call struct {
	*mock.Call
}

UCCEVCInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCCEVCInterface_AddFeatures_Call) Return 

func (_c *UCCEVCInterface_AddFeatures_Call) Return() *UCCEVCInterface_AddFeatures_Call

func (*UCCEVCInterface_AddFeatures_Call) Run 

func (_c *UCCEVCInterface_AddFeatures_Call) Run(run func()) *UCCEVCInterface_AddFeatures_Call

func (*UCCEVCInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCCEVCInterface_AddFeatures_Call) RunAndReturn(run func()) *UCCEVCInterface_AddFeatures_Call

type UCCEVCInterface_AddUseCase_Call 

type UCCEVCInterface_AddUseCase_Call struct {
	*mock.Call
}

UCCEVCInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCCEVCInterface_AddUseCase_Call) Return 

func (_c *UCCEVCInterface_AddUseCase_Call) Return() *UCCEVCInterface_AddUseCase_Call

func (*UCCEVCInterface_AddUseCase_Call) Run 

func (_c *UCCEVCInterface_AddUseCase_Call) Run(run func()) *UCCEVCInterface_AddUseCase_Call

func (*UCCEVCInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCCEVCInterface_AddUseCase_Call) RunAndReturn(run func()) *UCCEVCInterface_AddUseCase_Call

type UCCEVCInterface_ChargePlanConstraints_Call 

type UCCEVCInterface_ChargePlanConstraints_Call struct {
	*mock.Call
}

UCCEVCInterface_ChargePlanConstraints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChargePlanConstraints'

func (*UCCEVCInterface_ChargePlanConstraints_Call) Return 

func (_c *UCCEVCInterface_ChargePlanConstraints_Call) Return(_a0 []cemdapi.DurationSlotValue, _a1 error) *UCCEVCInterface_ChargePlanConstraints_Call

func (*UCCEVCInterface_ChargePlanConstraints_Call) Run 

func (_c *UCCEVCInterface_ChargePlanConstraints_Call) Run(run func(entity api.EntityRemoteInterface)) *UCCEVCInterface_ChargePlanConstraints_Call

func (*UCCEVCInterface_ChargePlanConstraints_Call) RunAndReturn 

func (_c *UCCEVCInterface_ChargePlanConstraints_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]cemdapi.DurationSlotValue, error)) *UCCEVCInterface_ChargePlanConstraints_Call

type UCCEVCInterface_ChargePlan_Call 

type UCCEVCInterface_ChargePlan_Call struct {
	*mock.Call
}

UCCEVCInterface_ChargePlan_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChargePlan'

func (*UCCEVCInterface_ChargePlan_Call) Return 

func (_c *UCCEVCInterface_ChargePlan_Call) Return(_a0 cemdapi.ChargePlan, _a1 error) *UCCEVCInterface_ChargePlan_Call

func (*UCCEVCInterface_ChargePlan_Call) Run 

func (_c *UCCEVCInterface_ChargePlan_Call) Run(run func(entity api.EntityRemoteInterface)) *UCCEVCInterface_ChargePlan_Call

func (*UCCEVCInterface_ChargePlan_Call) RunAndReturn 

func (_c *UCCEVCInterface_ChargePlan_Call) RunAndReturn(run func(api.EntityRemoteInterface) (cemdapi.ChargePlan, error)) *UCCEVCInterface_ChargePlan_Call

type UCCEVCInterface_ChargeStrategy_Call 

type UCCEVCInterface_ChargeStrategy_Call struct {
	*mock.Call
}

UCCEVCInterface_ChargeStrategy_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChargeStrategy'

func (*UCCEVCInterface_ChargeStrategy_Call) Return 

func (_c *UCCEVCInterface_ChargeStrategy_Call) Return(_a0 cemdapi.EVChargeStrategyType) *UCCEVCInterface_ChargeStrategy_Call

func (*UCCEVCInterface_ChargeStrategy_Call) Run 

func (_c *UCCEVCInterface_ChargeStrategy_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCCEVCInterface_ChargeStrategy_Call

func (*UCCEVCInterface_ChargeStrategy_Call) RunAndReturn 

func (_c *UCCEVCInterface_ChargeStrategy_Call) RunAndReturn(run func(api.EntityRemoteInterface) cemdapi.EVChargeStrategyType) *UCCEVCInterface_ChargeStrategy_Call

type UCCEVCInterface_EnergyDemand_Call 

type UCCEVCInterface_EnergyDemand_Call struct {
	*mock.Call
}

UCCEVCInterface_EnergyDemand_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnergyDemand'

func (*UCCEVCInterface_EnergyDemand_Call) Return 

func (_c *UCCEVCInterface_EnergyDemand_Call) Return(_a0 cemdapi.Demand, _a1 error) *UCCEVCInterface_EnergyDemand_Call

func (*UCCEVCInterface_EnergyDemand_Call) Run 

func (_c *UCCEVCInterface_EnergyDemand_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCCEVCInterface_EnergyDemand_Call

func (*UCCEVCInterface_EnergyDemand_Call) RunAndReturn 

func (_c *UCCEVCInterface_EnergyDemand_Call) RunAndReturn(run func(api.EntityRemoteInterface) (cemdapi.Demand, error)) *UCCEVCInterface_EnergyDemand_Call

type UCCEVCInterface_Expecter 

type UCCEVCInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCCEVCInterface_Expecter) AddFeatures 

func (_e *UCCEVCInterface_Expecter) AddFeatures() *UCCEVCInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCCEVCInterface_Expecter) AddUseCase 

func (_e *UCCEVCInterface_Expecter) AddUseCase() *UCCEVCInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCCEVCInterface_Expecter) ChargePlan 

func (_e *UCCEVCInterface_Expecter) ChargePlan(entity interface{}) *UCCEVCInterface_ChargePlan_Call

ChargePlan is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCCEVCInterface_Expecter) ChargePlanConstraints 

func (_e *UCCEVCInterface_Expecter) ChargePlanConstraints(entity interface{}) *UCCEVCInterface_ChargePlanConstraints_Call

ChargePlanConstraints is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCCEVCInterface_Expecter) ChargeStrategy 

func (_e *UCCEVCInterface_Expecter) ChargeStrategy(remoteEntity interface{}) *UCCEVCInterface_ChargeStrategy_Call

ChargeStrategy is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCCEVCInterface_Expecter) EnergyDemand 

func (_e *UCCEVCInterface_Expecter) EnergyDemand(remoteEntity interface{}) *UCCEVCInterface_EnergyDemand_Call

EnergyDemand is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCCEVCInterface_Expecter) IncentiveConstraints 

func (_e *UCCEVCInterface_Expecter) IncentiveConstraints(entity interface{}) *UCCEVCInterface_IncentiveConstraints_Call

IncentiveConstraints is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCCEVCInterface_Expecter) IsUseCaseSupported 

func (_e *UCCEVCInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCCEVCInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCCEVCInterface_Expecter) TimeSlotConstraints 

func (_e *UCCEVCInterface_Expecter) TimeSlotConstraints(entity interface{}) *UCCEVCInterface_TimeSlotConstraints_Call

TimeSlotConstraints is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCCEVCInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCCEVCInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCCEVCInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCCEVCInterface_Expecter) UseCaseName 

func (_e *UCCEVCInterface_Expecter) UseCaseName() *UCCEVCInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

func (*UCCEVCInterface_Expecter) WriteIncentiveTableDescriptions 

func (_e *UCCEVCInterface_Expecter) WriteIncentiveTableDescriptions(entity interface{}, data interface{}) *UCCEVCInterface_WriteIncentiveTableDescriptions_Call

WriteIncentiveTableDescriptions is a helper method to define mock.On call

  • entity api.EntityRemoteInterface
  • data []cemdapi.IncentiveTariffDescription

func (*UCCEVCInterface_Expecter) WriteIncentives 

func (_e *UCCEVCInterface_Expecter) WriteIncentives(entity interface{}, data interface{}) *UCCEVCInterface_WriteIncentives_Call

WriteIncentives is a helper method to define mock.On call

  • entity api.EntityRemoteInterface
  • data []cemdapi.DurationSlotValue

func (*UCCEVCInterface_Expecter) WritePowerLimits 

func (_e *UCCEVCInterface_Expecter) WritePowerLimits(entity interface{}, data interface{}) *UCCEVCInterface_WritePowerLimits_Call

WritePowerLimits is a helper method to define mock.On call

  • entity api.EntityRemoteInterface
  • data []cemdapi.DurationSlotValue

type UCCEVCInterface_IncentiveConstraints_Call 

type UCCEVCInterface_IncentiveConstraints_Call struct {
	*mock.Call
}

UCCEVCInterface_IncentiveConstraints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IncentiveConstraints'

func (*UCCEVCInterface_IncentiveConstraints_Call) Return 

func (_c *UCCEVCInterface_IncentiveConstraints_Call) Return(_a0 cemdapi.IncentiveSlotConstraints, _a1 error) *UCCEVCInterface_IncentiveConstraints_Call

func (*UCCEVCInterface_IncentiveConstraints_Call) Run 

func (_c *UCCEVCInterface_IncentiveConstraints_Call) Run(run func(entity api.EntityRemoteInterface)) *UCCEVCInterface_IncentiveConstraints_Call

func (*UCCEVCInterface_IncentiveConstraints_Call) RunAndReturn 

func (_c *UCCEVCInterface_IncentiveConstraints_Call) RunAndReturn(run func(api.EntityRemoteInterface) (cemdapi.IncentiveSlotConstraints, error)) *UCCEVCInterface_IncentiveConstraints_Call

type UCCEVCInterface_IsUseCaseSupported_Call 

type UCCEVCInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCCEVCInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCCEVCInterface_IsUseCaseSupported_Call) Return 

func (_c *UCCEVCInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCCEVCInterface_IsUseCaseSupported_Call

func (*UCCEVCInterface_IsUseCaseSupported_Call) Run 

func (_c *UCCEVCInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCCEVCInterface_IsUseCaseSupported_Call

func (*UCCEVCInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCCEVCInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCCEVCInterface_IsUseCaseSupported_Call

type UCCEVCInterface_TimeSlotConstraints_Call 

type UCCEVCInterface_TimeSlotConstraints_Call struct {
	*mock.Call
}

UCCEVCInterface_TimeSlotConstraints_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'TimeSlotConstraints'

func (*UCCEVCInterface_TimeSlotConstraints_Call) Return 

func (_c *UCCEVCInterface_TimeSlotConstraints_Call) Return(_a0 cemdapi.TimeSlotConstraints, _a1 error) *UCCEVCInterface_TimeSlotConstraints_Call

func (*UCCEVCInterface_TimeSlotConstraints_Call) Run 

func (_c *UCCEVCInterface_TimeSlotConstraints_Call) Run(run func(entity api.EntityRemoteInterface)) *UCCEVCInterface_TimeSlotConstraints_Call

func (*UCCEVCInterface_TimeSlotConstraints_Call) RunAndReturn 

func (_c *UCCEVCInterface_TimeSlotConstraints_Call) RunAndReturn(run func(api.EntityRemoteInterface) (cemdapi.TimeSlotConstraints, error)) *UCCEVCInterface_TimeSlotConstraints_Call

type UCCEVCInterface_UpdateUseCaseAvailability_Call 

type UCCEVCInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCCEVCInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCCEVCInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCCEVCInterface_UpdateUseCaseAvailability_Call) Return() *UCCEVCInterface_UpdateUseCaseAvailability_Call

func (*UCCEVCInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCCEVCInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCCEVCInterface_UpdateUseCaseAvailability_Call

func (*UCCEVCInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCCEVCInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCCEVCInterface_UpdateUseCaseAvailability_Call

type UCCEVCInterface_UseCaseName_Call 

type UCCEVCInterface_UseCaseName_Call struct {
	*mock.Call
}

UCCEVCInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCCEVCInterface_UseCaseName_Call) Return 

func (_c *UCCEVCInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCCEVCInterface_UseCaseName_Call

func (*UCCEVCInterface_UseCaseName_Call) Run 

func (_c *UCCEVCInterface_UseCaseName_Call) Run(run func()) *UCCEVCInterface_UseCaseName_Call

func (*UCCEVCInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCCEVCInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCCEVCInterface_UseCaseName_Call

type UCCEVCInterface_WriteIncentiveTableDescriptions_Call 

type UCCEVCInterface_WriteIncentiveTableDescriptions_Call struct {
	*mock.Call
}

UCCEVCInterface_WriteIncentiveTableDescriptions_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteIncentiveTableDescriptions'

func (*UCCEVCInterface_WriteIncentiveTableDescriptions_Call) Return 

func (_c *UCCEVCInterface_WriteIncentiveTableDescriptions_Call) Return(_a0 error) *UCCEVCInterface_WriteIncentiveTableDescriptions_Call

func (*UCCEVCInterface_WriteIncentiveTableDescriptions_Call) Run 

func (_c *UCCEVCInterface_WriteIncentiveTableDescriptions_Call) Run(run func(entity api.EntityRemoteInterface, data []cemdapi.IncentiveTariffDescription)) *UCCEVCInterface_WriteIncentiveTableDescriptions_Call

func (*UCCEVCInterface_WriteIncentiveTableDescriptions_Call) RunAndReturn 

func (_c *UCCEVCInterface_WriteIncentiveTableDescriptions_Call) RunAndReturn(run func(api.EntityRemoteInterface, []cemdapi.IncentiveTariffDescription) error) *UCCEVCInterface_WriteIncentiveTableDescriptions_Call

type UCCEVCInterface_WriteIncentives_Call 

type UCCEVCInterface_WriteIncentives_Call struct {
	*mock.Call
}

UCCEVCInterface_WriteIncentives_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteIncentives'

func (*UCCEVCInterface_WriteIncentives_Call) Return 

func (_c *UCCEVCInterface_WriteIncentives_Call) Return(_a0 error) *UCCEVCInterface_WriteIncentives_Call

func (*UCCEVCInterface_WriteIncentives_Call) Run 

func (_c *UCCEVCInterface_WriteIncentives_Call) Run(run func(entity api.EntityRemoteInterface, data []cemdapi.DurationSlotValue)) *UCCEVCInterface_WriteIncentives_Call

func (*UCCEVCInterface_WriteIncentives_Call) RunAndReturn 

func (_c *UCCEVCInterface_WriteIncentives_Call) RunAndReturn(run func(api.EntityRemoteInterface, []cemdapi.DurationSlotValue) error) *UCCEVCInterface_WriteIncentives_Call

type UCCEVCInterface_WritePowerLimits_Call 

type UCCEVCInterface_WritePowerLimits_Call struct {
	*mock.Call
}

UCCEVCInterface_WritePowerLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WritePowerLimits'

func (*UCCEVCInterface_WritePowerLimits_Call) Return 

func (_c *UCCEVCInterface_WritePowerLimits_Call) Return(_a0 error) *UCCEVCInterface_WritePowerLimits_Call

func (*UCCEVCInterface_WritePowerLimits_Call) Run 

func (_c *UCCEVCInterface_WritePowerLimits_Call) Run(run func(entity api.EntityRemoteInterface, data []cemdapi.DurationSlotValue)) *UCCEVCInterface_WritePowerLimits_Call

func (*UCCEVCInterface_WritePowerLimits_Call) RunAndReturn 

func (_c *UCCEVCInterface_WritePowerLimits_Call) RunAndReturn(run func(api.EntityRemoteInterface, []cemdapi.DurationSlotValue) error) *UCCEVCInterface_WritePowerLimits_Call

type UCEVCCInterface 

type UCEVCCInterface struct {
	mock.Mock
}

UCEVCCInterface is an autogenerated mock type for the UCEVCCInterface type

func NewUCEVCCInterface 

func NewUCEVCCInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCEVCCInterface

NewUCEVCCInterface creates a new instance of UCEVCCInterface. 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 (*UCEVCCInterface) AddFeatures 

func (_m *UCEVCCInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCEVCCInterface) AddUseCase 

func (_m *UCEVCCInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCEVCCInterface) AsymmetricChargingSupport 

func (_m *UCEVCCInterface) AsymmetricChargingSupport(entity api.EntityRemoteInterface) (bool, error)

AsymmetricChargingSupport provides a mock function with given fields: entity

func (*UCEVCCInterface) ChargeState 

func (_m *UCEVCCInterface) ChargeState(entity api.EntityRemoteInterface) (cemdapi.EVChargeStateType, error)

ChargeState provides a mock function with given fields: entity

func (*UCEVCCInterface) ChargingPowerLimits 

func (_m *UCEVCCInterface) ChargingPowerLimits(entity api.EntityRemoteInterface) (float64, float64, float64, error)

ChargingPowerLimits provides a mock function with given fields: entity

func (*UCEVCCInterface) CommunicationStandard 

func (_m *UCEVCCInterface) CommunicationStandard(entity api.EntityRemoteInterface) (model.DeviceConfigurationKeyValueStringType, error)

CommunicationStandard provides a mock function with given fields: entity

func (*UCEVCCInterface) EVConnected 

func (_m *UCEVCCInterface) EVConnected(entity api.EntityRemoteInterface) bool

EVConnected provides a mock function with given fields: entity

func (*UCEVCCInterface) EXPECT 

func (_m *UCEVCCInterface) EXPECT() *UCEVCCInterface_Expecter

func (*UCEVCCInterface) Identifications 

func (_m *UCEVCCInterface) Identifications(entity api.EntityRemoteInterface) ([]cemdapi.IdentificationItem, error)

Identifications provides a mock function with given fields: entity

func (*UCEVCCInterface) IsInSleepMode 

func (_m *UCEVCCInterface) IsInSleepMode(entity api.EntityRemoteInterface) (bool, error)

IsInSleepMode provides a mock function with given fields: entity

func (*UCEVCCInterface) IsUseCaseSupported 

func (_m *UCEVCCInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCEVCCInterface) ManufacturerData 

func (_m *UCEVCCInterface) ManufacturerData(entity api.EntityRemoteInterface) (cemdapi.ManufacturerData, error)

ManufacturerData provides a mock function with given fields: entity

func (*UCEVCCInterface) UpdateUseCaseAvailability 

func (_m *UCEVCCInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCEVCCInterface) UseCaseName 

func (_m *UCEVCCInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

type UCEVCCInterface_AddFeatures_Call 

type UCEVCCInterface_AddFeatures_Call struct {
	*mock.Call
}

UCEVCCInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCEVCCInterface_AddFeatures_Call) Return 

func (_c *UCEVCCInterface_AddFeatures_Call) Return() *UCEVCCInterface_AddFeatures_Call

func (*UCEVCCInterface_AddFeatures_Call) Run 

func (_c *UCEVCCInterface_AddFeatures_Call) Run(run func()) *UCEVCCInterface_AddFeatures_Call

func (*UCEVCCInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCEVCCInterface_AddFeatures_Call) RunAndReturn(run func()) *UCEVCCInterface_AddFeatures_Call

type UCEVCCInterface_AddUseCase_Call 

type UCEVCCInterface_AddUseCase_Call struct {
	*mock.Call
}

UCEVCCInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCEVCCInterface_AddUseCase_Call) Return 

func (_c *UCEVCCInterface_AddUseCase_Call) Return() *UCEVCCInterface_AddUseCase_Call

func (*UCEVCCInterface_AddUseCase_Call) Run 

func (_c *UCEVCCInterface_AddUseCase_Call) Run(run func()) *UCEVCCInterface_AddUseCase_Call

func (*UCEVCCInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCEVCCInterface_AddUseCase_Call) RunAndReturn(run func()) *UCEVCCInterface_AddUseCase_Call

type UCEVCCInterface_AsymmetricChargingSupport_Call 

type UCEVCCInterface_AsymmetricChargingSupport_Call struct {
	*mock.Call
}

UCEVCCInterface_AsymmetricChargingSupport_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AsymmetricChargingSupport'

func (*UCEVCCInterface_AsymmetricChargingSupport_Call) Return 

func (_c *UCEVCCInterface_AsymmetricChargingSupport_Call) Return(_a0 bool, _a1 error) *UCEVCCInterface_AsymmetricChargingSupport_Call

func (*UCEVCCInterface_AsymmetricChargingSupport_Call) Run 

func (_c *UCEVCCInterface_AsymmetricChargingSupport_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVCCInterface_AsymmetricChargingSupport_Call

func (*UCEVCCInterface_AsymmetricChargingSupport_Call) RunAndReturn 

func (_c *UCEVCCInterface_AsymmetricChargingSupport_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCEVCCInterface_AsymmetricChargingSupport_Call

type UCEVCCInterface_ChargeState_Call 

type UCEVCCInterface_ChargeState_Call struct {
	*mock.Call
}

UCEVCCInterface_ChargeState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChargeState'

func (*UCEVCCInterface_ChargeState_Call) Return 

func (_c *UCEVCCInterface_ChargeState_Call) Return(_a0 cemdapi.EVChargeStateType, _a1 error) *UCEVCCInterface_ChargeState_Call

func (*UCEVCCInterface_ChargeState_Call) Run 

func (_c *UCEVCCInterface_ChargeState_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVCCInterface_ChargeState_Call

func (*UCEVCCInterface_ChargeState_Call) RunAndReturn 

func (_c *UCEVCCInterface_ChargeState_Call) RunAndReturn(run func(api.EntityRemoteInterface) (cemdapi.EVChargeStateType, error)) *UCEVCCInterface_ChargeState_Call

type UCEVCCInterface_ChargingPowerLimits_Call 

type UCEVCCInterface_ChargingPowerLimits_Call struct {
	*mock.Call
}

UCEVCCInterface_ChargingPowerLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ChargingPowerLimits'

func (*UCEVCCInterface_ChargingPowerLimits_Call) Return 

func (_c *UCEVCCInterface_ChargingPowerLimits_Call) Return(_a0 float64, _a1 float64, _a2 float64, _a3 error) *UCEVCCInterface_ChargingPowerLimits_Call

func (*UCEVCCInterface_ChargingPowerLimits_Call) Run 

func (_c *UCEVCCInterface_ChargingPowerLimits_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVCCInterface_ChargingPowerLimits_Call

func (*UCEVCCInterface_ChargingPowerLimits_Call) RunAndReturn 

func (_c *UCEVCCInterface_ChargingPowerLimits_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, float64, float64, error)) *UCEVCCInterface_ChargingPowerLimits_Call

type UCEVCCInterface_CommunicationStandard_Call 

type UCEVCCInterface_CommunicationStandard_Call struct {
	*mock.Call
}

UCEVCCInterface_CommunicationStandard_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CommunicationStandard'

func (*UCEVCCInterface_CommunicationStandard_Call) Return 

func (_c *UCEVCCInterface_CommunicationStandard_Call) Return(_a0 model.DeviceConfigurationKeyValueStringType, _a1 error) *UCEVCCInterface_CommunicationStandard_Call

func (*UCEVCCInterface_CommunicationStandard_Call) Run 

func (_c *UCEVCCInterface_CommunicationStandard_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVCCInterface_CommunicationStandard_Call

func (*UCEVCCInterface_CommunicationStandard_Call) RunAndReturn 

func (_c *UCEVCCInterface_CommunicationStandard_Call) RunAndReturn(run func(api.EntityRemoteInterface) (model.DeviceConfigurationKeyValueStringType, error)) *UCEVCCInterface_CommunicationStandard_Call

type UCEVCCInterface_EVConnected_Call 

type UCEVCCInterface_EVConnected_Call struct {
	*mock.Call
}

UCEVCCInterface_EVConnected_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EVConnected'

func (*UCEVCCInterface_EVConnected_Call) Return 

func (_c *UCEVCCInterface_EVConnected_Call) Return(_a0 bool) *UCEVCCInterface_EVConnected_Call

func (*UCEVCCInterface_EVConnected_Call) Run 

func (_c *UCEVCCInterface_EVConnected_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVCCInterface_EVConnected_Call

func (*UCEVCCInterface_EVConnected_Call) RunAndReturn 

func (_c *UCEVCCInterface_EVConnected_Call) RunAndReturn(run func(api.EntityRemoteInterface) bool) *UCEVCCInterface_EVConnected_Call

type UCEVCCInterface_Expecter 

type UCEVCCInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCEVCCInterface_Expecter) AddFeatures 

func (_e *UCEVCCInterface_Expecter) AddFeatures() *UCEVCCInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCEVCCInterface_Expecter) AddUseCase 

func (_e *UCEVCCInterface_Expecter) AddUseCase() *UCEVCCInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCEVCCInterface_Expecter) AsymmetricChargingSupport 

func (_e *UCEVCCInterface_Expecter) AsymmetricChargingSupport(entity interface{}) *UCEVCCInterface_AsymmetricChargingSupport_Call

AsymmetricChargingSupport is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVCCInterface_Expecter) ChargeState 

func (_e *UCEVCCInterface_Expecter) ChargeState(entity interface{}) *UCEVCCInterface_ChargeState_Call

ChargeState is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVCCInterface_Expecter) ChargingPowerLimits 

func (_e *UCEVCCInterface_Expecter) ChargingPowerLimits(entity interface{}) *UCEVCCInterface_ChargingPowerLimits_Call

ChargingPowerLimits is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVCCInterface_Expecter) CommunicationStandard 

func (_e *UCEVCCInterface_Expecter) CommunicationStandard(entity interface{}) *UCEVCCInterface_CommunicationStandard_Call

CommunicationStandard is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVCCInterface_Expecter) EVConnected 

func (_e *UCEVCCInterface_Expecter) EVConnected(entity interface{}) *UCEVCCInterface_EVConnected_Call

EVConnected is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVCCInterface_Expecter) Identifications 

func (_e *UCEVCCInterface_Expecter) Identifications(entity interface{}) *UCEVCCInterface_Identifications_Call

Identifications is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVCCInterface_Expecter) IsInSleepMode 

func (_e *UCEVCCInterface_Expecter) IsInSleepMode(entity interface{}) *UCEVCCInterface_IsInSleepMode_Call

IsInSleepMode is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVCCInterface_Expecter) IsUseCaseSupported 

func (_e *UCEVCCInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCEVCCInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCEVCCInterface_Expecter) ManufacturerData 

func (_e *UCEVCCInterface_Expecter) ManufacturerData(entity interface{}) *UCEVCCInterface_ManufacturerData_Call

ManufacturerData is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVCCInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCEVCCInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCEVCCInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCEVCCInterface_Expecter) UseCaseName 

func (_e *UCEVCCInterface_Expecter) UseCaseName() *UCEVCCInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

type UCEVCCInterface_Identifications_Call 

type UCEVCCInterface_Identifications_Call struct {
	*mock.Call
}

UCEVCCInterface_Identifications_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Identifications'

func (*UCEVCCInterface_Identifications_Call) Return 

func (_c *UCEVCCInterface_Identifications_Call) Return(_a0 []cemdapi.IdentificationItem, _a1 error) *UCEVCCInterface_Identifications_Call

func (*UCEVCCInterface_Identifications_Call) Run 

func (_c *UCEVCCInterface_Identifications_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVCCInterface_Identifications_Call

func (*UCEVCCInterface_Identifications_Call) RunAndReturn 

func (_c *UCEVCCInterface_Identifications_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]cemdapi.IdentificationItem, error)) *UCEVCCInterface_Identifications_Call

type UCEVCCInterface_IsInSleepMode_Call 

type UCEVCCInterface_IsInSleepMode_Call struct {
	*mock.Call
}

UCEVCCInterface_IsInSleepMode_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsInSleepMode'

func (*UCEVCCInterface_IsInSleepMode_Call) Return 

func (_c *UCEVCCInterface_IsInSleepMode_Call) Return(_a0 bool, _a1 error) *UCEVCCInterface_IsInSleepMode_Call

func (*UCEVCCInterface_IsInSleepMode_Call) Run 

func (_c *UCEVCCInterface_IsInSleepMode_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVCCInterface_IsInSleepMode_Call

func (*UCEVCCInterface_IsInSleepMode_Call) RunAndReturn 

func (_c *UCEVCCInterface_IsInSleepMode_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCEVCCInterface_IsInSleepMode_Call

type UCEVCCInterface_IsUseCaseSupported_Call 

type UCEVCCInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCEVCCInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCEVCCInterface_IsUseCaseSupported_Call) Return 

func (_c *UCEVCCInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCEVCCInterface_IsUseCaseSupported_Call

func (*UCEVCCInterface_IsUseCaseSupported_Call) Run 

func (_c *UCEVCCInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCEVCCInterface_IsUseCaseSupported_Call

func (*UCEVCCInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCEVCCInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCEVCCInterface_IsUseCaseSupported_Call

type UCEVCCInterface_ManufacturerData_Call 

type UCEVCCInterface_ManufacturerData_Call struct {
	*mock.Call
}

UCEVCCInterface_ManufacturerData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManufacturerData'

func (*UCEVCCInterface_ManufacturerData_Call) Return 

func (_c *UCEVCCInterface_ManufacturerData_Call) Return(_a0 cemdapi.ManufacturerData, _a1 error) *UCEVCCInterface_ManufacturerData_Call

func (*UCEVCCInterface_ManufacturerData_Call) Run 

func (_c *UCEVCCInterface_ManufacturerData_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVCCInterface_ManufacturerData_Call

func (*UCEVCCInterface_ManufacturerData_Call) RunAndReturn 

func (_c *UCEVCCInterface_ManufacturerData_Call) RunAndReturn(run func(api.EntityRemoteInterface) (cemdapi.ManufacturerData, error)) *UCEVCCInterface_ManufacturerData_Call

type UCEVCCInterface_UpdateUseCaseAvailability_Call 

type UCEVCCInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCEVCCInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCEVCCInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCEVCCInterface_UpdateUseCaseAvailability_Call) Return() *UCEVCCInterface_UpdateUseCaseAvailability_Call

func (*UCEVCCInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCEVCCInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCEVCCInterface_UpdateUseCaseAvailability_Call

func (*UCEVCCInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCEVCCInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCEVCCInterface_UpdateUseCaseAvailability_Call

type UCEVCCInterface_UseCaseName_Call 

type UCEVCCInterface_UseCaseName_Call struct {
	*mock.Call
}

UCEVCCInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCEVCCInterface_UseCaseName_Call) Return 

func (_c *UCEVCCInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCEVCCInterface_UseCaseName_Call

func (*UCEVCCInterface_UseCaseName_Call) Run 

func (_c *UCEVCCInterface_UseCaseName_Call) Run(run func()) *UCEVCCInterface_UseCaseName_Call

func (*UCEVCCInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCEVCCInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCEVCCInterface_UseCaseName_Call

type UCEVCEMInterface 

type UCEVCEMInterface struct {
	mock.Mock
}

UCEVCEMInterface is an autogenerated mock type for the UCEVCEMInterface type

func NewUCEVCEMInterface 

func NewUCEVCEMInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCEVCEMInterface

NewUCEVCEMInterface creates a new instance of UCEVCEMInterface. 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 (*UCEVCEMInterface) AddFeatures 

func (_m *UCEVCEMInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCEVCEMInterface) AddUseCase 

func (_m *UCEVCEMInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCEVCEMInterface) CurrentPerPhase 

func (_m *UCEVCEMInterface) CurrentPerPhase(entity api.EntityRemoteInterface) ([]float64, error)

CurrentPerPhase provides a mock function with given fields: entity

func (*UCEVCEMInterface) EXPECT 

func (_m *UCEVCEMInterface) EXPECT() *UCEVCEMInterface_Expecter

func (*UCEVCEMInterface) EnergyCharged 

func (_m *UCEVCEMInterface) EnergyCharged(entity api.EntityRemoteInterface) (float64, error)

EnergyCharged provides a mock function with given fields: entity

func (*UCEVCEMInterface) IsUseCaseSupported 

func (_m *UCEVCEMInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCEVCEMInterface) PhasesConnected 

func (_m *UCEVCEMInterface) PhasesConnected(entity api.EntityRemoteInterface) (uint, error)

PhasesConnected provides a mock function with given fields: entity

func (*UCEVCEMInterface) PowerPerPhase 

func (_m *UCEVCEMInterface) PowerPerPhase(entity api.EntityRemoteInterface) ([]float64, error)

PowerPerPhase provides a mock function with given fields: entity

func (*UCEVCEMInterface) UpdateUseCaseAvailability 

func (_m *UCEVCEMInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCEVCEMInterface) UseCaseName 

func (_m *UCEVCEMInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

type UCEVCEMInterface_AddFeatures_Call 

type UCEVCEMInterface_AddFeatures_Call struct {
	*mock.Call
}

UCEVCEMInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCEVCEMInterface_AddFeatures_Call) Return 

func (_c *UCEVCEMInterface_AddFeatures_Call) Return() *UCEVCEMInterface_AddFeatures_Call

func (*UCEVCEMInterface_AddFeatures_Call) Run 

func (_c *UCEVCEMInterface_AddFeatures_Call) Run(run func()) *UCEVCEMInterface_AddFeatures_Call

func (*UCEVCEMInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCEVCEMInterface_AddFeatures_Call) RunAndReturn(run func()) *UCEVCEMInterface_AddFeatures_Call

type UCEVCEMInterface_AddUseCase_Call 

type UCEVCEMInterface_AddUseCase_Call struct {
	*mock.Call
}

UCEVCEMInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCEVCEMInterface_AddUseCase_Call) Return 

func (_c *UCEVCEMInterface_AddUseCase_Call) Return() *UCEVCEMInterface_AddUseCase_Call

func (*UCEVCEMInterface_AddUseCase_Call) Run 

func (_c *UCEVCEMInterface_AddUseCase_Call) Run(run func()) *UCEVCEMInterface_AddUseCase_Call

func (*UCEVCEMInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCEVCEMInterface_AddUseCase_Call) RunAndReturn(run func()) *UCEVCEMInterface_AddUseCase_Call

type UCEVCEMInterface_CurrentPerPhase_Call 

type UCEVCEMInterface_CurrentPerPhase_Call struct {
	*mock.Call
}

UCEVCEMInterface_CurrentPerPhase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurrentPerPhase'

func (*UCEVCEMInterface_CurrentPerPhase_Call) Return 

func (_c *UCEVCEMInterface_CurrentPerPhase_Call) Return(_a0 []float64, _a1 error) *UCEVCEMInterface_CurrentPerPhase_Call

func (*UCEVCEMInterface_CurrentPerPhase_Call) Run 

func (_c *UCEVCEMInterface_CurrentPerPhase_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVCEMInterface_CurrentPerPhase_Call

func (*UCEVCEMInterface_CurrentPerPhase_Call) RunAndReturn 

func (_c *UCEVCEMInterface_CurrentPerPhase_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]float64, error)) *UCEVCEMInterface_CurrentPerPhase_Call

type UCEVCEMInterface_EnergyCharged_Call 

type UCEVCEMInterface_EnergyCharged_Call struct {
	*mock.Call
}

UCEVCEMInterface_EnergyCharged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnergyCharged'

func (*UCEVCEMInterface_EnergyCharged_Call) Return 

func (_c *UCEVCEMInterface_EnergyCharged_Call) Return(_a0 float64, _a1 error) *UCEVCEMInterface_EnergyCharged_Call

func (*UCEVCEMInterface_EnergyCharged_Call) Run 

func (_c *UCEVCEMInterface_EnergyCharged_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVCEMInterface_EnergyCharged_Call

func (*UCEVCEMInterface_EnergyCharged_Call) RunAndReturn 

func (_c *UCEVCEMInterface_EnergyCharged_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCEVCEMInterface_EnergyCharged_Call

type UCEVCEMInterface_Expecter 

type UCEVCEMInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCEVCEMInterface_Expecter) AddFeatures 

func (_e *UCEVCEMInterface_Expecter) AddFeatures() *UCEVCEMInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCEVCEMInterface_Expecter) AddUseCase 

func (_e *UCEVCEMInterface_Expecter) AddUseCase() *UCEVCEMInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCEVCEMInterface_Expecter) CurrentPerPhase 

func (_e *UCEVCEMInterface_Expecter) CurrentPerPhase(entity interface{}) *UCEVCEMInterface_CurrentPerPhase_Call

CurrentPerPhase is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVCEMInterface_Expecter) EnergyCharged 

func (_e *UCEVCEMInterface_Expecter) EnergyCharged(entity interface{}) *UCEVCEMInterface_EnergyCharged_Call

EnergyCharged is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVCEMInterface_Expecter) IsUseCaseSupported 

func (_e *UCEVCEMInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCEVCEMInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCEVCEMInterface_Expecter) PhasesConnected 

func (_e *UCEVCEMInterface_Expecter) PhasesConnected(entity interface{}) *UCEVCEMInterface_PhasesConnected_Call

PhasesConnected is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVCEMInterface_Expecter) PowerPerPhase 

func (_e *UCEVCEMInterface_Expecter) PowerPerPhase(entity interface{}) *UCEVCEMInterface_PowerPerPhase_Call

PowerPerPhase is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVCEMInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCEVCEMInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCEVCEMInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCEVCEMInterface_Expecter) UseCaseName 

func (_e *UCEVCEMInterface_Expecter) UseCaseName() *UCEVCEMInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

type UCEVCEMInterface_IsUseCaseSupported_Call 

type UCEVCEMInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCEVCEMInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCEVCEMInterface_IsUseCaseSupported_Call) Return 

func (_c *UCEVCEMInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCEVCEMInterface_IsUseCaseSupported_Call

func (*UCEVCEMInterface_IsUseCaseSupported_Call) Run 

func (_c *UCEVCEMInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCEVCEMInterface_IsUseCaseSupported_Call

func (*UCEVCEMInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCEVCEMInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCEVCEMInterface_IsUseCaseSupported_Call

type UCEVCEMInterface_PhasesConnected_Call 

type UCEVCEMInterface_PhasesConnected_Call struct {
	*mock.Call
}

UCEVCEMInterface_PhasesConnected_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PhasesConnected'

func (*UCEVCEMInterface_PhasesConnected_Call) Return 

func (_c *UCEVCEMInterface_PhasesConnected_Call) Return(_a0 uint, _a1 error) *UCEVCEMInterface_PhasesConnected_Call

func (*UCEVCEMInterface_PhasesConnected_Call) Run 

func (_c *UCEVCEMInterface_PhasesConnected_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVCEMInterface_PhasesConnected_Call

func (*UCEVCEMInterface_PhasesConnected_Call) RunAndReturn 

func (_c *UCEVCEMInterface_PhasesConnected_Call) RunAndReturn(run func(api.EntityRemoteInterface) (uint, error)) *UCEVCEMInterface_PhasesConnected_Call

type UCEVCEMInterface_PowerPerPhase_Call 

type UCEVCEMInterface_PowerPerPhase_Call struct {
	*mock.Call
}

UCEVCEMInterface_PowerPerPhase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PowerPerPhase'

func (*UCEVCEMInterface_PowerPerPhase_Call) Return 

func (_c *UCEVCEMInterface_PowerPerPhase_Call) Return(_a0 []float64, _a1 error) *UCEVCEMInterface_PowerPerPhase_Call

func (*UCEVCEMInterface_PowerPerPhase_Call) Run 

func (_c *UCEVCEMInterface_PowerPerPhase_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVCEMInterface_PowerPerPhase_Call

func (*UCEVCEMInterface_PowerPerPhase_Call) RunAndReturn 

func (_c *UCEVCEMInterface_PowerPerPhase_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]float64, error)) *UCEVCEMInterface_PowerPerPhase_Call

type UCEVCEMInterface_UpdateUseCaseAvailability_Call 

type UCEVCEMInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCEVCEMInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCEVCEMInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCEVCEMInterface_UpdateUseCaseAvailability_Call) Return() *UCEVCEMInterface_UpdateUseCaseAvailability_Call

func (*UCEVCEMInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCEVCEMInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCEVCEMInterface_UpdateUseCaseAvailability_Call

func (*UCEVCEMInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCEVCEMInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCEVCEMInterface_UpdateUseCaseAvailability_Call

type UCEVCEMInterface_UseCaseName_Call 

type UCEVCEMInterface_UseCaseName_Call struct {
	*mock.Call
}

UCEVCEMInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCEVCEMInterface_UseCaseName_Call) Return 

func (_c *UCEVCEMInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCEVCEMInterface_UseCaseName_Call

func (*UCEVCEMInterface_UseCaseName_Call) Run 

func (_c *UCEVCEMInterface_UseCaseName_Call) Run(run func()) *UCEVCEMInterface_UseCaseName_Call

func (*UCEVCEMInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCEVCEMInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCEVCEMInterface_UseCaseName_Call

type UCEVSECCInterface 

type UCEVSECCInterface struct {
	mock.Mock
}

UCEVSECCInterface is an autogenerated mock type for the UCEVSECCInterface type

func NewUCEVSECCInterface 

func NewUCEVSECCInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCEVSECCInterface

NewUCEVSECCInterface creates a new instance of UCEVSECCInterface. 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 (*UCEVSECCInterface) AddFeatures 

func (_m *UCEVSECCInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCEVSECCInterface) AddUseCase 

func (_m *UCEVSECCInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCEVSECCInterface) EXPECT 

func (_m *UCEVSECCInterface) EXPECT() *UCEVSECCInterface_Expecter

func (*UCEVSECCInterface) IsUseCaseSupported 

func (_m *UCEVSECCInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCEVSECCInterface) ManufacturerData 

func (_m *UCEVSECCInterface) ManufacturerData(entity api.EntityRemoteInterface) (cemdapi.ManufacturerData, error)

ManufacturerData provides a mock function with given fields: entity

func (*UCEVSECCInterface) OperatingState 

func (_m *UCEVSECCInterface) OperatingState(entity api.EntityRemoteInterface) (model.DeviceDiagnosisOperatingStateType, string, error)

OperatingState provides a mock function with given fields: entity

func (*UCEVSECCInterface) UpdateUseCaseAvailability 

func (_m *UCEVSECCInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCEVSECCInterface) UseCaseName 

func (_m *UCEVSECCInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

type UCEVSECCInterface_AddFeatures_Call 

type UCEVSECCInterface_AddFeatures_Call struct {
	*mock.Call
}

UCEVSECCInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCEVSECCInterface_AddFeatures_Call) Return 

func (_c *UCEVSECCInterface_AddFeatures_Call) Return() *UCEVSECCInterface_AddFeatures_Call

func (*UCEVSECCInterface_AddFeatures_Call) Run 

func (_c *UCEVSECCInterface_AddFeatures_Call) Run(run func()) *UCEVSECCInterface_AddFeatures_Call

func (*UCEVSECCInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCEVSECCInterface_AddFeatures_Call) RunAndReturn(run func()) *UCEVSECCInterface_AddFeatures_Call

type UCEVSECCInterface_AddUseCase_Call 

type UCEVSECCInterface_AddUseCase_Call struct {
	*mock.Call
}

UCEVSECCInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCEVSECCInterface_AddUseCase_Call) Return 

func (_c *UCEVSECCInterface_AddUseCase_Call) Return() *UCEVSECCInterface_AddUseCase_Call

func (*UCEVSECCInterface_AddUseCase_Call) Run 

func (_c *UCEVSECCInterface_AddUseCase_Call) Run(run func()) *UCEVSECCInterface_AddUseCase_Call

func (*UCEVSECCInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCEVSECCInterface_AddUseCase_Call) RunAndReturn(run func()) *UCEVSECCInterface_AddUseCase_Call

type UCEVSECCInterface_Expecter 

type UCEVSECCInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCEVSECCInterface_Expecter) AddFeatures 

func (_e *UCEVSECCInterface_Expecter) AddFeatures() *UCEVSECCInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCEVSECCInterface_Expecter) AddUseCase 

func (_e *UCEVSECCInterface_Expecter) AddUseCase() *UCEVSECCInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCEVSECCInterface_Expecter) IsUseCaseSupported 

func (_e *UCEVSECCInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCEVSECCInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCEVSECCInterface_Expecter) ManufacturerData 

func (_e *UCEVSECCInterface_Expecter) ManufacturerData(entity interface{}) *UCEVSECCInterface_ManufacturerData_Call

ManufacturerData is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVSECCInterface_Expecter) OperatingState 

func (_e *UCEVSECCInterface_Expecter) OperatingState(entity interface{}) *UCEVSECCInterface_OperatingState_Call

OperatingState is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVSECCInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCEVSECCInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCEVSECCInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCEVSECCInterface_Expecter) UseCaseName 

func (_e *UCEVSECCInterface_Expecter) UseCaseName() *UCEVSECCInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

type UCEVSECCInterface_IsUseCaseSupported_Call 

type UCEVSECCInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCEVSECCInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCEVSECCInterface_IsUseCaseSupported_Call) Return 

func (_c *UCEVSECCInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCEVSECCInterface_IsUseCaseSupported_Call

func (*UCEVSECCInterface_IsUseCaseSupported_Call) Run 

func (_c *UCEVSECCInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCEVSECCInterface_IsUseCaseSupported_Call

func (*UCEVSECCInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCEVSECCInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCEVSECCInterface_IsUseCaseSupported_Call

type UCEVSECCInterface_ManufacturerData_Call 

type UCEVSECCInterface_ManufacturerData_Call struct {
	*mock.Call
}

UCEVSECCInterface_ManufacturerData_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ManufacturerData'

func (*UCEVSECCInterface_ManufacturerData_Call) Return 

func (_c *UCEVSECCInterface_ManufacturerData_Call) Return(_a0 cemdapi.ManufacturerData, _a1 error) *UCEVSECCInterface_ManufacturerData_Call

func (*UCEVSECCInterface_ManufacturerData_Call) Run 

func (_c *UCEVSECCInterface_ManufacturerData_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVSECCInterface_ManufacturerData_Call

func (*UCEVSECCInterface_ManufacturerData_Call) RunAndReturn 

func (_c *UCEVSECCInterface_ManufacturerData_Call) RunAndReturn(run func(api.EntityRemoteInterface) (cemdapi.ManufacturerData, error)) *UCEVSECCInterface_ManufacturerData_Call

type UCEVSECCInterface_OperatingState_Call 

type UCEVSECCInterface_OperatingState_Call struct {
	*mock.Call
}

UCEVSECCInterface_OperatingState_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'OperatingState'

func (*UCEVSECCInterface_OperatingState_Call) Return 

func (_c *UCEVSECCInterface_OperatingState_Call) Return(_a0 model.DeviceDiagnosisOperatingStateType, _a1 string, _a2 error) *UCEVSECCInterface_OperatingState_Call

func (*UCEVSECCInterface_OperatingState_Call) Run 

func (_c *UCEVSECCInterface_OperatingState_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVSECCInterface_OperatingState_Call

func (*UCEVSECCInterface_OperatingState_Call) RunAndReturn 

func (_c *UCEVSECCInterface_OperatingState_Call) RunAndReturn(run func(api.EntityRemoteInterface) (model.DeviceDiagnosisOperatingStateType, string, error)) *UCEVSECCInterface_OperatingState_Call

type UCEVSECCInterface_UpdateUseCaseAvailability_Call 

type UCEVSECCInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCEVSECCInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCEVSECCInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCEVSECCInterface_UpdateUseCaseAvailability_Call) Return() *UCEVSECCInterface_UpdateUseCaseAvailability_Call

func (*UCEVSECCInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCEVSECCInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCEVSECCInterface_UpdateUseCaseAvailability_Call

func (*UCEVSECCInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCEVSECCInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCEVSECCInterface_UpdateUseCaseAvailability_Call

type UCEVSECCInterface_UseCaseName_Call 

type UCEVSECCInterface_UseCaseName_Call struct {
	*mock.Call
}

UCEVSECCInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCEVSECCInterface_UseCaseName_Call) Return 

func (_c *UCEVSECCInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCEVSECCInterface_UseCaseName_Call

func (*UCEVSECCInterface_UseCaseName_Call) Run 

func (_c *UCEVSECCInterface_UseCaseName_Call) Run(run func()) *UCEVSECCInterface_UseCaseName_Call

func (*UCEVSECCInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCEVSECCInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCEVSECCInterface_UseCaseName_Call

type UCEVSOCInterface 

type UCEVSOCInterface struct {
	mock.Mock
}

UCEVSOCInterface is an autogenerated mock type for the UCEVSOCInterface type

func NewUCEVSOCInterface 

func NewUCEVSOCInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCEVSOCInterface

NewUCEVSOCInterface creates a new instance of UCEVSOCInterface. 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 (*UCEVSOCInterface) AddFeatures 

func (_m *UCEVSOCInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCEVSOCInterface) AddUseCase 

func (_m *UCEVSOCInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCEVSOCInterface) EXPECT 

func (_m *UCEVSOCInterface) EXPECT() *UCEVSOCInterface_Expecter

func (*UCEVSOCInterface) IsUseCaseSupported 

func (_m *UCEVSOCInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCEVSOCInterface) StateOfCharge 

func (_m *UCEVSOCInterface) StateOfCharge(entity api.EntityRemoteInterface) (float64, error)

StateOfCharge provides a mock function with given fields: entity

func (*UCEVSOCInterface) UpdateUseCaseAvailability 

func (_m *UCEVSOCInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCEVSOCInterface) UseCaseName 

func (_m *UCEVSOCInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

type UCEVSOCInterface_AddFeatures_Call 

type UCEVSOCInterface_AddFeatures_Call struct {
	*mock.Call
}

UCEVSOCInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCEVSOCInterface_AddFeatures_Call) Return 

func (_c *UCEVSOCInterface_AddFeatures_Call) Return() *UCEVSOCInterface_AddFeatures_Call

func (*UCEVSOCInterface_AddFeatures_Call) Run 

func (_c *UCEVSOCInterface_AddFeatures_Call) Run(run func()) *UCEVSOCInterface_AddFeatures_Call

func (*UCEVSOCInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCEVSOCInterface_AddFeatures_Call) RunAndReturn(run func()) *UCEVSOCInterface_AddFeatures_Call

type UCEVSOCInterface_AddUseCase_Call 

type UCEVSOCInterface_AddUseCase_Call struct {
	*mock.Call
}

UCEVSOCInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCEVSOCInterface_AddUseCase_Call) Return 

func (_c *UCEVSOCInterface_AddUseCase_Call) Return() *UCEVSOCInterface_AddUseCase_Call

func (*UCEVSOCInterface_AddUseCase_Call) Run 

func (_c *UCEVSOCInterface_AddUseCase_Call) Run(run func()) *UCEVSOCInterface_AddUseCase_Call

func (*UCEVSOCInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCEVSOCInterface_AddUseCase_Call) RunAndReturn(run func()) *UCEVSOCInterface_AddUseCase_Call

type UCEVSOCInterface_Expecter 

type UCEVSOCInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCEVSOCInterface_Expecter) AddFeatures 

func (_e *UCEVSOCInterface_Expecter) AddFeatures() *UCEVSOCInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCEVSOCInterface_Expecter) AddUseCase 

func (_e *UCEVSOCInterface_Expecter) AddUseCase() *UCEVSOCInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCEVSOCInterface_Expecter) IsUseCaseSupported 

func (_e *UCEVSOCInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCEVSOCInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCEVSOCInterface_Expecter) StateOfCharge 

func (_e *UCEVSOCInterface_Expecter) StateOfCharge(entity interface{}) *UCEVSOCInterface_StateOfCharge_Call

StateOfCharge is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCEVSOCInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCEVSOCInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCEVSOCInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCEVSOCInterface_Expecter) UseCaseName 

func (_e *UCEVSOCInterface_Expecter) UseCaseName() *UCEVSOCInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

type UCEVSOCInterface_IsUseCaseSupported_Call 

type UCEVSOCInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCEVSOCInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCEVSOCInterface_IsUseCaseSupported_Call) Return 

func (_c *UCEVSOCInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCEVSOCInterface_IsUseCaseSupported_Call

func (*UCEVSOCInterface_IsUseCaseSupported_Call) Run 

func (_c *UCEVSOCInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCEVSOCInterface_IsUseCaseSupported_Call

func (*UCEVSOCInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCEVSOCInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCEVSOCInterface_IsUseCaseSupported_Call

type UCEVSOCInterface_StateOfCharge_Call 

type UCEVSOCInterface_StateOfCharge_Call struct {
	*mock.Call
}

UCEVSOCInterface_StateOfCharge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StateOfCharge'

func (*UCEVSOCInterface_StateOfCharge_Call) Return 

func (_c *UCEVSOCInterface_StateOfCharge_Call) Return(_a0 float64, _a1 error) *UCEVSOCInterface_StateOfCharge_Call

func (*UCEVSOCInterface_StateOfCharge_Call) Run 

func (_c *UCEVSOCInterface_StateOfCharge_Call) Run(run func(entity api.EntityRemoteInterface)) *UCEVSOCInterface_StateOfCharge_Call

func (*UCEVSOCInterface_StateOfCharge_Call) RunAndReturn 

func (_c *UCEVSOCInterface_StateOfCharge_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCEVSOCInterface_StateOfCharge_Call

type UCEVSOCInterface_UpdateUseCaseAvailability_Call 

type UCEVSOCInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCEVSOCInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCEVSOCInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCEVSOCInterface_UpdateUseCaseAvailability_Call) Return() *UCEVSOCInterface_UpdateUseCaseAvailability_Call

func (*UCEVSOCInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCEVSOCInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCEVSOCInterface_UpdateUseCaseAvailability_Call

func (*UCEVSOCInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCEVSOCInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCEVSOCInterface_UpdateUseCaseAvailability_Call

type UCEVSOCInterface_UseCaseName_Call 

type UCEVSOCInterface_UseCaseName_Call struct {
	*mock.Call
}

UCEVSOCInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCEVSOCInterface_UseCaseName_Call) Return 

func (_c *UCEVSOCInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCEVSOCInterface_UseCaseName_Call

func (*UCEVSOCInterface_UseCaseName_Call) Run 

func (_c *UCEVSOCInterface_UseCaseName_Call) Run(run func()) *UCEVSOCInterface_UseCaseName_Call

func (*UCEVSOCInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCEVSOCInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCEVSOCInterface_UseCaseName_Call

type UCLPCInterface 

type UCLPCInterface struct {
	mock.Mock
}

UCLPCInterface is an autogenerated mock type for the UCLPCInterface type

func NewUCLPCInterface 

func NewUCLPCInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCLPCInterface

NewUCLPCInterface creates a new instance of UCLPCInterface. 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 (*UCLPCInterface) AddFeatures 

func (_m *UCLPCInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCLPCInterface) AddUseCase 

func (_m *UCLPCInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCLPCInterface) ConsumptionLimit 

func (_m *UCLPCInterface) ConsumptionLimit(entity api.EntityRemoteInterface) (cemdapi.LoadLimit, error)

ConsumptionLimit provides a mock function with given fields: entity

func (*UCLPCInterface) EXPECT 

func (_m *UCLPCInterface) EXPECT() *UCLPCInterface_Expecter

func (*UCLPCInterface) FailsafeConsumptionActivePowerLimit 

func (_m *UCLPCInterface) FailsafeConsumptionActivePowerLimit(entity api.EntityRemoteInterface) (float64, error)

FailsafeConsumptionActivePowerLimit provides a mock function with given fields: entity

func (*UCLPCInterface) FailsafeDurationMinimum 

func (_m *UCLPCInterface) FailsafeDurationMinimum(entity api.EntityRemoteInterface) (time.Duration, error)

FailsafeDurationMinimum provides a mock function with given fields: entity

func (*UCLPCInterface) IsUseCaseSupported 

func (_m *UCLPCInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCLPCInterface) PowerConsumptionNominalMax 

func (_m *UCLPCInterface) PowerConsumptionNominalMax(entity api.EntityRemoteInterface) (float64, error)

PowerConsumptionNominalMax provides a mock function with given fields: entity

func (*UCLPCInterface) UpdateUseCaseAvailability 

func (_m *UCLPCInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCLPCInterface) UseCaseName 

func (_m *UCLPCInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

func (*UCLPCInterface) WriteConsumptionLimit 

func (_m *UCLPCInterface) WriteConsumptionLimit(entity api.EntityRemoteInterface, limit cemdapi.LoadLimit) (*model.MsgCounterType, error)

WriteConsumptionLimit provides a mock function with given fields: entity, limit

func (*UCLPCInterface) WriteFailsafeConsumptionActivePowerLimit 

func (_m *UCLPCInterface) WriteFailsafeConsumptionActivePowerLimit(entity api.EntityRemoteInterface, value float64) (*model.MsgCounterType, error)

WriteFailsafeConsumptionActivePowerLimit provides a mock function with given fields: entity, value

func (*UCLPCInterface) WriteFailsafeDurationMinimum 

func (_m *UCLPCInterface) WriteFailsafeDurationMinimum(entity api.EntityRemoteInterface, duration time.Duration) (*model.MsgCounterType, error)

WriteFailsafeDurationMinimum provides a mock function with given fields: entity, duration

type UCLPCInterface_AddFeatures_Call 

type UCLPCInterface_AddFeatures_Call struct {
	*mock.Call
}

UCLPCInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCLPCInterface_AddFeatures_Call) Return 

func (_c *UCLPCInterface_AddFeatures_Call) Return() *UCLPCInterface_AddFeatures_Call

func (*UCLPCInterface_AddFeatures_Call) Run 

func (_c *UCLPCInterface_AddFeatures_Call) Run(run func()) *UCLPCInterface_AddFeatures_Call

func (*UCLPCInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCLPCInterface_AddFeatures_Call) RunAndReturn(run func()) *UCLPCInterface_AddFeatures_Call

type UCLPCInterface_AddUseCase_Call 

type UCLPCInterface_AddUseCase_Call struct {
	*mock.Call
}

UCLPCInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCLPCInterface_AddUseCase_Call) Return 

func (_c *UCLPCInterface_AddUseCase_Call) Return() *UCLPCInterface_AddUseCase_Call

func (*UCLPCInterface_AddUseCase_Call) Run 

func (_c *UCLPCInterface_AddUseCase_Call) Run(run func()) *UCLPCInterface_AddUseCase_Call

func (*UCLPCInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCLPCInterface_AddUseCase_Call) RunAndReturn(run func()) *UCLPCInterface_AddUseCase_Call

type UCLPCInterface_ConsumptionLimit_Call 

type UCLPCInterface_ConsumptionLimit_Call struct {
	*mock.Call
}

UCLPCInterface_ConsumptionLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConsumptionLimit'

func (*UCLPCInterface_ConsumptionLimit_Call) Return 

func (_c *UCLPCInterface_ConsumptionLimit_Call) Return(limit cemdapi.LoadLimit, resultErr error) *UCLPCInterface_ConsumptionLimit_Call

func (*UCLPCInterface_ConsumptionLimit_Call) Run 

func (_c *UCLPCInterface_ConsumptionLimit_Call) Run(run func(entity api.EntityRemoteInterface)) *UCLPCInterface_ConsumptionLimit_Call

func (*UCLPCInterface_ConsumptionLimit_Call) RunAndReturn 

func (_c *UCLPCInterface_ConsumptionLimit_Call) RunAndReturn(run func(api.EntityRemoteInterface) (cemdapi.LoadLimit, error)) *UCLPCInterface_ConsumptionLimit_Call

type UCLPCInterface_Expecter 

type UCLPCInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCLPCInterface_Expecter) AddFeatures 

func (_e *UCLPCInterface_Expecter) AddFeatures() *UCLPCInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCLPCInterface_Expecter) AddUseCase 

func (_e *UCLPCInterface_Expecter) AddUseCase() *UCLPCInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCLPCInterface_Expecter) ConsumptionLimit 

func (_e *UCLPCInterface_Expecter) ConsumptionLimit(entity interface{}) *UCLPCInterface_ConsumptionLimit_Call

ConsumptionLimit is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCLPCInterface_Expecter) FailsafeConsumptionActivePowerLimit 

func (_e *UCLPCInterface_Expecter) FailsafeConsumptionActivePowerLimit(entity interface{}) *UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call

FailsafeConsumptionActivePowerLimit is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCLPCInterface_Expecter) FailsafeDurationMinimum 

func (_e *UCLPCInterface_Expecter) FailsafeDurationMinimum(entity interface{}) *UCLPCInterface_FailsafeDurationMinimum_Call

FailsafeDurationMinimum is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCLPCInterface_Expecter) IsUseCaseSupported 

func (_e *UCLPCInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCLPCInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCLPCInterface_Expecter) PowerConsumptionNominalMax 

func (_e *UCLPCInterface_Expecter) PowerConsumptionNominalMax(entity interface{}) *UCLPCInterface_PowerConsumptionNominalMax_Call

PowerConsumptionNominalMax is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCLPCInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCLPCInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCLPCInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCLPCInterface_Expecter) UseCaseName 

func (_e *UCLPCInterface_Expecter) UseCaseName() *UCLPCInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

func (*UCLPCInterface_Expecter) WriteConsumptionLimit 

func (_e *UCLPCInterface_Expecter) WriteConsumptionLimit(entity interface{}, limit interface{}) *UCLPCInterface_WriteConsumptionLimit_Call

WriteConsumptionLimit is a helper method to define mock.On call

  • entity api.EntityRemoteInterface
  • limit cemdapi.LoadLimit

func (*UCLPCInterface_Expecter) WriteFailsafeConsumptionActivePowerLimit 

func (_e *UCLPCInterface_Expecter) WriteFailsafeConsumptionActivePowerLimit(entity interface{}, value interface{}) *UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call

WriteFailsafeConsumptionActivePowerLimit is a helper method to define mock.On call

  • entity api.EntityRemoteInterface
  • value float64

func (*UCLPCInterface_Expecter) WriteFailsafeDurationMinimum 

func (_e *UCLPCInterface_Expecter) WriteFailsafeDurationMinimum(entity interface{}, duration interface{}) *UCLPCInterface_WriteFailsafeDurationMinimum_Call

WriteFailsafeDurationMinimum is a helper method to define mock.On call

  • entity api.EntityRemoteInterface
  • duration time.Duration

type UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call 

type UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call struct {
	*mock.Call
}

UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FailsafeConsumptionActivePowerLimit'

func (*UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call) Return 

func (_c *UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call) Return(_a0 float64, _a1 error) *UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call

func (*UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call) Run 

func (_c *UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call) Run(run func(entity api.EntityRemoteInterface)) *UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call

func (*UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call) RunAndReturn 

func (_c *UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCLPCInterface_FailsafeConsumptionActivePowerLimit_Call

type UCLPCInterface_FailsafeDurationMinimum_Call 

type UCLPCInterface_FailsafeDurationMinimum_Call struct {
	*mock.Call
}

UCLPCInterface_FailsafeDurationMinimum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FailsafeDurationMinimum'

func (*UCLPCInterface_FailsafeDurationMinimum_Call) Return 

func (_c *UCLPCInterface_FailsafeDurationMinimum_Call) Return(_a0 time.Duration, _a1 error) *UCLPCInterface_FailsafeDurationMinimum_Call

func (*UCLPCInterface_FailsafeDurationMinimum_Call) Run 

func (_c *UCLPCInterface_FailsafeDurationMinimum_Call) Run(run func(entity api.EntityRemoteInterface)) *UCLPCInterface_FailsafeDurationMinimum_Call

func (*UCLPCInterface_FailsafeDurationMinimum_Call) RunAndReturn 

func (_c *UCLPCInterface_FailsafeDurationMinimum_Call) RunAndReturn(run func(api.EntityRemoteInterface) (time.Duration, error)) *UCLPCInterface_FailsafeDurationMinimum_Call

type UCLPCInterface_IsUseCaseSupported_Call 

type UCLPCInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCLPCInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCLPCInterface_IsUseCaseSupported_Call) Return 

func (_c *UCLPCInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCLPCInterface_IsUseCaseSupported_Call

func (*UCLPCInterface_IsUseCaseSupported_Call) Run 

func (_c *UCLPCInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCLPCInterface_IsUseCaseSupported_Call

func (*UCLPCInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCLPCInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCLPCInterface_IsUseCaseSupported_Call

type UCLPCInterface_PowerConsumptionNominalMax_Call 

type UCLPCInterface_PowerConsumptionNominalMax_Call struct {
	*mock.Call
}

UCLPCInterface_PowerConsumptionNominalMax_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PowerConsumptionNominalMax'

func (*UCLPCInterface_PowerConsumptionNominalMax_Call) Return 

func (_c *UCLPCInterface_PowerConsumptionNominalMax_Call) Return(_a0 float64, _a1 error) *UCLPCInterface_PowerConsumptionNominalMax_Call

func (*UCLPCInterface_PowerConsumptionNominalMax_Call) Run 

func (_c *UCLPCInterface_PowerConsumptionNominalMax_Call) Run(run func(entity api.EntityRemoteInterface)) *UCLPCInterface_PowerConsumptionNominalMax_Call

func (*UCLPCInterface_PowerConsumptionNominalMax_Call) RunAndReturn 

func (_c *UCLPCInterface_PowerConsumptionNominalMax_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCLPCInterface_PowerConsumptionNominalMax_Call

type UCLPCInterface_UpdateUseCaseAvailability_Call 

type UCLPCInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCLPCInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCLPCInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCLPCInterface_UpdateUseCaseAvailability_Call) Return() *UCLPCInterface_UpdateUseCaseAvailability_Call

func (*UCLPCInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCLPCInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCLPCInterface_UpdateUseCaseAvailability_Call

func (*UCLPCInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCLPCInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCLPCInterface_UpdateUseCaseAvailability_Call

type UCLPCInterface_UseCaseName_Call 

type UCLPCInterface_UseCaseName_Call struct {
	*mock.Call
}

UCLPCInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCLPCInterface_UseCaseName_Call) Return 

func (_c *UCLPCInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCLPCInterface_UseCaseName_Call

func (*UCLPCInterface_UseCaseName_Call) Run 

func (_c *UCLPCInterface_UseCaseName_Call) Run(run func()) *UCLPCInterface_UseCaseName_Call

func (*UCLPCInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCLPCInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCLPCInterface_UseCaseName_Call

type UCLPCInterface_WriteConsumptionLimit_Call 

type UCLPCInterface_WriteConsumptionLimit_Call struct {
	*mock.Call
}

UCLPCInterface_WriteConsumptionLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteConsumptionLimit'

func (*UCLPCInterface_WriteConsumptionLimit_Call) Return 

func (_c *UCLPCInterface_WriteConsumptionLimit_Call) Return(_a0 *model.MsgCounterType, _a1 error) *UCLPCInterface_WriteConsumptionLimit_Call

func (*UCLPCInterface_WriteConsumptionLimit_Call) Run 

func (_c *UCLPCInterface_WriteConsumptionLimit_Call) Run(run func(entity api.EntityRemoteInterface, limit cemdapi.LoadLimit)) *UCLPCInterface_WriteConsumptionLimit_Call

func (*UCLPCInterface_WriteConsumptionLimit_Call) RunAndReturn 

func (_c *UCLPCInterface_WriteConsumptionLimit_Call) RunAndReturn(run func(api.EntityRemoteInterface, cemdapi.LoadLimit) (*model.MsgCounterType, error)) *UCLPCInterface_WriteConsumptionLimit_Call

type UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call 

type UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call struct {
	*mock.Call
}

UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteFailsafeConsumptionActivePowerLimit'

func (*UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call) Return 

func (_c *UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call) Return(_a0 *model.MsgCounterType, _a1 error) *UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call

func (*UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call) Run 

func (_c *UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call) Run(run func(entity api.EntityRemoteInterface, value float64)) *UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call

func (*UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call) RunAndReturn 

func (_c *UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call) RunAndReturn(run func(api.EntityRemoteInterface, float64) (*model.MsgCounterType, error)) *UCLPCInterface_WriteFailsafeConsumptionActivePowerLimit_Call

type UCLPCInterface_WriteFailsafeDurationMinimum_Call 

type UCLPCInterface_WriteFailsafeDurationMinimum_Call struct {
	*mock.Call
}

UCLPCInterface_WriteFailsafeDurationMinimum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteFailsafeDurationMinimum'

func (*UCLPCInterface_WriteFailsafeDurationMinimum_Call) Return 

func (_c *UCLPCInterface_WriteFailsafeDurationMinimum_Call) Return(_a0 *model.MsgCounterType, _a1 error) *UCLPCInterface_WriteFailsafeDurationMinimum_Call

func (*UCLPCInterface_WriteFailsafeDurationMinimum_Call) Run 

func (_c *UCLPCInterface_WriteFailsafeDurationMinimum_Call) Run(run func(entity api.EntityRemoteInterface, duration time.Duration)) *UCLPCInterface_WriteFailsafeDurationMinimum_Call

func (*UCLPCInterface_WriteFailsafeDurationMinimum_Call) RunAndReturn 

func (_c *UCLPCInterface_WriteFailsafeDurationMinimum_Call) RunAndReturn(run func(api.EntityRemoteInterface, time.Duration) (*model.MsgCounterType, error)) *UCLPCInterface_WriteFailsafeDurationMinimum_Call

type UCLPCServerInterface 

type UCLPCServerInterface struct {
	mock.Mock
}

UCLPCServerInterface is an autogenerated mock type for the UCLPCServerInterface type

func NewUCLPCServerInterface 

func NewUCLPCServerInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCLPCServerInterface

NewUCLPCServerInterface creates a new instance of UCLPCServerInterface. 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 (*UCLPCServerInterface) AddFeatures 

func (_m *UCLPCServerInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCLPCServerInterface) AddUseCase 

func (_m *UCLPCServerInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCLPCServerInterface) ConsumptionLimit 

func (_m *UCLPCServerInterface) ConsumptionLimit() (api.LoadLimit, error)

ConsumptionLimit provides a mock function with given fields:

func (*UCLPCServerInterface) ContractualConsumptionNominalMax 

func (_m *UCLPCServerInterface) ContractualConsumptionNominalMax() (float64, error)

ContractualConsumptionNominalMax provides a mock function with given fields:

func (*UCLPCServerInterface) EXPECT 

func (_m *UCLPCServerInterface) EXPECT() *UCLPCServerInterface_Expecter

func (*UCLPCServerInterface) FailsafeConsumptionActivePowerLimit 

func (_m *UCLPCServerInterface) FailsafeConsumptionActivePowerLimit() (float64, bool, error)

FailsafeConsumptionActivePowerLimit provides a mock function with given fields:

func (*UCLPCServerInterface) FailsafeDurationMinimum 

func (_m *UCLPCServerInterface) FailsafeDurationMinimum() (time.Duration, bool, error)

FailsafeDurationMinimum provides a mock function with given fields:

func (*UCLPCServerInterface) IsUseCaseSupported 

func (_m *UCLPCServerInterface) IsUseCaseSupported(remoteEntity spine_goapi.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCLPCServerInterface) SetConsumptionLimit 

func (_m *UCLPCServerInterface) SetConsumptionLimit(limit api.LoadLimit) error

SetConsumptionLimit provides a mock function with given fields: limit

func (*UCLPCServerInterface) SetContractualConsumptionNominalMax 

func (_m *UCLPCServerInterface) SetContractualConsumptionNominalMax(value float64) error

SetContractualConsumptionNominalMax provides a mock function with given fields: value

func (*UCLPCServerInterface) SetFailsafeConsumptionActivePowerLimit 

func (_m *UCLPCServerInterface) SetFailsafeConsumptionActivePowerLimit(value float64, changeable bool) error

SetFailsafeConsumptionActivePowerLimit provides a mock function with given fields: value, changeable

func (*UCLPCServerInterface) SetFailsafeDurationMinimum 

func (_m *UCLPCServerInterface) SetFailsafeDurationMinimum(duration time.Duration, changeable bool) error

SetFailsafeDurationMinimum provides a mock function with given fields: duration, changeable

func (*UCLPCServerInterface) UpdateUseCaseAvailability 

func (_m *UCLPCServerInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCLPCServerInterface) UseCaseName 

func (_m *UCLPCServerInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

type UCLPCServerInterface_AddFeatures_Call 

type UCLPCServerInterface_AddFeatures_Call struct {
	*mock.Call
}

UCLPCServerInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCLPCServerInterface_AddFeatures_Call) Return 

func (_c *UCLPCServerInterface_AddFeatures_Call) Return() *UCLPCServerInterface_AddFeatures_Call

func (*UCLPCServerInterface_AddFeatures_Call) Run 

func (_c *UCLPCServerInterface_AddFeatures_Call) Run(run func()) *UCLPCServerInterface_AddFeatures_Call

func (*UCLPCServerInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCLPCServerInterface_AddFeatures_Call) RunAndReturn(run func()) *UCLPCServerInterface_AddFeatures_Call

type UCLPCServerInterface_AddUseCase_Call 

type UCLPCServerInterface_AddUseCase_Call struct {
	*mock.Call
}

UCLPCServerInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCLPCServerInterface_AddUseCase_Call) Return 

func (_c *UCLPCServerInterface_AddUseCase_Call) Return() *UCLPCServerInterface_AddUseCase_Call

func (*UCLPCServerInterface_AddUseCase_Call) Run 

func (_c *UCLPCServerInterface_AddUseCase_Call) Run(run func()) *UCLPCServerInterface_AddUseCase_Call

func (*UCLPCServerInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCLPCServerInterface_AddUseCase_Call) RunAndReturn(run func()) *UCLPCServerInterface_AddUseCase_Call

type UCLPCServerInterface_ConsumptionLimit_Call 

type UCLPCServerInterface_ConsumptionLimit_Call struct {
	*mock.Call
}

UCLPCServerInterface_ConsumptionLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ConsumptionLimit'

func (*UCLPCServerInterface_ConsumptionLimit_Call) Return 

func (_c *UCLPCServerInterface_ConsumptionLimit_Call) Return(_a0 api.LoadLimit, _a1 error) *UCLPCServerInterface_ConsumptionLimit_Call

func (*UCLPCServerInterface_ConsumptionLimit_Call) Run 

func (_c *UCLPCServerInterface_ConsumptionLimit_Call) Run(run func()) *UCLPCServerInterface_ConsumptionLimit_Call

func (*UCLPCServerInterface_ConsumptionLimit_Call) RunAndReturn 

func (_c *UCLPCServerInterface_ConsumptionLimit_Call) RunAndReturn(run func() (api.LoadLimit, error)) *UCLPCServerInterface_ConsumptionLimit_Call

type UCLPCServerInterface_ContractualConsumptionNominalMax_Call 

type UCLPCServerInterface_ContractualConsumptionNominalMax_Call struct {
	*mock.Call
}

UCLPCServerInterface_ContractualConsumptionNominalMax_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContractualConsumptionNominalMax'

func (*UCLPCServerInterface_ContractualConsumptionNominalMax_Call) Return 

func (_c *UCLPCServerInterface_ContractualConsumptionNominalMax_Call) Return(_a0 float64, _a1 error) *UCLPCServerInterface_ContractualConsumptionNominalMax_Call

func (*UCLPCServerInterface_ContractualConsumptionNominalMax_Call) Run 

func (_c *UCLPCServerInterface_ContractualConsumptionNominalMax_Call) Run(run func()) *UCLPCServerInterface_ContractualConsumptionNominalMax_Call

func (*UCLPCServerInterface_ContractualConsumptionNominalMax_Call) RunAndReturn 

func (_c *UCLPCServerInterface_ContractualConsumptionNominalMax_Call) RunAndReturn(run func() (float64, error)) *UCLPCServerInterface_ContractualConsumptionNominalMax_Call

type UCLPCServerInterface_Expecter 

type UCLPCServerInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCLPCServerInterface_Expecter) AddFeatures 

func (_e *UCLPCServerInterface_Expecter) AddFeatures() *UCLPCServerInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCLPCServerInterface_Expecter) AddUseCase 

func (_e *UCLPCServerInterface_Expecter) AddUseCase() *UCLPCServerInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCLPCServerInterface_Expecter) ConsumptionLimit 

func (_e *UCLPCServerInterface_Expecter) ConsumptionLimit() *UCLPCServerInterface_ConsumptionLimit_Call

ConsumptionLimit is a helper method to define mock.On call

func (*UCLPCServerInterface_Expecter) ContractualConsumptionNominalMax 

func (_e *UCLPCServerInterface_Expecter) ContractualConsumptionNominalMax() *UCLPCServerInterface_ContractualConsumptionNominalMax_Call

ContractualConsumptionNominalMax is a helper method to define mock.On call

func (*UCLPCServerInterface_Expecter) FailsafeConsumptionActivePowerLimit 

func (_e *UCLPCServerInterface_Expecter) FailsafeConsumptionActivePowerLimit() *UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call

FailsafeConsumptionActivePowerLimit is a helper method to define mock.On call

func (*UCLPCServerInterface_Expecter) FailsafeDurationMinimum 

func (_e *UCLPCServerInterface_Expecter) FailsafeDurationMinimum() *UCLPCServerInterface_FailsafeDurationMinimum_Call

FailsafeDurationMinimum is a helper method to define mock.On call

func (*UCLPCServerInterface_Expecter) IsUseCaseSupported 

func (_e *UCLPCServerInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCLPCServerInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity spine_goapi.EntityRemoteInterface

func (*UCLPCServerInterface_Expecter) SetConsumptionLimit 

func (_e *UCLPCServerInterface_Expecter) SetConsumptionLimit(limit interface{}) *UCLPCServerInterface_SetConsumptionLimit_Call

SetConsumptionLimit is a helper method to define mock.On call

  • limit api.LoadLimit

func (*UCLPCServerInterface_Expecter) SetContractualConsumptionNominalMax 

func (_e *UCLPCServerInterface_Expecter) SetContractualConsumptionNominalMax(value interface{}) *UCLPCServerInterface_SetContractualConsumptionNominalMax_Call

SetContractualConsumptionNominalMax is a helper method to define mock.On call

  • value float64

func (*UCLPCServerInterface_Expecter) SetFailsafeConsumptionActivePowerLimit 

func (_e *UCLPCServerInterface_Expecter) SetFailsafeConsumptionActivePowerLimit(value interface{}, changeable interface{}) *UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call

SetFailsafeConsumptionActivePowerLimit is a helper method to define mock.On call

  • value float64
  • changeable bool

func (*UCLPCServerInterface_Expecter) SetFailsafeDurationMinimum 

func (_e *UCLPCServerInterface_Expecter) SetFailsafeDurationMinimum(duration interface{}, changeable interface{}) *UCLPCServerInterface_SetFailsafeDurationMinimum_Call

SetFailsafeDurationMinimum is a helper method to define mock.On call

  • duration time.Duration
  • changeable bool

func (*UCLPCServerInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCLPCServerInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCLPCServerInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCLPCServerInterface_Expecter) UseCaseName 

func (_e *UCLPCServerInterface_Expecter) UseCaseName() *UCLPCServerInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

type UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call 

type UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call struct {
	*mock.Call
}

UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FailsafeConsumptionActivePowerLimit'

func (*UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call) Return 

func (_c *UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call) Return(value float64, isChangeable bool, resultErr error) *UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call

func (*UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call) Run 

func (_c *UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call) Run(run func()) *UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call

func (*UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call) RunAndReturn 

func (_c *UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call) RunAndReturn(run func() (float64, bool, error)) *UCLPCServerInterface_FailsafeConsumptionActivePowerLimit_Call

type UCLPCServerInterface_FailsafeDurationMinimum_Call 

type UCLPCServerInterface_FailsafeDurationMinimum_Call struct {
	*mock.Call
}

UCLPCServerInterface_FailsafeDurationMinimum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FailsafeDurationMinimum'

func (*UCLPCServerInterface_FailsafeDurationMinimum_Call) Return 

func (_c *UCLPCServerInterface_FailsafeDurationMinimum_Call) Return(duration time.Duration, isChangeable bool, resultErr error) *UCLPCServerInterface_FailsafeDurationMinimum_Call

func (*UCLPCServerInterface_FailsafeDurationMinimum_Call) Run 

func (_c *UCLPCServerInterface_FailsafeDurationMinimum_Call) Run(run func()) *UCLPCServerInterface_FailsafeDurationMinimum_Call

func (*UCLPCServerInterface_FailsafeDurationMinimum_Call) RunAndReturn 

func (_c *UCLPCServerInterface_FailsafeDurationMinimum_Call) RunAndReturn(run func() (time.Duration, bool, error)) *UCLPCServerInterface_FailsafeDurationMinimum_Call

type UCLPCServerInterface_IsUseCaseSupported_Call 

type UCLPCServerInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCLPCServerInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCLPCServerInterface_IsUseCaseSupported_Call) Return 

func (_c *UCLPCServerInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCLPCServerInterface_IsUseCaseSupported_Call

func (*UCLPCServerInterface_IsUseCaseSupported_Call) Run 

func (_c *UCLPCServerInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity spine_goapi.EntityRemoteInterface)) *UCLPCServerInterface_IsUseCaseSupported_Call

func (*UCLPCServerInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCLPCServerInterface_IsUseCaseSupported_Call) RunAndReturn(run func(spine_goapi.EntityRemoteInterface) (bool, error)) *UCLPCServerInterface_IsUseCaseSupported_Call

type UCLPCServerInterface_SetConsumptionLimit_Call 

type UCLPCServerInterface_SetConsumptionLimit_Call struct {
	*mock.Call
}

UCLPCServerInterface_SetConsumptionLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetConsumptionLimit'

func (*UCLPCServerInterface_SetConsumptionLimit_Call) Return 

func (_c *UCLPCServerInterface_SetConsumptionLimit_Call) Return(resultErr error) *UCLPCServerInterface_SetConsumptionLimit_Call

func (*UCLPCServerInterface_SetConsumptionLimit_Call) Run 

func (_c *UCLPCServerInterface_SetConsumptionLimit_Call) Run(run func(limit api.LoadLimit)) *UCLPCServerInterface_SetConsumptionLimit_Call

func (*UCLPCServerInterface_SetConsumptionLimit_Call) RunAndReturn 

func (_c *UCLPCServerInterface_SetConsumptionLimit_Call) RunAndReturn(run func(api.LoadLimit) error) *UCLPCServerInterface_SetConsumptionLimit_Call

type UCLPCServerInterface_SetContractualConsumptionNominalMax_Call 

type UCLPCServerInterface_SetContractualConsumptionNominalMax_Call struct {
	*mock.Call
}

UCLPCServerInterface_SetContractualConsumptionNominalMax_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetContractualConsumptionNominalMax'

func (*UCLPCServerInterface_SetContractualConsumptionNominalMax_Call) Return 

func (_c *UCLPCServerInterface_SetContractualConsumptionNominalMax_Call) Return(resultErr error) *UCLPCServerInterface_SetContractualConsumptionNominalMax_Call

func (*UCLPCServerInterface_SetContractualConsumptionNominalMax_Call) Run 

func (_c *UCLPCServerInterface_SetContractualConsumptionNominalMax_Call) Run(run func(value float64)) *UCLPCServerInterface_SetContractualConsumptionNominalMax_Call

func (*UCLPCServerInterface_SetContractualConsumptionNominalMax_Call) RunAndReturn 

func (_c *UCLPCServerInterface_SetContractualConsumptionNominalMax_Call) RunAndReturn(run func(float64) error) *UCLPCServerInterface_SetContractualConsumptionNominalMax_Call

type UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call 

type UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call struct {
	*mock.Call
}

UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFailsafeConsumptionActivePowerLimit'

func (*UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call) Return 

func (_c *UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call) Return(resultErr error) *UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call

func (*UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call) Run 

func (_c *UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call) Run(run func(value float64, changeable bool)) *UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call

func (*UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call) RunAndReturn 

func (_c *UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call) RunAndReturn(run func(float64, bool) error) *UCLPCServerInterface_SetFailsafeConsumptionActivePowerLimit_Call

type UCLPCServerInterface_SetFailsafeDurationMinimum_Call 

type UCLPCServerInterface_SetFailsafeDurationMinimum_Call struct {
	*mock.Call
}

UCLPCServerInterface_SetFailsafeDurationMinimum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFailsafeDurationMinimum'

func (*UCLPCServerInterface_SetFailsafeDurationMinimum_Call) Return 

func (_c *UCLPCServerInterface_SetFailsafeDurationMinimum_Call) Return(resultErr error) *UCLPCServerInterface_SetFailsafeDurationMinimum_Call

func (*UCLPCServerInterface_SetFailsafeDurationMinimum_Call) Run 

func (_c *UCLPCServerInterface_SetFailsafeDurationMinimum_Call) Run(run func(duration time.Duration, changeable bool)) *UCLPCServerInterface_SetFailsafeDurationMinimum_Call

func (*UCLPCServerInterface_SetFailsafeDurationMinimum_Call) RunAndReturn 

func (_c *UCLPCServerInterface_SetFailsafeDurationMinimum_Call) RunAndReturn(run func(time.Duration, bool) error) *UCLPCServerInterface_SetFailsafeDurationMinimum_Call

type UCLPCServerInterface_UpdateUseCaseAvailability_Call 

type UCLPCServerInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCLPCServerInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCLPCServerInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCLPCServerInterface_UpdateUseCaseAvailability_Call) Return() *UCLPCServerInterface_UpdateUseCaseAvailability_Call

func (*UCLPCServerInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCLPCServerInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCLPCServerInterface_UpdateUseCaseAvailability_Call

func (*UCLPCServerInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCLPCServerInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCLPCServerInterface_UpdateUseCaseAvailability_Call

type UCLPCServerInterface_UseCaseName_Call 

type UCLPCServerInterface_UseCaseName_Call struct {
	*mock.Call
}

UCLPCServerInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCLPCServerInterface_UseCaseName_Call) Return 

func (_c *UCLPCServerInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCLPCServerInterface_UseCaseName_Call

func (*UCLPCServerInterface_UseCaseName_Call) Run 

func (_c *UCLPCServerInterface_UseCaseName_Call) Run(run func()) *UCLPCServerInterface_UseCaseName_Call

func (*UCLPCServerInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCLPCServerInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCLPCServerInterface_UseCaseName_Call

type UCLPPInterface 

type UCLPPInterface struct {
	mock.Mock
}

UCLPPInterface is an autogenerated mock type for the UCLPPInterface type

func NewUCLPPInterface 

func NewUCLPPInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCLPPInterface

NewUCLPPInterface creates a new instance of UCLPPInterface. 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 (*UCLPPInterface) AddFeatures 

func (_m *UCLPPInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCLPPInterface) AddUseCase 

func (_m *UCLPPInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCLPPInterface) EXPECT 

func (_m *UCLPPInterface) EXPECT() *UCLPPInterface_Expecter

func (*UCLPPInterface) FailsafeDurationMinimum 

func (_m *UCLPPInterface) FailsafeDurationMinimum(entity api.EntityRemoteInterface) (time.Duration, error)

FailsafeDurationMinimum provides a mock function with given fields: entity

func (*UCLPPInterface) FailsafeProductionActivePowerLimit 

func (_m *UCLPPInterface) FailsafeProductionActivePowerLimit(entity api.EntityRemoteInterface) (float64, error)

FailsafeProductionActivePowerLimit provides a mock function with given fields: entity

func (*UCLPPInterface) IsUseCaseSupported 

func (_m *UCLPPInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCLPPInterface) PowerProductionNominalMax 

func (_m *UCLPPInterface) PowerProductionNominalMax(entity api.EntityRemoteInterface) (float64, error)

PowerProductionNominalMax provides a mock function with given fields: entity

func (*UCLPPInterface) ProductionLimit 

func (_m *UCLPPInterface) ProductionLimit(entity api.EntityRemoteInterface) (cemdapi.LoadLimit, error)

ProductionLimit provides a mock function with given fields: entity

func (*UCLPPInterface) UpdateUseCaseAvailability 

func (_m *UCLPPInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCLPPInterface) UseCaseName 

func (_m *UCLPPInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

func (*UCLPPInterface) WriteFailsafeDurationMinimum 

func (_m *UCLPPInterface) WriteFailsafeDurationMinimum(entity api.EntityRemoteInterface, duration time.Duration) (*model.MsgCounterType, error)

WriteFailsafeDurationMinimum provides a mock function with given fields: entity, duration

func (*UCLPPInterface) WriteFailsafeProductionActivePowerLimit 

func (_m *UCLPPInterface) WriteFailsafeProductionActivePowerLimit(entity api.EntityRemoteInterface, value float64) (*model.MsgCounterType, error)

WriteFailsafeProductionActivePowerLimit provides a mock function with given fields: entity, value

func (*UCLPPInterface) WriteProductionLimit 

func (_m *UCLPPInterface) WriteProductionLimit(entity api.EntityRemoteInterface, limit cemdapi.LoadLimit) (*model.MsgCounterType, error)

WriteProductionLimit provides a mock function with given fields: entity, limit

type UCLPPInterface_AddFeatures_Call 

type UCLPPInterface_AddFeatures_Call struct {
	*mock.Call
}

UCLPPInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCLPPInterface_AddFeatures_Call) Return 

func (_c *UCLPPInterface_AddFeatures_Call) Return() *UCLPPInterface_AddFeatures_Call

func (*UCLPPInterface_AddFeatures_Call) Run 

func (_c *UCLPPInterface_AddFeatures_Call) Run(run func()) *UCLPPInterface_AddFeatures_Call

func (*UCLPPInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCLPPInterface_AddFeatures_Call) RunAndReturn(run func()) *UCLPPInterface_AddFeatures_Call

type UCLPPInterface_AddUseCase_Call 

type UCLPPInterface_AddUseCase_Call struct {
	*mock.Call
}

UCLPPInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCLPPInterface_AddUseCase_Call) Return 

func (_c *UCLPPInterface_AddUseCase_Call) Return() *UCLPPInterface_AddUseCase_Call

func (*UCLPPInterface_AddUseCase_Call) Run 

func (_c *UCLPPInterface_AddUseCase_Call) Run(run func()) *UCLPPInterface_AddUseCase_Call

func (*UCLPPInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCLPPInterface_AddUseCase_Call) RunAndReturn(run func()) *UCLPPInterface_AddUseCase_Call

type UCLPPInterface_Expecter 

type UCLPPInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCLPPInterface_Expecter) AddFeatures 

func (_e *UCLPPInterface_Expecter) AddFeatures() *UCLPPInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCLPPInterface_Expecter) AddUseCase 

func (_e *UCLPPInterface_Expecter) AddUseCase() *UCLPPInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCLPPInterface_Expecter) FailsafeDurationMinimum 

func (_e *UCLPPInterface_Expecter) FailsafeDurationMinimum(entity interface{}) *UCLPPInterface_FailsafeDurationMinimum_Call

FailsafeDurationMinimum is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCLPPInterface_Expecter) FailsafeProductionActivePowerLimit 

func (_e *UCLPPInterface_Expecter) FailsafeProductionActivePowerLimit(entity interface{}) *UCLPPInterface_FailsafeProductionActivePowerLimit_Call

FailsafeProductionActivePowerLimit is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCLPPInterface_Expecter) IsUseCaseSupported 

func (_e *UCLPPInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCLPPInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCLPPInterface_Expecter) PowerProductionNominalMax 

func (_e *UCLPPInterface_Expecter) PowerProductionNominalMax(entity interface{}) *UCLPPInterface_PowerProductionNominalMax_Call

PowerProductionNominalMax is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCLPPInterface_Expecter) ProductionLimit 

func (_e *UCLPPInterface_Expecter) ProductionLimit(entity interface{}) *UCLPPInterface_ProductionLimit_Call

ProductionLimit is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCLPPInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCLPPInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCLPPInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCLPPInterface_Expecter) UseCaseName 

func (_e *UCLPPInterface_Expecter) UseCaseName() *UCLPPInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

func (*UCLPPInterface_Expecter) WriteFailsafeDurationMinimum 

func (_e *UCLPPInterface_Expecter) WriteFailsafeDurationMinimum(entity interface{}, duration interface{}) *UCLPPInterface_WriteFailsafeDurationMinimum_Call

WriteFailsafeDurationMinimum is a helper method to define mock.On call

  • entity api.EntityRemoteInterface
  • duration time.Duration

func (*UCLPPInterface_Expecter) WriteFailsafeProductionActivePowerLimit 

func (_e *UCLPPInterface_Expecter) WriteFailsafeProductionActivePowerLimit(entity interface{}, value interface{}) *UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call

WriteFailsafeProductionActivePowerLimit is a helper method to define mock.On call

  • entity api.EntityRemoteInterface
  • value float64

func (*UCLPPInterface_Expecter) WriteProductionLimit 

func (_e *UCLPPInterface_Expecter) WriteProductionLimit(entity interface{}, limit interface{}) *UCLPPInterface_WriteProductionLimit_Call

WriteProductionLimit is a helper method to define mock.On call

  • entity api.EntityRemoteInterface
  • limit cemdapi.LoadLimit

type UCLPPInterface_FailsafeDurationMinimum_Call 

type UCLPPInterface_FailsafeDurationMinimum_Call struct {
	*mock.Call
}

UCLPPInterface_FailsafeDurationMinimum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FailsafeDurationMinimum'

func (*UCLPPInterface_FailsafeDurationMinimum_Call) Return 

func (_c *UCLPPInterface_FailsafeDurationMinimum_Call) Return(_a0 time.Duration, _a1 error) *UCLPPInterface_FailsafeDurationMinimum_Call

func (*UCLPPInterface_FailsafeDurationMinimum_Call) Run 

func (_c *UCLPPInterface_FailsafeDurationMinimum_Call) Run(run func(entity api.EntityRemoteInterface)) *UCLPPInterface_FailsafeDurationMinimum_Call

func (*UCLPPInterface_FailsafeDurationMinimum_Call) RunAndReturn 

func (_c *UCLPPInterface_FailsafeDurationMinimum_Call) RunAndReturn(run func(api.EntityRemoteInterface) (time.Duration, error)) *UCLPPInterface_FailsafeDurationMinimum_Call

type UCLPPInterface_FailsafeProductionActivePowerLimit_Call 

type UCLPPInterface_FailsafeProductionActivePowerLimit_Call struct {
	*mock.Call
}

UCLPPInterface_FailsafeProductionActivePowerLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FailsafeProductionActivePowerLimit'

func (*UCLPPInterface_FailsafeProductionActivePowerLimit_Call) Return 

func (_c *UCLPPInterface_FailsafeProductionActivePowerLimit_Call) Return(_a0 float64, _a1 error) *UCLPPInterface_FailsafeProductionActivePowerLimit_Call

func (*UCLPPInterface_FailsafeProductionActivePowerLimit_Call) Run 

func (_c *UCLPPInterface_FailsafeProductionActivePowerLimit_Call) Run(run func(entity api.EntityRemoteInterface)) *UCLPPInterface_FailsafeProductionActivePowerLimit_Call

func (*UCLPPInterface_FailsafeProductionActivePowerLimit_Call) RunAndReturn 

func (_c *UCLPPInterface_FailsafeProductionActivePowerLimit_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCLPPInterface_FailsafeProductionActivePowerLimit_Call

type UCLPPInterface_IsUseCaseSupported_Call 

type UCLPPInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCLPPInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCLPPInterface_IsUseCaseSupported_Call) Return 

func (_c *UCLPPInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCLPPInterface_IsUseCaseSupported_Call

func (*UCLPPInterface_IsUseCaseSupported_Call) Run 

func (_c *UCLPPInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCLPPInterface_IsUseCaseSupported_Call

func (*UCLPPInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCLPPInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCLPPInterface_IsUseCaseSupported_Call

type UCLPPInterface_PowerProductionNominalMax_Call 

type UCLPPInterface_PowerProductionNominalMax_Call struct {
	*mock.Call
}

UCLPPInterface_PowerProductionNominalMax_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PowerProductionNominalMax'

func (*UCLPPInterface_PowerProductionNominalMax_Call) Return 

func (_c *UCLPPInterface_PowerProductionNominalMax_Call) Return(_a0 float64, _a1 error) *UCLPPInterface_PowerProductionNominalMax_Call

func (*UCLPPInterface_PowerProductionNominalMax_Call) Run 

func (_c *UCLPPInterface_PowerProductionNominalMax_Call) Run(run func(entity api.EntityRemoteInterface)) *UCLPPInterface_PowerProductionNominalMax_Call

func (*UCLPPInterface_PowerProductionNominalMax_Call) RunAndReturn 

func (_c *UCLPPInterface_PowerProductionNominalMax_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCLPPInterface_PowerProductionNominalMax_Call

type UCLPPInterface_ProductionLimit_Call 

type UCLPPInterface_ProductionLimit_Call struct {
	*mock.Call
}

UCLPPInterface_ProductionLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProductionLimit'

func (*UCLPPInterface_ProductionLimit_Call) Return 

func (_c *UCLPPInterface_ProductionLimit_Call) Return(limit cemdapi.LoadLimit, resultErr error) *UCLPPInterface_ProductionLimit_Call

func (*UCLPPInterface_ProductionLimit_Call) Run 

func (_c *UCLPPInterface_ProductionLimit_Call) Run(run func(entity api.EntityRemoteInterface)) *UCLPPInterface_ProductionLimit_Call

func (*UCLPPInterface_ProductionLimit_Call) RunAndReturn 

func (_c *UCLPPInterface_ProductionLimit_Call) RunAndReturn(run func(api.EntityRemoteInterface) (cemdapi.LoadLimit, error)) *UCLPPInterface_ProductionLimit_Call

type UCLPPInterface_UpdateUseCaseAvailability_Call 

type UCLPPInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCLPPInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCLPPInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCLPPInterface_UpdateUseCaseAvailability_Call) Return() *UCLPPInterface_UpdateUseCaseAvailability_Call

func (*UCLPPInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCLPPInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCLPPInterface_UpdateUseCaseAvailability_Call

func (*UCLPPInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCLPPInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCLPPInterface_UpdateUseCaseAvailability_Call

type UCLPPInterface_UseCaseName_Call 

type UCLPPInterface_UseCaseName_Call struct {
	*mock.Call
}

UCLPPInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCLPPInterface_UseCaseName_Call) Return 

func (_c *UCLPPInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCLPPInterface_UseCaseName_Call

func (*UCLPPInterface_UseCaseName_Call) Run 

func (_c *UCLPPInterface_UseCaseName_Call) Run(run func()) *UCLPPInterface_UseCaseName_Call

func (*UCLPPInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCLPPInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCLPPInterface_UseCaseName_Call

type UCLPPInterface_WriteFailsafeDurationMinimum_Call 

type UCLPPInterface_WriteFailsafeDurationMinimum_Call struct {
	*mock.Call
}

UCLPPInterface_WriteFailsafeDurationMinimum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteFailsafeDurationMinimum'

func (*UCLPPInterface_WriteFailsafeDurationMinimum_Call) Return 

func (_c *UCLPPInterface_WriteFailsafeDurationMinimum_Call) Return(_a0 *model.MsgCounterType, _a1 error) *UCLPPInterface_WriteFailsafeDurationMinimum_Call

func (*UCLPPInterface_WriteFailsafeDurationMinimum_Call) Run 

func (_c *UCLPPInterface_WriteFailsafeDurationMinimum_Call) Run(run func(entity api.EntityRemoteInterface, duration time.Duration)) *UCLPPInterface_WriteFailsafeDurationMinimum_Call

func (*UCLPPInterface_WriteFailsafeDurationMinimum_Call) RunAndReturn 

func (_c *UCLPPInterface_WriteFailsafeDurationMinimum_Call) RunAndReturn(run func(api.EntityRemoteInterface, time.Duration) (*model.MsgCounterType, error)) *UCLPPInterface_WriteFailsafeDurationMinimum_Call

type UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call 

type UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call struct {
	*mock.Call
}

UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteFailsafeProductionActivePowerLimit'

func (*UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call) Return 

func (_c *UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call) Return(_a0 *model.MsgCounterType, _a1 error) *UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call

func (*UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call) Run 

func (_c *UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call) Run(run func(entity api.EntityRemoteInterface, value float64)) *UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call

func (*UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call) RunAndReturn 

func (_c *UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call) RunAndReturn(run func(api.EntityRemoteInterface, float64) (*model.MsgCounterType, error)) *UCLPPInterface_WriteFailsafeProductionActivePowerLimit_Call

type UCLPPInterface_WriteProductionLimit_Call 

type UCLPPInterface_WriteProductionLimit_Call struct {
	*mock.Call
}

UCLPPInterface_WriteProductionLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteProductionLimit'

func (*UCLPPInterface_WriteProductionLimit_Call) Return 

func (_c *UCLPPInterface_WriteProductionLimit_Call) Return(_a0 *model.MsgCounterType, _a1 error) *UCLPPInterface_WriteProductionLimit_Call

func (*UCLPPInterface_WriteProductionLimit_Call) Run 

func (_c *UCLPPInterface_WriteProductionLimit_Call) Run(run func(entity api.EntityRemoteInterface, limit cemdapi.LoadLimit)) *UCLPPInterface_WriteProductionLimit_Call

func (*UCLPPInterface_WriteProductionLimit_Call) RunAndReturn 

func (_c *UCLPPInterface_WriteProductionLimit_Call) RunAndReturn(run func(api.EntityRemoteInterface, cemdapi.LoadLimit) (*model.MsgCounterType, error)) *UCLPPInterface_WriteProductionLimit_Call

type UCLPPServerInterface 

type UCLPPServerInterface struct {
	mock.Mock
}

UCLPPServerInterface is an autogenerated mock type for the UCLPPServerInterface type

func NewUCLPPServerInterface 

func NewUCLPPServerInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCLPPServerInterface

NewUCLPPServerInterface creates a new instance of UCLPPServerInterface. 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 (*UCLPPServerInterface) AddFeatures 

func (_m *UCLPPServerInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCLPPServerInterface) AddUseCase 

func (_m *UCLPPServerInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCLPPServerInterface) ContractualProductionNominalMax 

func (_m *UCLPPServerInterface) ContractualProductionNominalMax() (float64, error)

ContractualProductionNominalMax provides a mock function with given fields:

func (*UCLPPServerInterface) EXPECT 

func (_m *UCLPPServerInterface) EXPECT() *UCLPPServerInterface_Expecter

func (*UCLPPServerInterface) FailsafeDurationMinimum 

func (_m *UCLPPServerInterface) FailsafeDurationMinimum() (time.Duration, bool, error)

FailsafeDurationMinimum provides a mock function with given fields:

func (*UCLPPServerInterface) FailsafeProductionActivePowerLimit 

func (_m *UCLPPServerInterface) FailsafeProductionActivePowerLimit() (float64, bool, error)

FailsafeProductionActivePowerLimit provides a mock function with given fields:

func (*UCLPPServerInterface) IsUseCaseSupported 

func (_m *UCLPPServerInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCLPPServerInterface) ProductionLimit 

func (_m *UCLPPServerInterface) ProductionLimit() (cemdapi.LoadLimit, error)

ProductionLimit provides a mock function with given fields:

func (*UCLPPServerInterface) SetContractualProductionNominalMax 

func (_m *UCLPPServerInterface) SetContractualProductionNominalMax(value float64) error

SetContractualProductionNominalMax provides a mock function with given fields: value

func (*UCLPPServerInterface) SetFailsafeDurationMinimum 

func (_m *UCLPPServerInterface) SetFailsafeDurationMinimum(duration time.Duration, changeable bool) error

SetFailsafeDurationMinimum provides a mock function with given fields: duration, changeable

func (*UCLPPServerInterface) SetFailsafeProductionActivePowerLimit 

func (_m *UCLPPServerInterface) SetFailsafeProductionActivePowerLimit(value float64, changeable bool) error

SetFailsafeProductionActivePowerLimit provides a mock function with given fields: value, changeable

func (*UCLPPServerInterface) SetProductionLimit 

func (_m *UCLPPServerInterface) SetProductionLimit(limit cemdapi.LoadLimit) error

SetProductionLimit provides a mock function with given fields: limit

func (*UCLPPServerInterface) UpdateUseCaseAvailability 

func (_m *UCLPPServerInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCLPPServerInterface) UseCaseName 

func (_m *UCLPPServerInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

type UCLPPServerInterface_AddFeatures_Call 

type UCLPPServerInterface_AddFeatures_Call struct {
	*mock.Call
}

UCLPPServerInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCLPPServerInterface_AddFeatures_Call) Return 

func (_c *UCLPPServerInterface_AddFeatures_Call) Return() *UCLPPServerInterface_AddFeatures_Call

func (*UCLPPServerInterface_AddFeatures_Call) Run 

func (_c *UCLPPServerInterface_AddFeatures_Call) Run(run func()) *UCLPPServerInterface_AddFeatures_Call

func (*UCLPPServerInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCLPPServerInterface_AddFeatures_Call) RunAndReturn(run func()) *UCLPPServerInterface_AddFeatures_Call

type UCLPPServerInterface_AddUseCase_Call 

type UCLPPServerInterface_AddUseCase_Call struct {
	*mock.Call
}

UCLPPServerInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCLPPServerInterface_AddUseCase_Call) Return 

func (_c *UCLPPServerInterface_AddUseCase_Call) Return() *UCLPPServerInterface_AddUseCase_Call

func (*UCLPPServerInterface_AddUseCase_Call) Run 

func (_c *UCLPPServerInterface_AddUseCase_Call) Run(run func()) *UCLPPServerInterface_AddUseCase_Call

func (*UCLPPServerInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCLPPServerInterface_AddUseCase_Call) RunAndReturn(run func()) *UCLPPServerInterface_AddUseCase_Call

type UCLPPServerInterface_ContractualProductionNominalMax_Call 

type UCLPPServerInterface_ContractualProductionNominalMax_Call struct {
	*mock.Call
}

UCLPPServerInterface_ContractualProductionNominalMax_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ContractualProductionNominalMax'

func (*UCLPPServerInterface_ContractualProductionNominalMax_Call) Return 

func (_c *UCLPPServerInterface_ContractualProductionNominalMax_Call) Return(_a0 float64, _a1 error) *UCLPPServerInterface_ContractualProductionNominalMax_Call

func (*UCLPPServerInterface_ContractualProductionNominalMax_Call) Run 

func (_c *UCLPPServerInterface_ContractualProductionNominalMax_Call) Run(run func()) *UCLPPServerInterface_ContractualProductionNominalMax_Call

func (*UCLPPServerInterface_ContractualProductionNominalMax_Call) RunAndReturn 

func (_c *UCLPPServerInterface_ContractualProductionNominalMax_Call) RunAndReturn(run func() (float64, error)) *UCLPPServerInterface_ContractualProductionNominalMax_Call

type UCLPPServerInterface_Expecter 

type UCLPPServerInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCLPPServerInterface_Expecter) AddFeatures 

func (_e *UCLPPServerInterface_Expecter) AddFeatures() *UCLPPServerInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCLPPServerInterface_Expecter) AddUseCase 

func (_e *UCLPPServerInterface_Expecter) AddUseCase() *UCLPPServerInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCLPPServerInterface_Expecter) ContractualProductionNominalMax 

func (_e *UCLPPServerInterface_Expecter) ContractualProductionNominalMax() *UCLPPServerInterface_ContractualProductionNominalMax_Call

ContractualProductionNominalMax is a helper method to define mock.On call

func (*UCLPPServerInterface_Expecter) FailsafeDurationMinimum 

func (_e *UCLPPServerInterface_Expecter) FailsafeDurationMinimum() *UCLPPServerInterface_FailsafeDurationMinimum_Call

FailsafeDurationMinimum is a helper method to define mock.On call

func (*UCLPPServerInterface_Expecter) FailsafeProductionActivePowerLimit 

func (_e *UCLPPServerInterface_Expecter) FailsafeProductionActivePowerLimit() *UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call

FailsafeProductionActivePowerLimit is a helper method to define mock.On call

func (*UCLPPServerInterface_Expecter) IsUseCaseSupported 

func (_e *UCLPPServerInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCLPPServerInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCLPPServerInterface_Expecter) ProductionLimit 

func (_e *UCLPPServerInterface_Expecter) ProductionLimit() *UCLPPServerInterface_ProductionLimit_Call

ProductionLimit is a helper method to define mock.On call

func (*UCLPPServerInterface_Expecter) SetContractualProductionNominalMax 

func (_e *UCLPPServerInterface_Expecter) SetContractualProductionNominalMax(value interface{}) *UCLPPServerInterface_SetContractualProductionNominalMax_Call

SetContractualProductionNominalMax is a helper method to define mock.On call

  • value float64

func (*UCLPPServerInterface_Expecter) SetFailsafeDurationMinimum 

func (_e *UCLPPServerInterface_Expecter) SetFailsafeDurationMinimum(duration interface{}, changeable interface{}) *UCLPPServerInterface_SetFailsafeDurationMinimum_Call

SetFailsafeDurationMinimum is a helper method to define mock.On call

  • duration time.Duration
  • changeable bool

func (*UCLPPServerInterface_Expecter) SetFailsafeProductionActivePowerLimit 

func (_e *UCLPPServerInterface_Expecter) SetFailsafeProductionActivePowerLimit(value interface{}, changeable interface{}) *UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call

SetFailsafeProductionActivePowerLimit is a helper method to define mock.On call

  • value float64
  • changeable bool

func (*UCLPPServerInterface_Expecter) SetProductionLimit 

func (_e *UCLPPServerInterface_Expecter) SetProductionLimit(limit interface{}) *UCLPPServerInterface_SetProductionLimit_Call

SetProductionLimit is a helper method to define mock.On call

  • limit cemdapi.LoadLimit

func (*UCLPPServerInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCLPPServerInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCLPPServerInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCLPPServerInterface_Expecter) UseCaseName 

func (_e *UCLPPServerInterface_Expecter) UseCaseName() *UCLPPServerInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

type UCLPPServerInterface_FailsafeDurationMinimum_Call 

type UCLPPServerInterface_FailsafeDurationMinimum_Call struct {
	*mock.Call
}

UCLPPServerInterface_FailsafeDurationMinimum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FailsafeDurationMinimum'

func (*UCLPPServerInterface_FailsafeDurationMinimum_Call) Return 

func (_c *UCLPPServerInterface_FailsafeDurationMinimum_Call) Return(duration time.Duration, isChangeable bool, resultErr error) *UCLPPServerInterface_FailsafeDurationMinimum_Call

func (*UCLPPServerInterface_FailsafeDurationMinimum_Call) Run 

func (_c *UCLPPServerInterface_FailsafeDurationMinimum_Call) Run(run func()) *UCLPPServerInterface_FailsafeDurationMinimum_Call

func (*UCLPPServerInterface_FailsafeDurationMinimum_Call) RunAndReturn 

func (_c *UCLPPServerInterface_FailsafeDurationMinimum_Call) RunAndReturn(run func() (time.Duration, bool, error)) *UCLPPServerInterface_FailsafeDurationMinimum_Call

type UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call 

type UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call struct {
	*mock.Call
}

UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'FailsafeProductionActivePowerLimit'

func (*UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call) Return 

func (_c *UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call) Return(value float64, isChangeable bool, resultErr error) *UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call

func (*UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call) Run 

func (_c *UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call) Run(run func()) *UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call

func (*UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call) RunAndReturn 

func (_c *UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call) RunAndReturn(run func() (float64, bool, error)) *UCLPPServerInterface_FailsafeProductionActivePowerLimit_Call

type UCLPPServerInterface_IsUseCaseSupported_Call 

type UCLPPServerInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCLPPServerInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCLPPServerInterface_IsUseCaseSupported_Call) Return 

func (_c *UCLPPServerInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCLPPServerInterface_IsUseCaseSupported_Call

func (*UCLPPServerInterface_IsUseCaseSupported_Call) Run 

func (_c *UCLPPServerInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCLPPServerInterface_IsUseCaseSupported_Call

func (*UCLPPServerInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCLPPServerInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCLPPServerInterface_IsUseCaseSupported_Call

type UCLPPServerInterface_ProductionLimit_Call 

type UCLPPServerInterface_ProductionLimit_Call struct {
	*mock.Call
}

UCLPPServerInterface_ProductionLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'ProductionLimit'

func (*UCLPPServerInterface_ProductionLimit_Call) Return 

func (_c *UCLPPServerInterface_ProductionLimit_Call) Return(_a0 cemdapi.LoadLimit, _a1 error) *UCLPPServerInterface_ProductionLimit_Call

func (*UCLPPServerInterface_ProductionLimit_Call) Run 

func (_c *UCLPPServerInterface_ProductionLimit_Call) Run(run func()) *UCLPPServerInterface_ProductionLimit_Call

func (*UCLPPServerInterface_ProductionLimit_Call) RunAndReturn 

func (_c *UCLPPServerInterface_ProductionLimit_Call) RunAndReturn(run func() (cemdapi.LoadLimit, error)) *UCLPPServerInterface_ProductionLimit_Call

type UCLPPServerInterface_SetContractualProductionNominalMax_Call 

type UCLPPServerInterface_SetContractualProductionNominalMax_Call struct {
	*mock.Call
}

UCLPPServerInterface_SetContractualProductionNominalMax_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetContractualProductionNominalMax'

func (*UCLPPServerInterface_SetContractualProductionNominalMax_Call) Return 

func (_c *UCLPPServerInterface_SetContractualProductionNominalMax_Call) Return(resultErr error) *UCLPPServerInterface_SetContractualProductionNominalMax_Call

func (*UCLPPServerInterface_SetContractualProductionNominalMax_Call) Run 

func (_c *UCLPPServerInterface_SetContractualProductionNominalMax_Call) Run(run func(value float64)) *UCLPPServerInterface_SetContractualProductionNominalMax_Call

func (*UCLPPServerInterface_SetContractualProductionNominalMax_Call) RunAndReturn 

func (_c *UCLPPServerInterface_SetContractualProductionNominalMax_Call) RunAndReturn(run func(float64) error) *UCLPPServerInterface_SetContractualProductionNominalMax_Call

type UCLPPServerInterface_SetFailsafeDurationMinimum_Call 

type UCLPPServerInterface_SetFailsafeDurationMinimum_Call struct {
	*mock.Call
}

UCLPPServerInterface_SetFailsafeDurationMinimum_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFailsafeDurationMinimum'

func (*UCLPPServerInterface_SetFailsafeDurationMinimum_Call) Return 

func (_c *UCLPPServerInterface_SetFailsafeDurationMinimum_Call) Return(resultErr error) *UCLPPServerInterface_SetFailsafeDurationMinimum_Call

func (*UCLPPServerInterface_SetFailsafeDurationMinimum_Call) Run 

func (_c *UCLPPServerInterface_SetFailsafeDurationMinimum_Call) Run(run func(duration time.Duration, changeable bool)) *UCLPPServerInterface_SetFailsafeDurationMinimum_Call

func (*UCLPPServerInterface_SetFailsafeDurationMinimum_Call) RunAndReturn 

func (_c *UCLPPServerInterface_SetFailsafeDurationMinimum_Call) RunAndReturn(run func(time.Duration, bool) error) *UCLPPServerInterface_SetFailsafeDurationMinimum_Call

type UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call 

type UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call struct {
	*mock.Call
}

UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetFailsafeProductionActivePowerLimit'

func (*UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call) Return 

func (_c *UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call) Return(resultErr error) *UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call

func (*UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call) Run 

func (_c *UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call) Run(run func(value float64, changeable bool)) *UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call

func (*UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call) RunAndReturn 

func (_c *UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call) RunAndReturn(run func(float64, bool) error) *UCLPPServerInterface_SetFailsafeProductionActivePowerLimit_Call

type UCLPPServerInterface_SetProductionLimit_Call 

type UCLPPServerInterface_SetProductionLimit_Call struct {
	*mock.Call
}

UCLPPServerInterface_SetProductionLimit_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'SetProductionLimit'

func (*UCLPPServerInterface_SetProductionLimit_Call) Return 

func (_c *UCLPPServerInterface_SetProductionLimit_Call) Return(resultErr error) *UCLPPServerInterface_SetProductionLimit_Call

func (*UCLPPServerInterface_SetProductionLimit_Call) Run 

func (_c *UCLPPServerInterface_SetProductionLimit_Call) Run(run func(limit cemdapi.LoadLimit)) *UCLPPServerInterface_SetProductionLimit_Call

func (*UCLPPServerInterface_SetProductionLimit_Call) RunAndReturn 

func (_c *UCLPPServerInterface_SetProductionLimit_Call) RunAndReturn(run func(cemdapi.LoadLimit) error) *UCLPPServerInterface_SetProductionLimit_Call

type UCLPPServerInterface_UpdateUseCaseAvailability_Call 

type UCLPPServerInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCLPPServerInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCLPPServerInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCLPPServerInterface_UpdateUseCaseAvailability_Call) Return() *UCLPPServerInterface_UpdateUseCaseAvailability_Call

func (*UCLPPServerInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCLPPServerInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCLPPServerInterface_UpdateUseCaseAvailability_Call

func (*UCLPPServerInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCLPPServerInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCLPPServerInterface_UpdateUseCaseAvailability_Call

type UCLPPServerInterface_UseCaseName_Call 

type UCLPPServerInterface_UseCaseName_Call struct {
	*mock.Call
}

UCLPPServerInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCLPPServerInterface_UseCaseName_Call) Return 

func (_c *UCLPPServerInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCLPPServerInterface_UseCaseName_Call

func (*UCLPPServerInterface_UseCaseName_Call) Run 

func (_c *UCLPPServerInterface_UseCaseName_Call) Run(run func()) *UCLPPServerInterface_UseCaseName_Call

func (*UCLPPServerInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCLPPServerInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCLPPServerInterface_UseCaseName_Call

type UCMCPInterface 

type UCMCPInterface struct {
	mock.Mock
}

UCMCPInterface is an autogenerated mock type for the UCMCPInterface type

func NewUCMCPInterface 

func NewUCMCPInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCMCPInterface

NewUCMCPInterface creates a new instance of UCMCPInterface. 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 (*UCMCPInterface) AddFeatures 

func (_m *UCMCPInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCMCPInterface) AddUseCase 

func (_m *UCMCPInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCMCPInterface) CurrentPerPhase 

func (_m *UCMCPInterface) CurrentPerPhase(entity api.EntityRemoteInterface) ([]float64, error)

CurrentPerPhase provides a mock function with given fields: entity

func (*UCMCPInterface) EXPECT 

func (_m *UCMCPInterface) EXPECT() *UCMCPInterface_Expecter

func (*UCMCPInterface) EnergyConsumed 

func (_m *UCMCPInterface) EnergyConsumed(entity api.EntityRemoteInterface) (float64, error)

EnergyConsumed provides a mock function with given fields: entity

func (*UCMCPInterface) EnergyProduced 

func (_m *UCMCPInterface) EnergyProduced(entity api.EntityRemoteInterface) (float64, error)

EnergyProduced provides a mock function with given fields: entity

func (*UCMCPInterface) Frequency 

func (_m *UCMCPInterface) Frequency(entity api.EntityRemoteInterface) (float64, error)

Frequency provides a mock function with given fields: entity

func (*UCMCPInterface) IsUseCaseSupported 

func (_m *UCMCPInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCMCPInterface) Power 

func (_m *UCMCPInterface) Power(entity api.EntityRemoteInterface) (float64, error)

Power provides a mock function with given fields: entity

func (*UCMCPInterface) PowerPerPhase 

func (_m *UCMCPInterface) PowerPerPhase(entity api.EntityRemoteInterface) ([]float64, error)

PowerPerPhase provides a mock function with given fields: entity

func (*UCMCPInterface) UpdateUseCaseAvailability 

func (_m *UCMCPInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCMCPInterface) UseCaseName 

func (_m *UCMCPInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

func (*UCMCPInterface) VoltagePerPhase 

func (_m *UCMCPInterface) VoltagePerPhase(entity api.EntityRemoteInterface) ([]float64, error)

VoltagePerPhase provides a mock function with given fields: entity

type UCMCPInterface_AddFeatures_Call 

type UCMCPInterface_AddFeatures_Call struct {
	*mock.Call
}

UCMCPInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCMCPInterface_AddFeatures_Call) Return 

func (_c *UCMCPInterface_AddFeatures_Call) Return() *UCMCPInterface_AddFeatures_Call

func (*UCMCPInterface_AddFeatures_Call) Run 

func (_c *UCMCPInterface_AddFeatures_Call) Run(run func()) *UCMCPInterface_AddFeatures_Call

func (*UCMCPInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCMCPInterface_AddFeatures_Call) RunAndReturn(run func()) *UCMCPInterface_AddFeatures_Call

type UCMCPInterface_AddUseCase_Call 

type UCMCPInterface_AddUseCase_Call struct {
	*mock.Call
}

UCMCPInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCMCPInterface_AddUseCase_Call) Return 

func (_c *UCMCPInterface_AddUseCase_Call) Return() *UCMCPInterface_AddUseCase_Call

func (*UCMCPInterface_AddUseCase_Call) Run 

func (_c *UCMCPInterface_AddUseCase_Call) Run(run func()) *UCMCPInterface_AddUseCase_Call

func (*UCMCPInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCMCPInterface_AddUseCase_Call) RunAndReturn(run func()) *UCMCPInterface_AddUseCase_Call

type UCMCPInterface_CurrentPerPhase_Call 

type UCMCPInterface_CurrentPerPhase_Call struct {
	*mock.Call
}

UCMCPInterface_CurrentPerPhase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurrentPerPhase'

func (*UCMCPInterface_CurrentPerPhase_Call) Return 

func (_c *UCMCPInterface_CurrentPerPhase_Call) Return(_a0 []float64, _a1 error) *UCMCPInterface_CurrentPerPhase_Call

func (*UCMCPInterface_CurrentPerPhase_Call) Run 

func (_c *UCMCPInterface_CurrentPerPhase_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMCPInterface_CurrentPerPhase_Call

func (*UCMCPInterface_CurrentPerPhase_Call) RunAndReturn 

func (_c *UCMCPInterface_CurrentPerPhase_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]float64, error)) *UCMCPInterface_CurrentPerPhase_Call

type UCMCPInterface_EnergyConsumed_Call 

type UCMCPInterface_EnergyConsumed_Call struct {
	*mock.Call
}

UCMCPInterface_EnergyConsumed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnergyConsumed'

func (*UCMCPInterface_EnergyConsumed_Call) Return 

func (_c *UCMCPInterface_EnergyConsumed_Call) Return(_a0 float64, _a1 error) *UCMCPInterface_EnergyConsumed_Call

func (*UCMCPInterface_EnergyConsumed_Call) Run 

func (_c *UCMCPInterface_EnergyConsumed_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMCPInterface_EnergyConsumed_Call

func (*UCMCPInterface_EnergyConsumed_Call) RunAndReturn 

func (_c *UCMCPInterface_EnergyConsumed_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCMCPInterface_EnergyConsumed_Call

type UCMCPInterface_EnergyProduced_Call 

type UCMCPInterface_EnergyProduced_Call struct {
	*mock.Call
}

UCMCPInterface_EnergyProduced_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnergyProduced'

func (*UCMCPInterface_EnergyProduced_Call) Return 

func (_c *UCMCPInterface_EnergyProduced_Call) Return(_a0 float64, _a1 error) *UCMCPInterface_EnergyProduced_Call

func (*UCMCPInterface_EnergyProduced_Call) Run 

func (_c *UCMCPInterface_EnergyProduced_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMCPInterface_EnergyProduced_Call

func (*UCMCPInterface_EnergyProduced_Call) RunAndReturn 

func (_c *UCMCPInterface_EnergyProduced_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCMCPInterface_EnergyProduced_Call

type UCMCPInterface_Expecter 

type UCMCPInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCMCPInterface_Expecter) AddFeatures 

func (_e *UCMCPInterface_Expecter) AddFeatures() *UCMCPInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCMCPInterface_Expecter) AddUseCase 

func (_e *UCMCPInterface_Expecter) AddUseCase() *UCMCPInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCMCPInterface_Expecter) CurrentPerPhase 

func (_e *UCMCPInterface_Expecter) CurrentPerPhase(entity interface{}) *UCMCPInterface_CurrentPerPhase_Call

CurrentPerPhase is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCMCPInterface_Expecter) EnergyConsumed 

func (_e *UCMCPInterface_Expecter) EnergyConsumed(entity interface{}) *UCMCPInterface_EnergyConsumed_Call

EnergyConsumed is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCMCPInterface_Expecter) EnergyProduced 

func (_e *UCMCPInterface_Expecter) EnergyProduced(entity interface{}) *UCMCPInterface_EnergyProduced_Call

EnergyProduced is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCMCPInterface_Expecter) Frequency 

func (_e *UCMCPInterface_Expecter) Frequency(entity interface{}) *UCMCPInterface_Frequency_Call

Frequency is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCMCPInterface_Expecter) IsUseCaseSupported 

func (_e *UCMCPInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCMCPInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCMCPInterface_Expecter) Power 

func (_e *UCMCPInterface_Expecter) Power(entity interface{}) *UCMCPInterface_Power_Call

Power is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCMCPInterface_Expecter) PowerPerPhase 

func (_e *UCMCPInterface_Expecter) PowerPerPhase(entity interface{}) *UCMCPInterface_PowerPerPhase_Call

PowerPerPhase is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCMCPInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCMCPInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCMCPInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCMCPInterface_Expecter) UseCaseName 

func (_e *UCMCPInterface_Expecter) UseCaseName() *UCMCPInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

func (*UCMCPInterface_Expecter) VoltagePerPhase 

func (_e *UCMCPInterface_Expecter) VoltagePerPhase(entity interface{}) *UCMCPInterface_VoltagePerPhase_Call

VoltagePerPhase is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

type UCMCPInterface_Frequency_Call 

type UCMCPInterface_Frequency_Call struct {
	*mock.Call
}

UCMCPInterface_Frequency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Frequency'

func (*UCMCPInterface_Frequency_Call) Return 

func (_c *UCMCPInterface_Frequency_Call) Return(_a0 float64, _a1 error) *UCMCPInterface_Frequency_Call

func (*UCMCPInterface_Frequency_Call) Run 

func (_c *UCMCPInterface_Frequency_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMCPInterface_Frequency_Call

func (*UCMCPInterface_Frequency_Call) RunAndReturn 

func (_c *UCMCPInterface_Frequency_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCMCPInterface_Frequency_Call

type UCMCPInterface_IsUseCaseSupported_Call 

type UCMCPInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCMCPInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCMCPInterface_IsUseCaseSupported_Call) Return 

func (_c *UCMCPInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCMCPInterface_IsUseCaseSupported_Call

func (*UCMCPInterface_IsUseCaseSupported_Call) Run 

func (_c *UCMCPInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCMCPInterface_IsUseCaseSupported_Call

func (*UCMCPInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCMCPInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCMCPInterface_IsUseCaseSupported_Call

type UCMCPInterface_PowerPerPhase_Call 

type UCMCPInterface_PowerPerPhase_Call struct {
	*mock.Call
}

UCMCPInterface_PowerPerPhase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PowerPerPhase'

func (*UCMCPInterface_PowerPerPhase_Call) Return 

func (_c *UCMCPInterface_PowerPerPhase_Call) Return(_a0 []float64, _a1 error) *UCMCPInterface_PowerPerPhase_Call

func (*UCMCPInterface_PowerPerPhase_Call) Run 

func (_c *UCMCPInterface_PowerPerPhase_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMCPInterface_PowerPerPhase_Call

func (*UCMCPInterface_PowerPerPhase_Call) RunAndReturn 

func (_c *UCMCPInterface_PowerPerPhase_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]float64, error)) *UCMCPInterface_PowerPerPhase_Call

type UCMCPInterface_Power_Call 

type UCMCPInterface_Power_Call struct {
	*mock.Call
}

UCMCPInterface_Power_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Power'

func (*UCMCPInterface_Power_Call) Return 

func (_c *UCMCPInterface_Power_Call) Return(_a0 float64, _a1 error) *UCMCPInterface_Power_Call

func (*UCMCPInterface_Power_Call) Run 

func (_c *UCMCPInterface_Power_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMCPInterface_Power_Call

func (*UCMCPInterface_Power_Call) RunAndReturn 

func (_c *UCMCPInterface_Power_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCMCPInterface_Power_Call

type UCMCPInterface_UpdateUseCaseAvailability_Call 

type UCMCPInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCMCPInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCMCPInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCMCPInterface_UpdateUseCaseAvailability_Call) Return() *UCMCPInterface_UpdateUseCaseAvailability_Call

func (*UCMCPInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCMCPInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCMCPInterface_UpdateUseCaseAvailability_Call

func (*UCMCPInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCMCPInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCMCPInterface_UpdateUseCaseAvailability_Call

type UCMCPInterface_UseCaseName_Call 

type UCMCPInterface_UseCaseName_Call struct {
	*mock.Call
}

UCMCPInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCMCPInterface_UseCaseName_Call) Return 

func (_c *UCMCPInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCMCPInterface_UseCaseName_Call

func (*UCMCPInterface_UseCaseName_Call) Run 

func (_c *UCMCPInterface_UseCaseName_Call) Run(run func()) *UCMCPInterface_UseCaseName_Call

func (*UCMCPInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCMCPInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCMCPInterface_UseCaseName_Call

type UCMCPInterface_VoltagePerPhase_Call 

type UCMCPInterface_VoltagePerPhase_Call struct {
	*mock.Call
}

UCMCPInterface_VoltagePerPhase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VoltagePerPhase'

func (*UCMCPInterface_VoltagePerPhase_Call) Return 

func (_c *UCMCPInterface_VoltagePerPhase_Call) Return(_a0 []float64, _a1 error) *UCMCPInterface_VoltagePerPhase_Call

func (*UCMCPInterface_VoltagePerPhase_Call) Run 

func (_c *UCMCPInterface_VoltagePerPhase_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMCPInterface_VoltagePerPhase_Call

func (*UCMCPInterface_VoltagePerPhase_Call) RunAndReturn 

func (_c *UCMCPInterface_VoltagePerPhase_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]float64, error)) *UCMCPInterface_VoltagePerPhase_Call

type UCMGCPInterface 

type UCMGCPInterface struct {
	mock.Mock
}

UCMGCPInterface is an autogenerated mock type for the UCMGCPInterface type

func NewUCMGCPInterface 

func NewUCMGCPInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCMGCPInterface

NewUCMGCPInterface creates a new instance of UCMGCPInterface. 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 (*UCMGCPInterface) AddFeatures 

func (_m *UCMGCPInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCMGCPInterface) AddUseCase 

func (_m *UCMGCPInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCMGCPInterface) CurrentPerPhase 

func (_m *UCMGCPInterface) CurrentPerPhase(entity api.EntityRemoteInterface) ([]float64, error)

CurrentPerPhase provides a mock function with given fields: entity

func (*UCMGCPInterface) EXPECT 

func (_m *UCMGCPInterface) EXPECT() *UCMGCPInterface_Expecter

func (*UCMGCPInterface) EnergyConsumed 

func (_m *UCMGCPInterface) EnergyConsumed(entity api.EntityRemoteInterface) (float64, error)

EnergyConsumed provides a mock function with given fields: entity

func (*UCMGCPInterface) EnergyFeedIn 

func (_m *UCMGCPInterface) EnergyFeedIn(entity api.EntityRemoteInterface) (float64, error)

EnergyFeedIn provides a mock function with given fields: entity

func (*UCMGCPInterface) Frequency 

func (_m *UCMGCPInterface) Frequency(entity api.EntityRemoteInterface) (float64, error)

Frequency provides a mock function with given fields: entity

func (*UCMGCPInterface) IsUseCaseSupported 

func (_m *UCMGCPInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCMGCPInterface) Power 

func (_m *UCMGCPInterface) Power(entity api.EntityRemoteInterface) (float64, error)

Power provides a mock function with given fields: entity

func (*UCMGCPInterface) PowerLimitationFactor 

func (_m *UCMGCPInterface) PowerLimitationFactor(entity api.EntityRemoteInterface) (float64, error)

PowerLimitationFactor provides a mock function with given fields: entity

func (*UCMGCPInterface) UpdateUseCaseAvailability 

func (_m *UCMGCPInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCMGCPInterface) UseCaseName 

func (_m *UCMGCPInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

func (*UCMGCPInterface) VoltagePerPhase 

func (_m *UCMGCPInterface) VoltagePerPhase(entity api.EntityRemoteInterface) ([]float64, error)

VoltagePerPhase provides a mock function with given fields: entity

type UCMGCPInterface_AddFeatures_Call 

type UCMGCPInterface_AddFeatures_Call struct {
	*mock.Call
}

UCMGCPInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCMGCPInterface_AddFeatures_Call) Return 

func (_c *UCMGCPInterface_AddFeatures_Call) Return() *UCMGCPInterface_AddFeatures_Call

func (*UCMGCPInterface_AddFeatures_Call) Run 

func (_c *UCMGCPInterface_AddFeatures_Call) Run(run func()) *UCMGCPInterface_AddFeatures_Call

func (*UCMGCPInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCMGCPInterface_AddFeatures_Call) RunAndReturn(run func()) *UCMGCPInterface_AddFeatures_Call

type UCMGCPInterface_AddUseCase_Call 

type UCMGCPInterface_AddUseCase_Call struct {
	*mock.Call
}

UCMGCPInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCMGCPInterface_AddUseCase_Call) Return 

func (_c *UCMGCPInterface_AddUseCase_Call) Return() *UCMGCPInterface_AddUseCase_Call

func (*UCMGCPInterface_AddUseCase_Call) Run 

func (_c *UCMGCPInterface_AddUseCase_Call) Run(run func()) *UCMGCPInterface_AddUseCase_Call

func (*UCMGCPInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCMGCPInterface_AddUseCase_Call) RunAndReturn(run func()) *UCMGCPInterface_AddUseCase_Call

type UCMGCPInterface_CurrentPerPhase_Call 

type UCMGCPInterface_CurrentPerPhase_Call struct {
	*mock.Call
}

UCMGCPInterface_CurrentPerPhase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurrentPerPhase'

func (*UCMGCPInterface_CurrentPerPhase_Call) Return 

func (_c *UCMGCPInterface_CurrentPerPhase_Call) Return(_a0 []float64, _a1 error) *UCMGCPInterface_CurrentPerPhase_Call

func (*UCMGCPInterface_CurrentPerPhase_Call) Run 

func (_c *UCMGCPInterface_CurrentPerPhase_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMGCPInterface_CurrentPerPhase_Call

func (*UCMGCPInterface_CurrentPerPhase_Call) RunAndReturn 

func (_c *UCMGCPInterface_CurrentPerPhase_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]float64, error)) *UCMGCPInterface_CurrentPerPhase_Call

type UCMGCPInterface_EnergyConsumed_Call 

type UCMGCPInterface_EnergyConsumed_Call struct {
	*mock.Call
}

UCMGCPInterface_EnergyConsumed_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnergyConsumed'

func (*UCMGCPInterface_EnergyConsumed_Call) Return 

func (_c *UCMGCPInterface_EnergyConsumed_Call) Return(_a0 float64, _a1 error) *UCMGCPInterface_EnergyConsumed_Call

func (*UCMGCPInterface_EnergyConsumed_Call) Run 

func (_c *UCMGCPInterface_EnergyConsumed_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMGCPInterface_EnergyConsumed_Call

func (*UCMGCPInterface_EnergyConsumed_Call) RunAndReturn 

func (_c *UCMGCPInterface_EnergyConsumed_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCMGCPInterface_EnergyConsumed_Call

type UCMGCPInterface_EnergyFeedIn_Call 

type UCMGCPInterface_EnergyFeedIn_Call struct {
	*mock.Call
}

UCMGCPInterface_EnergyFeedIn_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnergyFeedIn'

func (*UCMGCPInterface_EnergyFeedIn_Call) Return 

func (_c *UCMGCPInterface_EnergyFeedIn_Call) Return(_a0 float64, _a1 error) *UCMGCPInterface_EnergyFeedIn_Call

func (*UCMGCPInterface_EnergyFeedIn_Call) Run 

func (_c *UCMGCPInterface_EnergyFeedIn_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMGCPInterface_EnergyFeedIn_Call

func (*UCMGCPInterface_EnergyFeedIn_Call) RunAndReturn 

func (_c *UCMGCPInterface_EnergyFeedIn_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCMGCPInterface_EnergyFeedIn_Call

type UCMGCPInterface_Expecter 

type UCMGCPInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCMGCPInterface_Expecter) AddFeatures 

func (_e *UCMGCPInterface_Expecter) AddFeatures() *UCMGCPInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCMGCPInterface_Expecter) AddUseCase 

func (_e *UCMGCPInterface_Expecter) AddUseCase() *UCMGCPInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCMGCPInterface_Expecter) CurrentPerPhase 

func (_e *UCMGCPInterface_Expecter) CurrentPerPhase(entity interface{}) *UCMGCPInterface_CurrentPerPhase_Call

CurrentPerPhase is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCMGCPInterface_Expecter) EnergyConsumed 

func (_e *UCMGCPInterface_Expecter) EnergyConsumed(entity interface{}) *UCMGCPInterface_EnergyConsumed_Call

EnergyConsumed is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCMGCPInterface_Expecter) EnergyFeedIn 

func (_e *UCMGCPInterface_Expecter) EnergyFeedIn(entity interface{}) *UCMGCPInterface_EnergyFeedIn_Call

EnergyFeedIn is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCMGCPInterface_Expecter) Frequency 

func (_e *UCMGCPInterface_Expecter) Frequency(entity interface{}) *UCMGCPInterface_Frequency_Call

Frequency is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCMGCPInterface_Expecter) IsUseCaseSupported 

func (_e *UCMGCPInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCMGCPInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCMGCPInterface_Expecter) Power 

func (_e *UCMGCPInterface_Expecter) Power(entity interface{}) *UCMGCPInterface_Power_Call

Power is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCMGCPInterface_Expecter) PowerLimitationFactor 

func (_e *UCMGCPInterface_Expecter) PowerLimitationFactor(entity interface{}) *UCMGCPInterface_PowerLimitationFactor_Call

PowerLimitationFactor is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCMGCPInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCMGCPInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCMGCPInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCMGCPInterface_Expecter) UseCaseName 

func (_e *UCMGCPInterface_Expecter) UseCaseName() *UCMGCPInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

func (*UCMGCPInterface_Expecter) VoltagePerPhase 

func (_e *UCMGCPInterface_Expecter) VoltagePerPhase(entity interface{}) *UCMGCPInterface_VoltagePerPhase_Call

VoltagePerPhase is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

type UCMGCPInterface_Frequency_Call 

type UCMGCPInterface_Frequency_Call struct {
	*mock.Call
}

UCMGCPInterface_Frequency_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Frequency'

func (*UCMGCPInterface_Frequency_Call) Return 

func (_c *UCMGCPInterface_Frequency_Call) Return(_a0 float64, _a1 error) *UCMGCPInterface_Frequency_Call

func (*UCMGCPInterface_Frequency_Call) Run 

func (_c *UCMGCPInterface_Frequency_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMGCPInterface_Frequency_Call

func (*UCMGCPInterface_Frequency_Call) RunAndReturn 

func (_c *UCMGCPInterface_Frequency_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCMGCPInterface_Frequency_Call

type UCMGCPInterface_IsUseCaseSupported_Call 

type UCMGCPInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCMGCPInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCMGCPInterface_IsUseCaseSupported_Call) Return 

func (_c *UCMGCPInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCMGCPInterface_IsUseCaseSupported_Call

func (*UCMGCPInterface_IsUseCaseSupported_Call) Run 

func (_c *UCMGCPInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCMGCPInterface_IsUseCaseSupported_Call

func (*UCMGCPInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCMGCPInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCMGCPInterface_IsUseCaseSupported_Call

type UCMGCPInterface_PowerLimitationFactor_Call 

type UCMGCPInterface_PowerLimitationFactor_Call struct {
	*mock.Call
}

UCMGCPInterface_PowerLimitationFactor_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PowerLimitationFactor'

func (*UCMGCPInterface_PowerLimitationFactor_Call) Return 

func (_c *UCMGCPInterface_PowerLimitationFactor_Call) Return(_a0 float64, _a1 error) *UCMGCPInterface_PowerLimitationFactor_Call

func (*UCMGCPInterface_PowerLimitationFactor_Call) Run 

func (_c *UCMGCPInterface_PowerLimitationFactor_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMGCPInterface_PowerLimitationFactor_Call

func (*UCMGCPInterface_PowerLimitationFactor_Call) RunAndReturn 

func (_c *UCMGCPInterface_PowerLimitationFactor_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCMGCPInterface_PowerLimitationFactor_Call

type UCMGCPInterface_Power_Call 

type UCMGCPInterface_Power_Call struct {
	*mock.Call
}

UCMGCPInterface_Power_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Power'

func (*UCMGCPInterface_Power_Call) Return 

func (_c *UCMGCPInterface_Power_Call) Return(_a0 float64, _a1 error) *UCMGCPInterface_Power_Call

func (*UCMGCPInterface_Power_Call) Run 

func (_c *UCMGCPInterface_Power_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMGCPInterface_Power_Call

func (*UCMGCPInterface_Power_Call) RunAndReturn 

func (_c *UCMGCPInterface_Power_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCMGCPInterface_Power_Call

type UCMGCPInterface_UpdateUseCaseAvailability_Call 

type UCMGCPInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCMGCPInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCMGCPInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCMGCPInterface_UpdateUseCaseAvailability_Call) Return() *UCMGCPInterface_UpdateUseCaseAvailability_Call

func (*UCMGCPInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCMGCPInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCMGCPInterface_UpdateUseCaseAvailability_Call

func (*UCMGCPInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCMGCPInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCMGCPInterface_UpdateUseCaseAvailability_Call

type UCMGCPInterface_UseCaseName_Call 

type UCMGCPInterface_UseCaseName_Call struct {
	*mock.Call
}

UCMGCPInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCMGCPInterface_UseCaseName_Call) Return 

func (_c *UCMGCPInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCMGCPInterface_UseCaseName_Call

func (*UCMGCPInterface_UseCaseName_Call) Run 

func (_c *UCMGCPInterface_UseCaseName_Call) Run(run func()) *UCMGCPInterface_UseCaseName_Call

func (*UCMGCPInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCMGCPInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCMGCPInterface_UseCaseName_Call

type UCMGCPInterface_VoltagePerPhase_Call 

type UCMGCPInterface_VoltagePerPhase_Call struct {
	*mock.Call
}

UCMGCPInterface_VoltagePerPhase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'VoltagePerPhase'

func (*UCMGCPInterface_VoltagePerPhase_Call) Return 

func (_c *UCMGCPInterface_VoltagePerPhase_Call) Return(_a0 []float64, _a1 error) *UCMGCPInterface_VoltagePerPhase_Call

func (*UCMGCPInterface_VoltagePerPhase_Call) Run 

func (_c *UCMGCPInterface_VoltagePerPhase_Call) Run(run func(entity api.EntityRemoteInterface)) *UCMGCPInterface_VoltagePerPhase_Call

func (*UCMGCPInterface_VoltagePerPhase_Call) RunAndReturn 

func (_c *UCMGCPInterface_VoltagePerPhase_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]float64, error)) *UCMGCPInterface_VoltagePerPhase_Call

type UCOPEVInterface 

type UCOPEVInterface struct {
	mock.Mock
}

UCOPEVInterface is an autogenerated mock type for the UCOPEVInterface type

func NewUCOPEVInterface 

func NewUCOPEVInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCOPEVInterface

NewUCOPEVInterface creates a new instance of UCOPEVInterface. 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 (*UCOPEVInterface) AddFeatures 

func (_m *UCOPEVInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCOPEVInterface) AddUseCase 

func (_m *UCOPEVInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCOPEVInterface) CurrentLimits 

func (_m *UCOPEVInterface) CurrentLimits(entity api.EntityRemoteInterface) ([]float64, []float64, []float64, error)

CurrentLimits provides a mock function with given fields: entity

func (*UCOPEVInterface) EXPECT 

func (_m *UCOPEVInterface) EXPECT() *UCOPEVInterface_Expecter

func (*UCOPEVInterface) IsUseCaseSupported 

func (_m *UCOPEVInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCOPEVInterface) LoadControlLimits 

func (_m *UCOPEVInterface) LoadControlLimits(entity api.EntityRemoteInterface) ([]cemdapi.LoadLimitsPhase, error)

LoadControlLimits provides a mock function with given fields: entity

func (*UCOPEVInterface) UpdateUseCaseAvailability 

func (_m *UCOPEVInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCOPEVInterface) UseCaseName 

func (_m *UCOPEVInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

func (*UCOPEVInterface) WriteLoadControlLimits 

func (_m *UCOPEVInterface) WriteLoadControlLimits(entity api.EntityRemoteInterface, limits []cemdapi.LoadLimitsPhase) (*model.MsgCounterType, error)

WriteLoadControlLimits provides a mock function with given fields: entity, limits

type UCOPEVInterface_AddFeatures_Call 

type UCOPEVInterface_AddFeatures_Call struct {
	*mock.Call
}

UCOPEVInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCOPEVInterface_AddFeatures_Call) Return 

func (_c *UCOPEVInterface_AddFeatures_Call) Return() *UCOPEVInterface_AddFeatures_Call

func (*UCOPEVInterface_AddFeatures_Call) Run 

func (_c *UCOPEVInterface_AddFeatures_Call) Run(run func()) *UCOPEVInterface_AddFeatures_Call

func (*UCOPEVInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCOPEVInterface_AddFeatures_Call) RunAndReturn(run func()) *UCOPEVInterface_AddFeatures_Call

type UCOPEVInterface_AddUseCase_Call 

type UCOPEVInterface_AddUseCase_Call struct {
	*mock.Call
}

UCOPEVInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCOPEVInterface_AddUseCase_Call) Return 

func (_c *UCOPEVInterface_AddUseCase_Call) Return() *UCOPEVInterface_AddUseCase_Call

func (*UCOPEVInterface_AddUseCase_Call) Run 

func (_c *UCOPEVInterface_AddUseCase_Call) Run(run func()) *UCOPEVInterface_AddUseCase_Call

func (*UCOPEVInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCOPEVInterface_AddUseCase_Call) RunAndReturn(run func()) *UCOPEVInterface_AddUseCase_Call

type UCOPEVInterface_CurrentLimits_Call 

type UCOPEVInterface_CurrentLimits_Call struct {
	*mock.Call
}

UCOPEVInterface_CurrentLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurrentLimits'

func (*UCOPEVInterface_CurrentLimits_Call) Return 

func (_c *UCOPEVInterface_CurrentLimits_Call) Return(_a0 []float64, _a1 []float64, _a2 []float64, _a3 error) *UCOPEVInterface_CurrentLimits_Call

func (*UCOPEVInterface_CurrentLimits_Call) Run 

func (_c *UCOPEVInterface_CurrentLimits_Call) Run(run func(entity api.EntityRemoteInterface)) *UCOPEVInterface_CurrentLimits_Call

func (*UCOPEVInterface_CurrentLimits_Call) RunAndReturn 

func (_c *UCOPEVInterface_CurrentLimits_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]float64, []float64, []float64, error)) *UCOPEVInterface_CurrentLimits_Call

type UCOPEVInterface_Expecter 

type UCOPEVInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCOPEVInterface_Expecter) AddFeatures 

func (_e *UCOPEVInterface_Expecter) AddFeatures() *UCOPEVInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCOPEVInterface_Expecter) AddUseCase 

func (_e *UCOPEVInterface_Expecter) AddUseCase() *UCOPEVInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCOPEVInterface_Expecter) CurrentLimits 

func (_e *UCOPEVInterface_Expecter) CurrentLimits(entity interface{}) *UCOPEVInterface_CurrentLimits_Call

CurrentLimits is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCOPEVInterface_Expecter) IsUseCaseSupported 

func (_e *UCOPEVInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCOPEVInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCOPEVInterface_Expecter) LoadControlLimits 

func (_e *UCOPEVInterface_Expecter) LoadControlLimits(entity interface{}) *UCOPEVInterface_LoadControlLimits_Call

LoadControlLimits is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCOPEVInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCOPEVInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCOPEVInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCOPEVInterface_Expecter) UseCaseName 

func (_e *UCOPEVInterface_Expecter) UseCaseName() *UCOPEVInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

func (*UCOPEVInterface_Expecter) WriteLoadControlLimits 

func (_e *UCOPEVInterface_Expecter) WriteLoadControlLimits(entity interface{}, limits interface{}) *UCOPEVInterface_WriteLoadControlLimits_Call

WriteLoadControlLimits is a helper method to define mock.On call

  • entity api.EntityRemoteInterface
  • limits []cemdapi.LoadLimitsPhase

type UCOPEVInterface_IsUseCaseSupported_Call 

type UCOPEVInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCOPEVInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCOPEVInterface_IsUseCaseSupported_Call) Return 

func (_c *UCOPEVInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCOPEVInterface_IsUseCaseSupported_Call

func (*UCOPEVInterface_IsUseCaseSupported_Call) Run 

func (_c *UCOPEVInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCOPEVInterface_IsUseCaseSupported_Call

func (*UCOPEVInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCOPEVInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCOPEVInterface_IsUseCaseSupported_Call

type UCOPEVInterface_LoadControlLimits_Call 

type UCOPEVInterface_LoadControlLimits_Call struct {
	*mock.Call
}

UCOPEVInterface_LoadControlLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadControlLimits'

func (*UCOPEVInterface_LoadControlLimits_Call) Return 

func (_c *UCOPEVInterface_LoadControlLimits_Call) Return(limits []cemdapi.LoadLimitsPhase, resultErr error) *UCOPEVInterface_LoadControlLimits_Call

func (*UCOPEVInterface_LoadControlLimits_Call) Run 

func (_c *UCOPEVInterface_LoadControlLimits_Call) Run(run func(entity api.EntityRemoteInterface)) *UCOPEVInterface_LoadControlLimits_Call

func (*UCOPEVInterface_LoadControlLimits_Call) RunAndReturn 

func (_c *UCOPEVInterface_LoadControlLimits_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]cemdapi.LoadLimitsPhase, error)) *UCOPEVInterface_LoadControlLimits_Call

type UCOPEVInterface_UpdateUseCaseAvailability_Call 

type UCOPEVInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCOPEVInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCOPEVInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCOPEVInterface_UpdateUseCaseAvailability_Call) Return() *UCOPEVInterface_UpdateUseCaseAvailability_Call

func (*UCOPEVInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCOPEVInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCOPEVInterface_UpdateUseCaseAvailability_Call

func (*UCOPEVInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCOPEVInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCOPEVInterface_UpdateUseCaseAvailability_Call

type UCOPEVInterface_UseCaseName_Call 

type UCOPEVInterface_UseCaseName_Call struct {
	*mock.Call
}

UCOPEVInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCOPEVInterface_UseCaseName_Call) Return 

func (_c *UCOPEVInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCOPEVInterface_UseCaseName_Call

func (*UCOPEVInterface_UseCaseName_Call) Run 

func (_c *UCOPEVInterface_UseCaseName_Call) Run(run func()) *UCOPEVInterface_UseCaseName_Call

func (*UCOPEVInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCOPEVInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCOPEVInterface_UseCaseName_Call

type UCOPEVInterface_WriteLoadControlLimits_Call 

type UCOPEVInterface_WriteLoadControlLimits_Call struct {
	*mock.Call
}

UCOPEVInterface_WriteLoadControlLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteLoadControlLimits'

func (*UCOPEVInterface_WriteLoadControlLimits_Call) Return 

func (_c *UCOPEVInterface_WriteLoadControlLimits_Call) Return(_a0 *model.MsgCounterType, _a1 error) *UCOPEVInterface_WriteLoadControlLimits_Call

func (*UCOPEVInterface_WriteLoadControlLimits_Call) Run 

func (_c *UCOPEVInterface_WriteLoadControlLimits_Call) Run(run func(entity api.EntityRemoteInterface, limits []cemdapi.LoadLimitsPhase)) *UCOPEVInterface_WriteLoadControlLimits_Call

func (*UCOPEVInterface_WriteLoadControlLimits_Call) RunAndReturn 

func (_c *UCOPEVInterface_WriteLoadControlLimits_Call) RunAndReturn(run func(api.EntityRemoteInterface, []cemdapi.LoadLimitsPhase) (*model.MsgCounterType, error)) *UCOPEVInterface_WriteLoadControlLimits_Call

type UCOSCEVInterface 

type UCOSCEVInterface struct {
	mock.Mock
}

UCOSCEVInterface is an autogenerated mock type for the UCOSCEVInterface type

func NewUCOSCEVInterface 

func NewUCOSCEVInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCOSCEVInterface

NewUCOSCEVInterface creates a new instance of UCOSCEVInterface. 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 (*UCOSCEVInterface) AddFeatures 

func (_m *UCOSCEVInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCOSCEVInterface) AddUseCase 

func (_m *UCOSCEVInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCOSCEVInterface) CurrentLimits 

func (_m *UCOSCEVInterface) CurrentLimits(entity api.EntityRemoteInterface) ([]float64, []float64, []float64, error)

CurrentLimits provides a mock function with given fields: entity

func (*UCOSCEVInterface) EXPECT 

func (_m *UCOSCEVInterface) EXPECT() *UCOSCEVInterface_Expecter

func (*UCOSCEVInterface) IsUseCaseSupported 

func (_m *UCOSCEVInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCOSCEVInterface) LoadControlLimits 

func (_m *UCOSCEVInterface) LoadControlLimits(entity api.EntityRemoteInterface) ([]cemdapi.LoadLimitsPhase, error)

LoadControlLimits provides a mock function with given fields: entity

func (*UCOSCEVInterface) UpdateUseCaseAvailability 

func (_m *UCOSCEVInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCOSCEVInterface) UseCaseName 

func (_m *UCOSCEVInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

func (*UCOSCEVInterface) WriteLoadControlLimits 

func (_m *UCOSCEVInterface) WriteLoadControlLimits(entity api.EntityRemoteInterface, limits []cemdapi.LoadLimitsPhase) (*model.MsgCounterType, error)

WriteLoadControlLimits provides a mock function with given fields: entity, limits

type UCOSCEVInterface_AddFeatures_Call 

type UCOSCEVInterface_AddFeatures_Call struct {
	*mock.Call
}

UCOSCEVInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCOSCEVInterface_AddFeatures_Call) Return 

func (_c *UCOSCEVInterface_AddFeatures_Call) Return() *UCOSCEVInterface_AddFeatures_Call

func (*UCOSCEVInterface_AddFeatures_Call) Run 

func (_c *UCOSCEVInterface_AddFeatures_Call) Run(run func()) *UCOSCEVInterface_AddFeatures_Call

func (*UCOSCEVInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCOSCEVInterface_AddFeatures_Call) RunAndReturn(run func()) *UCOSCEVInterface_AddFeatures_Call

type UCOSCEVInterface_AddUseCase_Call 

type UCOSCEVInterface_AddUseCase_Call struct {
	*mock.Call
}

UCOSCEVInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCOSCEVInterface_AddUseCase_Call) Return 

func (_c *UCOSCEVInterface_AddUseCase_Call) Return() *UCOSCEVInterface_AddUseCase_Call

func (*UCOSCEVInterface_AddUseCase_Call) Run 

func (_c *UCOSCEVInterface_AddUseCase_Call) Run(run func()) *UCOSCEVInterface_AddUseCase_Call

func (*UCOSCEVInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCOSCEVInterface_AddUseCase_Call) RunAndReturn(run func()) *UCOSCEVInterface_AddUseCase_Call

type UCOSCEVInterface_CurrentLimits_Call 

type UCOSCEVInterface_CurrentLimits_Call struct {
	*mock.Call
}

UCOSCEVInterface_CurrentLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'CurrentLimits'

func (*UCOSCEVInterface_CurrentLimits_Call) Return 

func (_c *UCOSCEVInterface_CurrentLimits_Call) Return(_a0 []float64, _a1 []float64, _a2 []float64, _a3 error) *UCOSCEVInterface_CurrentLimits_Call

func (*UCOSCEVInterface_CurrentLimits_Call) Run 

func (_c *UCOSCEVInterface_CurrentLimits_Call) Run(run func(entity api.EntityRemoteInterface)) *UCOSCEVInterface_CurrentLimits_Call

func (*UCOSCEVInterface_CurrentLimits_Call) RunAndReturn 

func (_c *UCOSCEVInterface_CurrentLimits_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]float64, []float64, []float64, error)) *UCOSCEVInterface_CurrentLimits_Call

type UCOSCEVInterface_Expecter 

type UCOSCEVInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCOSCEVInterface_Expecter) AddFeatures 

func (_e *UCOSCEVInterface_Expecter) AddFeatures() *UCOSCEVInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCOSCEVInterface_Expecter) AddUseCase 

func (_e *UCOSCEVInterface_Expecter) AddUseCase() *UCOSCEVInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCOSCEVInterface_Expecter) CurrentLimits 

func (_e *UCOSCEVInterface_Expecter) CurrentLimits(entity interface{}) *UCOSCEVInterface_CurrentLimits_Call

CurrentLimits is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCOSCEVInterface_Expecter) IsUseCaseSupported 

func (_e *UCOSCEVInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCOSCEVInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCOSCEVInterface_Expecter) LoadControlLimits 

func (_e *UCOSCEVInterface_Expecter) LoadControlLimits(entity interface{}) *UCOSCEVInterface_LoadControlLimits_Call

LoadControlLimits is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCOSCEVInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCOSCEVInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCOSCEVInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCOSCEVInterface_Expecter) UseCaseName 

func (_e *UCOSCEVInterface_Expecter) UseCaseName() *UCOSCEVInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

func (*UCOSCEVInterface_Expecter) WriteLoadControlLimits 

func (_e *UCOSCEVInterface_Expecter) WriteLoadControlLimits(entity interface{}, limits interface{}) *UCOSCEVInterface_WriteLoadControlLimits_Call

WriteLoadControlLimits is a helper method to define mock.On call

  • entity api.EntityRemoteInterface
  • limits []cemdapi.LoadLimitsPhase

type UCOSCEVInterface_IsUseCaseSupported_Call 

type UCOSCEVInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCOSCEVInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCOSCEVInterface_IsUseCaseSupported_Call) Return 

func (_c *UCOSCEVInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCOSCEVInterface_IsUseCaseSupported_Call

func (*UCOSCEVInterface_IsUseCaseSupported_Call) Run 

func (_c *UCOSCEVInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCOSCEVInterface_IsUseCaseSupported_Call

func (*UCOSCEVInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCOSCEVInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCOSCEVInterface_IsUseCaseSupported_Call

type UCOSCEVInterface_LoadControlLimits_Call 

type UCOSCEVInterface_LoadControlLimits_Call struct {
	*mock.Call
}

UCOSCEVInterface_LoadControlLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'LoadControlLimits'

func (*UCOSCEVInterface_LoadControlLimits_Call) Return 

func (_c *UCOSCEVInterface_LoadControlLimits_Call) Return(limits []cemdapi.LoadLimitsPhase, resultErr error) *UCOSCEVInterface_LoadControlLimits_Call

func (*UCOSCEVInterface_LoadControlLimits_Call) Run 

func (_c *UCOSCEVInterface_LoadControlLimits_Call) Run(run func(entity api.EntityRemoteInterface)) *UCOSCEVInterface_LoadControlLimits_Call

func (*UCOSCEVInterface_LoadControlLimits_Call) RunAndReturn 

func (_c *UCOSCEVInterface_LoadControlLimits_Call) RunAndReturn(run func(api.EntityRemoteInterface) ([]cemdapi.LoadLimitsPhase, error)) *UCOSCEVInterface_LoadControlLimits_Call

type UCOSCEVInterface_UpdateUseCaseAvailability_Call 

type UCOSCEVInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCOSCEVInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCOSCEVInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCOSCEVInterface_UpdateUseCaseAvailability_Call) Return() *UCOSCEVInterface_UpdateUseCaseAvailability_Call

func (*UCOSCEVInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCOSCEVInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCOSCEVInterface_UpdateUseCaseAvailability_Call

func (*UCOSCEVInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCOSCEVInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCOSCEVInterface_UpdateUseCaseAvailability_Call

type UCOSCEVInterface_UseCaseName_Call 

type UCOSCEVInterface_UseCaseName_Call struct {
	*mock.Call
}

UCOSCEVInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCOSCEVInterface_UseCaseName_Call) Return 

func (_c *UCOSCEVInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCOSCEVInterface_UseCaseName_Call

func (*UCOSCEVInterface_UseCaseName_Call) Run 

func (_c *UCOSCEVInterface_UseCaseName_Call) Run(run func()) *UCOSCEVInterface_UseCaseName_Call

func (*UCOSCEVInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCOSCEVInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCOSCEVInterface_UseCaseName_Call

type UCOSCEVInterface_WriteLoadControlLimits_Call 

type UCOSCEVInterface_WriteLoadControlLimits_Call struct {
	*mock.Call
}

UCOSCEVInterface_WriteLoadControlLimits_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'WriteLoadControlLimits'

func (*UCOSCEVInterface_WriteLoadControlLimits_Call) Return 

func (_c *UCOSCEVInterface_WriteLoadControlLimits_Call) Return(_a0 *model.MsgCounterType, _a1 error) *UCOSCEVInterface_WriteLoadControlLimits_Call

func (*UCOSCEVInterface_WriteLoadControlLimits_Call) Run 

func (_c *UCOSCEVInterface_WriteLoadControlLimits_Call) Run(run func(entity api.EntityRemoteInterface, limits []cemdapi.LoadLimitsPhase)) *UCOSCEVInterface_WriteLoadControlLimits_Call

func (*UCOSCEVInterface_WriteLoadControlLimits_Call) RunAndReturn 

func (_c *UCOSCEVInterface_WriteLoadControlLimits_Call) RunAndReturn(run func(api.EntityRemoteInterface, []cemdapi.LoadLimitsPhase) (*model.MsgCounterType, error)) *UCOSCEVInterface_WriteLoadControlLimits_Call

type UCVABDInterface 

type UCVABDInterface struct {
	mock.Mock
}

UCVABDInterface is an autogenerated mock type for the UCVABDInterface type

func NewUCVABDInterface 

func NewUCVABDInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCVABDInterface

NewUCVABDInterface creates a new instance of UCVABDInterface. 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 (*UCVABDInterface) AddFeatures 

func (_m *UCVABDInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCVABDInterface) AddUseCase 

func (_m *UCVABDInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCVABDInterface) EXPECT 

func (_m *UCVABDInterface) EXPECT() *UCVABDInterface_Expecter

func (*UCVABDInterface) EnergyCharged 

func (_m *UCVABDInterface) EnergyCharged(entity api.EntityRemoteInterface) (float64, error)

EnergyCharged provides a mock function with given fields: entity

func (*UCVABDInterface) EnergyDischarged 

func (_m *UCVABDInterface) EnergyDischarged(entity api.EntityRemoteInterface) (float64, error)

EnergyDischarged provides a mock function with given fields: entity

func (*UCVABDInterface) IsUseCaseSupported 

func (_m *UCVABDInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCVABDInterface) Power 

func (_m *UCVABDInterface) Power(entity api.EntityRemoteInterface) (float64, error)

Power provides a mock function with given fields: entity

func (*UCVABDInterface) StateOfCharge 

func (_m *UCVABDInterface) StateOfCharge(entity api.EntityRemoteInterface) (float64, error)

StateOfCharge provides a mock function with given fields: entity

func (*UCVABDInterface) UpdateUseCaseAvailability 

func (_m *UCVABDInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCVABDInterface) UseCaseName 

func (_m *UCVABDInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

type UCVABDInterface_AddFeatures_Call 

type UCVABDInterface_AddFeatures_Call struct {
	*mock.Call
}

UCVABDInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCVABDInterface_AddFeatures_Call) Return 

func (_c *UCVABDInterface_AddFeatures_Call) Return() *UCVABDInterface_AddFeatures_Call

func (*UCVABDInterface_AddFeatures_Call) Run 

func (_c *UCVABDInterface_AddFeatures_Call) Run(run func()) *UCVABDInterface_AddFeatures_Call

func (*UCVABDInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCVABDInterface_AddFeatures_Call) RunAndReturn(run func()) *UCVABDInterface_AddFeatures_Call

type UCVABDInterface_AddUseCase_Call 

type UCVABDInterface_AddUseCase_Call struct {
	*mock.Call
}

UCVABDInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCVABDInterface_AddUseCase_Call) Return 

func (_c *UCVABDInterface_AddUseCase_Call) Return() *UCVABDInterface_AddUseCase_Call

func (*UCVABDInterface_AddUseCase_Call) Run 

func (_c *UCVABDInterface_AddUseCase_Call) Run(run func()) *UCVABDInterface_AddUseCase_Call

func (*UCVABDInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCVABDInterface_AddUseCase_Call) RunAndReturn(run func()) *UCVABDInterface_AddUseCase_Call

type UCVABDInterface_EnergyCharged_Call 

type UCVABDInterface_EnergyCharged_Call struct {
	*mock.Call
}

UCVABDInterface_EnergyCharged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnergyCharged'

func (*UCVABDInterface_EnergyCharged_Call) Return 

func (_c *UCVABDInterface_EnergyCharged_Call) Return(_a0 float64, _a1 error) *UCVABDInterface_EnergyCharged_Call

func (*UCVABDInterface_EnergyCharged_Call) Run 

func (_c *UCVABDInterface_EnergyCharged_Call) Run(run func(entity api.EntityRemoteInterface)) *UCVABDInterface_EnergyCharged_Call

func (*UCVABDInterface_EnergyCharged_Call) RunAndReturn 

func (_c *UCVABDInterface_EnergyCharged_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCVABDInterface_EnergyCharged_Call

type UCVABDInterface_EnergyDischarged_Call 

type UCVABDInterface_EnergyDischarged_Call struct {
	*mock.Call
}

UCVABDInterface_EnergyDischarged_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'EnergyDischarged'

func (*UCVABDInterface_EnergyDischarged_Call) Return 

func (_c *UCVABDInterface_EnergyDischarged_Call) Return(_a0 float64, _a1 error) *UCVABDInterface_EnergyDischarged_Call

func (*UCVABDInterface_EnergyDischarged_Call) Run 

func (_c *UCVABDInterface_EnergyDischarged_Call) Run(run func(entity api.EntityRemoteInterface)) *UCVABDInterface_EnergyDischarged_Call

func (*UCVABDInterface_EnergyDischarged_Call) RunAndReturn 

func (_c *UCVABDInterface_EnergyDischarged_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCVABDInterface_EnergyDischarged_Call

type UCVABDInterface_Expecter 

type UCVABDInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCVABDInterface_Expecter) AddFeatures 

func (_e *UCVABDInterface_Expecter) AddFeatures() *UCVABDInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCVABDInterface_Expecter) AddUseCase 

func (_e *UCVABDInterface_Expecter) AddUseCase() *UCVABDInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCVABDInterface_Expecter) EnergyCharged 

func (_e *UCVABDInterface_Expecter) EnergyCharged(entity interface{}) *UCVABDInterface_EnergyCharged_Call

EnergyCharged is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCVABDInterface_Expecter) EnergyDischarged 

func (_e *UCVABDInterface_Expecter) EnergyDischarged(entity interface{}) *UCVABDInterface_EnergyDischarged_Call

EnergyDischarged is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCVABDInterface_Expecter) IsUseCaseSupported 

func (_e *UCVABDInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCVABDInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCVABDInterface_Expecter) Power 

func (_e *UCVABDInterface_Expecter) Power(entity interface{}) *UCVABDInterface_Power_Call

Power is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCVABDInterface_Expecter) StateOfCharge 

func (_e *UCVABDInterface_Expecter) StateOfCharge(entity interface{}) *UCVABDInterface_StateOfCharge_Call

StateOfCharge is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCVABDInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCVABDInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCVABDInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCVABDInterface_Expecter) UseCaseName 

func (_e *UCVABDInterface_Expecter) UseCaseName() *UCVABDInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

type UCVABDInterface_IsUseCaseSupported_Call 

type UCVABDInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCVABDInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCVABDInterface_IsUseCaseSupported_Call) Return 

func (_c *UCVABDInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCVABDInterface_IsUseCaseSupported_Call

func (*UCVABDInterface_IsUseCaseSupported_Call) Run 

func (_c *UCVABDInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCVABDInterface_IsUseCaseSupported_Call

func (*UCVABDInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCVABDInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCVABDInterface_IsUseCaseSupported_Call

type UCVABDInterface_Power_Call 

type UCVABDInterface_Power_Call struct {
	*mock.Call
}

UCVABDInterface_Power_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Power'

func (*UCVABDInterface_Power_Call) Return 

func (_c *UCVABDInterface_Power_Call) Return(_a0 float64, _a1 error) *UCVABDInterface_Power_Call

func (*UCVABDInterface_Power_Call) Run 

func (_c *UCVABDInterface_Power_Call) Run(run func(entity api.EntityRemoteInterface)) *UCVABDInterface_Power_Call

func (*UCVABDInterface_Power_Call) RunAndReturn 

func (_c *UCVABDInterface_Power_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCVABDInterface_Power_Call

type UCVABDInterface_StateOfCharge_Call 

type UCVABDInterface_StateOfCharge_Call struct {
	*mock.Call
}

UCVABDInterface_StateOfCharge_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'StateOfCharge'

func (*UCVABDInterface_StateOfCharge_Call) Return 

func (_c *UCVABDInterface_StateOfCharge_Call) Return(_a0 float64, _a1 error) *UCVABDInterface_StateOfCharge_Call

func (*UCVABDInterface_StateOfCharge_Call) Run 

func (_c *UCVABDInterface_StateOfCharge_Call) Run(run func(entity api.EntityRemoteInterface)) *UCVABDInterface_StateOfCharge_Call

func (*UCVABDInterface_StateOfCharge_Call) RunAndReturn 

func (_c *UCVABDInterface_StateOfCharge_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCVABDInterface_StateOfCharge_Call

type UCVABDInterface_UpdateUseCaseAvailability_Call 

type UCVABDInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCVABDInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCVABDInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCVABDInterface_UpdateUseCaseAvailability_Call) Return() *UCVABDInterface_UpdateUseCaseAvailability_Call

func (*UCVABDInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCVABDInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCVABDInterface_UpdateUseCaseAvailability_Call

func (*UCVABDInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCVABDInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCVABDInterface_UpdateUseCaseAvailability_Call

type UCVABDInterface_UseCaseName_Call 

type UCVABDInterface_UseCaseName_Call struct {
	*mock.Call
}

UCVABDInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCVABDInterface_UseCaseName_Call) Return 

func (_c *UCVABDInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCVABDInterface_UseCaseName_Call

func (*UCVABDInterface_UseCaseName_Call) Run 

func (_c *UCVABDInterface_UseCaseName_Call) Run(run func()) *UCVABDInterface_UseCaseName_Call

func (*UCVABDInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCVABDInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCVABDInterface_UseCaseName_Call

type UCVAPDInterface 

type UCVAPDInterface struct {
	mock.Mock
}

UCVAPDInterface is an autogenerated mock type for the UCVAPDInterface type

func NewUCVAPDInterface 

func NewUCVAPDInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UCVAPDInterface

NewUCVAPDInterface creates a new instance of UCVAPDInterface. 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 (*UCVAPDInterface) AddFeatures 

func (_m *UCVAPDInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UCVAPDInterface) AddUseCase 

func (_m *UCVAPDInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UCVAPDInterface) EXPECT 

func (_m *UCVAPDInterface) EXPECT() *UCVAPDInterface_Expecter

func (*UCVAPDInterface) IsUseCaseSupported 

func (_m *UCVAPDInterface) IsUseCaseSupported(remoteEntity api.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UCVAPDInterface) PVYieldTotal 

func (_m *UCVAPDInterface) PVYieldTotal(entity api.EntityRemoteInterface) (float64, error)

PVYieldTotal provides a mock function with given fields: entity

func (*UCVAPDInterface) Power 

func (_m *UCVAPDInterface) Power(entity api.EntityRemoteInterface) (float64, error)

Power provides a mock function with given fields: entity

func (*UCVAPDInterface) PowerNominalPeak 

func (_m *UCVAPDInterface) PowerNominalPeak(entity api.EntityRemoteInterface) (float64, error)

PowerNominalPeak provides a mock function with given fields: entity

func (*UCVAPDInterface) UpdateUseCaseAvailability 

func (_m *UCVAPDInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UCVAPDInterface) UseCaseName 

func (_m *UCVAPDInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

type UCVAPDInterface_AddFeatures_Call 

type UCVAPDInterface_AddFeatures_Call struct {
	*mock.Call
}

UCVAPDInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UCVAPDInterface_AddFeatures_Call) Return 

func (_c *UCVAPDInterface_AddFeatures_Call) Return() *UCVAPDInterface_AddFeatures_Call

func (*UCVAPDInterface_AddFeatures_Call) Run 

func (_c *UCVAPDInterface_AddFeatures_Call) Run(run func()) *UCVAPDInterface_AddFeatures_Call

func (*UCVAPDInterface_AddFeatures_Call) RunAndReturn 

func (_c *UCVAPDInterface_AddFeatures_Call) RunAndReturn(run func()) *UCVAPDInterface_AddFeatures_Call

type UCVAPDInterface_AddUseCase_Call 

type UCVAPDInterface_AddUseCase_Call struct {
	*mock.Call
}

UCVAPDInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UCVAPDInterface_AddUseCase_Call) Return 

func (_c *UCVAPDInterface_AddUseCase_Call) Return() *UCVAPDInterface_AddUseCase_Call

func (*UCVAPDInterface_AddUseCase_Call) Run 

func (_c *UCVAPDInterface_AddUseCase_Call) Run(run func()) *UCVAPDInterface_AddUseCase_Call

func (*UCVAPDInterface_AddUseCase_Call) RunAndReturn 

func (_c *UCVAPDInterface_AddUseCase_Call) RunAndReturn(run func()) *UCVAPDInterface_AddUseCase_Call

type UCVAPDInterface_Expecter 

type UCVAPDInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UCVAPDInterface_Expecter) AddFeatures 

func (_e *UCVAPDInterface_Expecter) AddFeatures() *UCVAPDInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UCVAPDInterface_Expecter) AddUseCase 

func (_e *UCVAPDInterface_Expecter) AddUseCase() *UCVAPDInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UCVAPDInterface_Expecter) IsUseCaseSupported 

func (_e *UCVAPDInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UCVAPDInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity api.EntityRemoteInterface

func (*UCVAPDInterface_Expecter) PVYieldTotal 

func (_e *UCVAPDInterface_Expecter) PVYieldTotal(entity interface{}) *UCVAPDInterface_PVYieldTotal_Call

PVYieldTotal is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCVAPDInterface_Expecter) Power 

func (_e *UCVAPDInterface_Expecter) Power(entity interface{}) *UCVAPDInterface_Power_Call

Power is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCVAPDInterface_Expecter) PowerNominalPeak 

func (_e *UCVAPDInterface_Expecter) PowerNominalPeak(entity interface{}) *UCVAPDInterface_PowerNominalPeak_Call

PowerNominalPeak is a helper method to define mock.On call

  • entity api.EntityRemoteInterface

func (*UCVAPDInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UCVAPDInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UCVAPDInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UCVAPDInterface_Expecter) UseCaseName 

func (_e *UCVAPDInterface_Expecter) UseCaseName() *UCVAPDInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

type UCVAPDInterface_IsUseCaseSupported_Call 

type UCVAPDInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UCVAPDInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UCVAPDInterface_IsUseCaseSupported_Call) Return 

func (_c *UCVAPDInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UCVAPDInterface_IsUseCaseSupported_Call

func (*UCVAPDInterface_IsUseCaseSupported_Call) Run 

func (_c *UCVAPDInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity api.EntityRemoteInterface)) *UCVAPDInterface_IsUseCaseSupported_Call

func (*UCVAPDInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UCVAPDInterface_IsUseCaseSupported_Call) RunAndReturn(run func(api.EntityRemoteInterface) (bool, error)) *UCVAPDInterface_IsUseCaseSupported_Call

type UCVAPDInterface_PVYieldTotal_Call 

type UCVAPDInterface_PVYieldTotal_Call struct {
	*mock.Call
}

UCVAPDInterface_PVYieldTotal_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PVYieldTotal'

func (*UCVAPDInterface_PVYieldTotal_Call) Return 

func (_c *UCVAPDInterface_PVYieldTotal_Call) Return(_a0 float64, _a1 error) *UCVAPDInterface_PVYieldTotal_Call

func (*UCVAPDInterface_PVYieldTotal_Call) Run 

func (_c *UCVAPDInterface_PVYieldTotal_Call) Run(run func(entity api.EntityRemoteInterface)) *UCVAPDInterface_PVYieldTotal_Call

func (*UCVAPDInterface_PVYieldTotal_Call) RunAndReturn 

func (_c *UCVAPDInterface_PVYieldTotal_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCVAPDInterface_PVYieldTotal_Call

type UCVAPDInterface_PowerNominalPeak_Call 

type UCVAPDInterface_PowerNominalPeak_Call struct {
	*mock.Call
}

UCVAPDInterface_PowerNominalPeak_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'PowerNominalPeak'

func (*UCVAPDInterface_PowerNominalPeak_Call) Return 

func (_c *UCVAPDInterface_PowerNominalPeak_Call) Return(_a0 float64, _a1 error) *UCVAPDInterface_PowerNominalPeak_Call

func (*UCVAPDInterface_PowerNominalPeak_Call) Run 

func (_c *UCVAPDInterface_PowerNominalPeak_Call) Run(run func(entity api.EntityRemoteInterface)) *UCVAPDInterface_PowerNominalPeak_Call

func (*UCVAPDInterface_PowerNominalPeak_Call) RunAndReturn 

func (_c *UCVAPDInterface_PowerNominalPeak_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCVAPDInterface_PowerNominalPeak_Call

type UCVAPDInterface_Power_Call 

type UCVAPDInterface_Power_Call struct {
	*mock.Call
}

UCVAPDInterface_Power_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Power'

func (*UCVAPDInterface_Power_Call) Return 

func (_c *UCVAPDInterface_Power_Call) Return(_a0 float64, _a1 error) *UCVAPDInterface_Power_Call

func (*UCVAPDInterface_Power_Call) Run 

func (_c *UCVAPDInterface_Power_Call) Run(run func(entity api.EntityRemoteInterface)) *UCVAPDInterface_Power_Call

func (*UCVAPDInterface_Power_Call) RunAndReturn 

func (_c *UCVAPDInterface_Power_Call) RunAndReturn(run func(api.EntityRemoteInterface) (float64, error)) *UCVAPDInterface_Power_Call

type UCVAPDInterface_UpdateUseCaseAvailability_Call 

type UCVAPDInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UCVAPDInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UCVAPDInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UCVAPDInterface_UpdateUseCaseAvailability_Call) Return() *UCVAPDInterface_UpdateUseCaseAvailability_Call

func (*UCVAPDInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UCVAPDInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UCVAPDInterface_UpdateUseCaseAvailability_Call

func (*UCVAPDInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UCVAPDInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UCVAPDInterface_UpdateUseCaseAvailability_Call

type UCVAPDInterface_UseCaseName_Call 

type UCVAPDInterface_UseCaseName_Call struct {
	*mock.Call
}

UCVAPDInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UCVAPDInterface_UseCaseName_Call) Return 

func (_c *UCVAPDInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UCVAPDInterface_UseCaseName_Call

func (*UCVAPDInterface_UseCaseName_Call) Run 

func (_c *UCVAPDInterface_UseCaseName_Call) Run(run func()) *UCVAPDInterface_UseCaseName_Call

func (*UCVAPDInterface_UseCaseName_Call) RunAndReturn 

func (_c *UCVAPDInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UCVAPDInterface_UseCaseName_Call

type UseCaseInterface 

type UseCaseInterface struct {
	mock.Mock
}

UseCaseInterface is an autogenerated mock type for the UseCaseInterface type

func NewUseCaseInterface 

func NewUseCaseInterface(t interface {
	mock.TestingT
	Cleanup(func())
}) *UseCaseInterface

NewUseCaseInterface creates a new instance of UseCaseInterface. 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 (*UseCaseInterface) AddFeatures 

func (_m *UseCaseInterface) AddFeatures()

AddFeatures provides a mock function with given fields:

func (*UseCaseInterface) AddUseCase 

func (_m *UseCaseInterface) AddUseCase()

AddUseCase provides a mock function with given fields:

func (*UseCaseInterface) EXPECT 

func (_m *UseCaseInterface) EXPECT() *UseCaseInterface_Expecter

func (*UseCaseInterface) IsUseCaseSupported 

func (_m *UseCaseInterface) IsUseCaseSupported(remoteEntity spine_goapi.EntityRemoteInterface) (bool, error)

IsUseCaseSupported provides a mock function with given fields: remoteEntity

func (*UseCaseInterface) UpdateUseCaseAvailability 

func (_m *UseCaseInterface) UpdateUseCaseAvailability(available bool)

UpdateUseCaseAvailability provides a mock function with given fields: available

func (*UseCaseInterface) UseCaseName 

func (_m *UseCaseInterface) UseCaseName() model.UseCaseNameType

UseCaseName provides a mock function with given fields:

type UseCaseInterface_AddFeatures_Call 

type UseCaseInterface_AddFeatures_Call struct {
	*mock.Call
}

UseCaseInterface_AddFeatures_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddFeatures'

func (*UseCaseInterface_AddFeatures_Call) Return 

func (_c *UseCaseInterface_AddFeatures_Call) Return() *UseCaseInterface_AddFeatures_Call

func (*UseCaseInterface_AddFeatures_Call) Run 

func (_c *UseCaseInterface_AddFeatures_Call) Run(run func()) *UseCaseInterface_AddFeatures_Call

func (*UseCaseInterface_AddFeatures_Call) RunAndReturn 

func (_c *UseCaseInterface_AddFeatures_Call) RunAndReturn(run func()) *UseCaseInterface_AddFeatures_Call

type UseCaseInterface_AddUseCase_Call 

type UseCaseInterface_AddUseCase_Call struct {
	*mock.Call
}

UseCaseInterface_AddUseCase_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddUseCase'

func (*UseCaseInterface_AddUseCase_Call) Return 

func (_c *UseCaseInterface_AddUseCase_Call) Return() *UseCaseInterface_AddUseCase_Call

func (*UseCaseInterface_AddUseCase_Call) Run 

func (_c *UseCaseInterface_AddUseCase_Call) Run(run func()) *UseCaseInterface_AddUseCase_Call

func (*UseCaseInterface_AddUseCase_Call) RunAndReturn 

func (_c *UseCaseInterface_AddUseCase_Call) RunAndReturn(run func()) *UseCaseInterface_AddUseCase_Call

type UseCaseInterface_Expecter 

type UseCaseInterface_Expecter struct {
	// contains filtered or unexported fields
}

func (*UseCaseInterface_Expecter) AddFeatures 

func (_e *UseCaseInterface_Expecter) AddFeatures() *UseCaseInterface_AddFeatures_Call

AddFeatures is a helper method to define mock.On call

func (*UseCaseInterface_Expecter) AddUseCase 

func (_e *UseCaseInterface_Expecter) AddUseCase() *UseCaseInterface_AddUseCase_Call

AddUseCase is a helper method to define mock.On call

func (*UseCaseInterface_Expecter) IsUseCaseSupported 

func (_e *UseCaseInterface_Expecter) IsUseCaseSupported(remoteEntity interface{}) *UseCaseInterface_IsUseCaseSupported_Call

IsUseCaseSupported is a helper method to define mock.On call

  • remoteEntity spine_goapi.EntityRemoteInterface

func (*UseCaseInterface_Expecter) UpdateUseCaseAvailability 

func (_e *UseCaseInterface_Expecter) UpdateUseCaseAvailability(available interface{}) *UseCaseInterface_UpdateUseCaseAvailability_Call

UpdateUseCaseAvailability is a helper method to define mock.On call

  • available bool

func (*UseCaseInterface_Expecter) UseCaseName 

func (_e *UseCaseInterface_Expecter) UseCaseName() *UseCaseInterface_UseCaseName_Call

UseCaseName is a helper method to define mock.On call

type UseCaseInterface_IsUseCaseSupported_Call 

type UseCaseInterface_IsUseCaseSupported_Call struct {
	*mock.Call
}

UseCaseInterface_IsUseCaseSupported_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'IsUseCaseSupported'

func (*UseCaseInterface_IsUseCaseSupported_Call) Return 

func (_c *UseCaseInterface_IsUseCaseSupported_Call) Return(_a0 bool, _a1 error) *UseCaseInterface_IsUseCaseSupported_Call

func (*UseCaseInterface_IsUseCaseSupported_Call) Run 

func (_c *UseCaseInterface_IsUseCaseSupported_Call) Run(run func(remoteEntity spine_goapi.EntityRemoteInterface)) *UseCaseInterface_IsUseCaseSupported_Call

func (*UseCaseInterface_IsUseCaseSupported_Call) RunAndReturn 

func (_c *UseCaseInterface_IsUseCaseSupported_Call) RunAndReturn(run func(spine_goapi.EntityRemoteInterface) (bool, error)) *UseCaseInterface_IsUseCaseSupported_Call

type UseCaseInterface_UpdateUseCaseAvailability_Call 

type UseCaseInterface_UpdateUseCaseAvailability_Call struct {
	*mock.Call
}

UseCaseInterface_UpdateUseCaseAvailability_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UpdateUseCaseAvailability'

func (*UseCaseInterface_UpdateUseCaseAvailability_Call) Return 

func (_c *UseCaseInterface_UpdateUseCaseAvailability_Call) Return() *UseCaseInterface_UpdateUseCaseAvailability_Call

func (*UseCaseInterface_UpdateUseCaseAvailability_Call) Run 

func (_c *UseCaseInterface_UpdateUseCaseAvailability_Call) Run(run func(available bool)) *UseCaseInterface_UpdateUseCaseAvailability_Call

func (*UseCaseInterface_UpdateUseCaseAvailability_Call) RunAndReturn 

func (_c *UseCaseInterface_UpdateUseCaseAvailability_Call) RunAndReturn(run func(bool)) *UseCaseInterface_UpdateUseCaseAvailability_Call

type UseCaseInterface_UseCaseName_Call 

type UseCaseInterface_UseCaseName_Call struct {
	*mock.Call
}

UseCaseInterface_UseCaseName_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'UseCaseName'

func (*UseCaseInterface_UseCaseName_Call) Return 

func (_c *UseCaseInterface_UseCaseName_Call) Return(_a0 model.UseCaseNameType) *UseCaseInterface_UseCaseName_Call

func (*UseCaseInterface_UseCaseName_Call) Run 

func (_c *UseCaseInterface_UseCaseName_Call) Run(run func()) *UseCaseInterface_UseCaseName_Call

func (*UseCaseInterface_UseCaseName_Call) RunAndReturn 

func (_c *UseCaseInterface_UseCaseName_Call) RunAndReturn(run func() model.UseCaseNameType) *UseCaseInterface_UseCaseName_Call

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.