From c9e146e9697e774507ce4b8db53b6060cf5aa9b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20R=C3=BChl?= Date: Mon, 31 Jul 2023 20:37:41 +0200 Subject: [PATCH] fix(plc4go): sync generated code --- .../bacnetip/mock_BacNetPlcTag_test.go | 41 ++++++ .../cbus/mock_CALGetStatusTag_test.go | 41 ++++++ .../internal/cbus/mock_CALIdentifyTag_test.go | 41 ++++++ .../internal/cbus/mock_CALRecallTag_test.go | 41 ++++++ .../internal/cbus/mock_MMIMonitorTag_test.go | 125 ++++++++++++++++++ .../internal/cbus/mock_SALMonitorTag_test.go | 125 ++++++++++++++++++ plc4go/internal/cbus/mock_SALTag_test.go | 41 ++++++ plc4go/internal/cbus/mock_StatusTag_test.go | 41 ++++++ plc4go/internal/cbus/mock_Tag_test.go | 41 ++++++ plc4go/internal/eip/mock_PlcTag_test.go | 41 ++++++ .../internal/knxnetip/mock_DeviceTag_test.go | 41 ++++++ .../knxnetip/mock_GroupAddressTag_test.go | 41 ++++++ plc4go/internal/knxnetip/mock_Tag_test.go | 41 ++++++ plc4go/internal/opcua/Subscriber.go | 2 +- plc4go/internal/opcua/Subscriber_plc4xgen.go | 7 + plc4go/internal/s7/mock_PlcTag_test.go | 41 ++++++ plc4go/internal/simulated/mock_Tag_test.go | 41 ++++++ ...mock_PlcSubscriptionRequestBuilder_test.go | 36 ++--- .../model/mock_PlcSubscriptionRequest_test.go | 12 +- plc4go/pkg/api/model/mock_PlcTag_test.go | 41 ++++++ ...ck_PlcUnsubscriptionRequestBuilder_test.go | 99 ++++++++++++++ .../mock_PlcUnsubscriptionResponse_test.go | 43 ++++++ .../readwrite/model/KnxManufacturer.go | 16 +-- ...tPlcSubscriptionRequestBuilder_plc4xgen.go | 19 ++- .../DefaultPlcSubscriptionRequest_plc4xgen.go | 19 ++- plc4go/spi/model/mock_PlcTag_test.go | 41 ++++++ plc4go/spi/model/render_test.go | 8 +- plc4go/spi/values/PlcValueHandler_test.go | 7 + plc4go/spi/values/mock_PlcTag_test.go | 41 ++++++ .../knxnetip/readwrite/KnxManufacturer.java | 2 +- 30 files changed, 1135 insertions(+), 41 deletions(-) diff --git a/plc4go/internal/bacnetip/mock_BacNetPlcTag_test.go b/plc4go/internal/bacnetip/mock_BacNetPlcTag_test.go index afb620c4ce5..25cc8584cdc 100644 --- a/plc4go/internal/bacnetip/mock_BacNetPlcTag_test.go +++ b/plc4go/internal/bacnetip/mock_BacNetPlcTag_test.go @@ -250,6 +250,47 @@ func (_c *MockBacNetPlcTag_GetValueType_Call) RunAndReturn(run func() values.Plc return _c } +// String provides a mock function with given fields: +func (_m *MockBacNetPlcTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockBacNetPlcTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockBacNetPlcTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockBacNetPlcTag_Expecter) String() *MockBacNetPlcTag_String_Call { + return &MockBacNetPlcTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockBacNetPlcTag_String_Call) Run(run func()) *MockBacNetPlcTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockBacNetPlcTag_String_Call) Return(_a0 string) *MockBacNetPlcTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockBacNetPlcTag_String_Call) RunAndReturn(run func() string) *MockBacNetPlcTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockBacNetPlcTag creates a new instance of MockBacNetPlcTag. 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 NewMockBacNetPlcTag(t interface { diff --git a/plc4go/internal/cbus/mock_CALGetStatusTag_test.go b/plc4go/internal/cbus/mock_CALGetStatusTag_test.go index 7d0e17b7fdf..c8c9ee247c7 100644 --- a/plc4go/internal/cbus/mock_CALGetStatusTag_test.go +++ b/plc4go/internal/cbus/mock_CALGetStatusTag_test.go @@ -377,6 +377,47 @@ func (_c *MockCALGetStatusTag_GetValueType_Call) RunAndReturn(run func() values. return _c } +// String provides a mock function with given fields: +func (_m *MockCALGetStatusTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockCALGetStatusTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockCALGetStatusTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockCALGetStatusTag_Expecter) String() *MockCALGetStatusTag_String_Call { + return &MockCALGetStatusTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockCALGetStatusTag_String_Call) Run(run func()) *MockCALGetStatusTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockCALGetStatusTag_String_Call) Return(_a0 string) *MockCALGetStatusTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCALGetStatusTag_String_Call) RunAndReturn(run func() string) *MockCALGetStatusTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockCALGetStatusTag creates a new instance of MockCALGetStatusTag. 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 NewMockCALGetStatusTag(t interface { diff --git a/plc4go/internal/cbus/mock_CALIdentifyTag_test.go b/plc4go/internal/cbus/mock_CALIdentifyTag_test.go index 5e5185daf11..0cd6d66f3a1 100644 --- a/plc4go/internal/cbus/mock_CALIdentifyTag_test.go +++ b/plc4go/internal/cbus/mock_CALIdentifyTag_test.go @@ -336,6 +336,47 @@ func (_c *MockCALIdentifyTag_GetValueType_Call) RunAndReturn(run func() values.P return _c } +// String provides a mock function with given fields: +func (_m *MockCALIdentifyTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockCALIdentifyTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockCALIdentifyTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockCALIdentifyTag_Expecter) String() *MockCALIdentifyTag_String_Call { + return &MockCALIdentifyTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockCALIdentifyTag_String_Call) Run(run func()) *MockCALIdentifyTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockCALIdentifyTag_String_Call) Return(_a0 string) *MockCALIdentifyTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCALIdentifyTag_String_Call) RunAndReturn(run func() string) *MockCALIdentifyTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockCALIdentifyTag creates a new instance of MockCALIdentifyTag. 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 NewMockCALIdentifyTag(t interface { diff --git a/plc4go/internal/cbus/mock_CALRecallTag_test.go b/plc4go/internal/cbus/mock_CALRecallTag_test.go index 5f45bd3010f..d3c3bc8d974 100644 --- a/plc4go/internal/cbus/mock_CALRecallTag_test.go +++ b/plc4go/internal/cbus/mock_CALRecallTag_test.go @@ -377,6 +377,47 @@ func (_c *MockCALRecallTag_GetValueType_Call) RunAndReturn(run func() values.Plc return _c } +// String provides a mock function with given fields: +func (_m *MockCALRecallTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockCALRecallTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockCALRecallTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockCALRecallTag_Expecter) String() *MockCALRecallTag_String_Call { + return &MockCALRecallTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockCALRecallTag_String_Call) Run(run func()) *MockCALRecallTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockCALRecallTag_String_Call) Return(_a0 string) *MockCALRecallTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockCALRecallTag_String_Call) RunAndReturn(run func() string) *MockCALRecallTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockCALRecallTag creates a new instance of MockCALRecallTag. 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 NewMockCALRecallTag(t interface { diff --git a/plc4go/internal/cbus/mock_MMIMonitorTag_test.go b/plc4go/internal/cbus/mock_MMIMonitorTag_test.go index 8ae004e1a84..8e5eeeb13ff 100644 --- a/plc4go/internal/cbus/mock_MMIMonitorTag_test.go +++ b/plc4go/internal/cbus/mock_MMIMonitorTag_test.go @@ -27,6 +27,8 @@ import ( model "github.com/apache/plc4x/plc4go/protocols/cbus/readwrite/model" + time "time" + values "github.com/apache/plc4x/plc4go/pkg/api/values" ) @@ -170,6 +172,88 @@ func (_c *MockMMIMonitorTag_GetArrayInfo_Call) RunAndReturn(run func() []apimode return _c } +// GetDuration provides a mock function with given fields: +func (_m *MockMMIMonitorTag) GetDuration() time.Duration { + ret := _m.Called() + + var r0 time.Duration + if rf, ok := ret.Get(0).(func() time.Duration); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(time.Duration) + } + + return r0 +} + +// MockMMIMonitorTag_GetDuration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDuration' +type MockMMIMonitorTag_GetDuration_Call struct { + *mock.Call +} + +// GetDuration is a helper method to define mock.On call +func (_e *MockMMIMonitorTag_Expecter) GetDuration() *MockMMIMonitorTag_GetDuration_Call { + return &MockMMIMonitorTag_GetDuration_Call{Call: _e.mock.On("GetDuration")} +} + +func (_c *MockMMIMonitorTag_GetDuration_Call) Run(run func()) *MockMMIMonitorTag_GetDuration_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMMIMonitorTag_GetDuration_Call) Return(_a0 time.Duration) *MockMMIMonitorTag_GetDuration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMMIMonitorTag_GetDuration_Call) RunAndReturn(run func() time.Duration) *MockMMIMonitorTag_GetDuration_Call { + _c.Call.Return(run) + return _c +} + +// GetPlcSubscriptionType provides a mock function with given fields: +func (_m *MockMMIMonitorTag) GetPlcSubscriptionType() apimodel.PlcSubscriptionType { + ret := _m.Called() + + var r0 apimodel.PlcSubscriptionType + if rf, ok := ret.Get(0).(func() apimodel.PlcSubscriptionType); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(apimodel.PlcSubscriptionType) + } + + return r0 +} + +// MockMMIMonitorTag_GetPlcSubscriptionType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPlcSubscriptionType' +type MockMMIMonitorTag_GetPlcSubscriptionType_Call struct { + *mock.Call +} + +// GetPlcSubscriptionType is a helper method to define mock.On call +func (_e *MockMMIMonitorTag_Expecter) GetPlcSubscriptionType() *MockMMIMonitorTag_GetPlcSubscriptionType_Call { + return &MockMMIMonitorTag_GetPlcSubscriptionType_Call{Call: _e.mock.On("GetPlcSubscriptionType")} +} + +func (_c *MockMMIMonitorTag_GetPlcSubscriptionType_Call) Run(run func()) *MockMMIMonitorTag_GetPlcSubscriptionType_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMMIMonitorTag_GetPlcSubscriptionType_Call) Return(_a0 apimodel.PlcSubscriptionType) *MockMMIMonitorTag_GetPlcSubscriptionType_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMMIMonitorTag_GetPlcSubscriptionType_Call) RunAndReturn(run func() apimodel.PlcSubscriptionType) *MockMMIMonitorTag_GetPlcSubscriptionType_Call { + _c.Call.Return(run) + return _c +} + // GetTagType provides a mock function with given fields: func (_m *MockMMIMonitorTag) GetTagType() TagType { ret := _m.Called() @@ -295,6 +379,47 @@ func (_c *MockMMIMonitorTag_GetValueType_Call) RunAndReturn(run func() values.Pl return _c } +// String provides a mock function with given fields: +func (_m *MockMMIMonitorTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockMMIMonitorTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockMMIMonitorTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockMMIMonitorTag_Expecter) String() *MockMMIMonitorTag_String_Call { + return &MockMMIMonitorTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockMMIMonitorTag_String_Call) Run(run func()) *MockMMIMonitorTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockMMIMonitorTag_String_Call) Return(_a0 string) *MockMMIMonitorTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockMMIMonitorTag_String_Call) RunAndReturn(run func() string) *MockMMIMonitorTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockMMIMonitorTag creates a new instance of MockMMIMonitorTag. 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 NewMockMMIMonitorTag(t interface { diff --git a/plc4go/internal/cbus/mock_SALMonitorTag_test.go b/plc4go/internal/cbus/mock_SALMonitorTag_test.go index ca4342bb20b..b318c4c3e68 100644 --- a/plc4go/internal/cbus/mock_SALMonitorTag_test.go +++ b/plc4go/internal/cbus/mock_SALMonitorTag_test.go @@ -27,6 +27,8 @@ import ( model "github.com/apache/plc4x/plc4go/protocols/cbus/readwrite/model" + time "time" + values "github.com/apache/plc4x/plc4go/pkg/api/values" ) @@ -170,6 +172,88 @@ func (_c *MockSALMonitorTag_GetArrayInfo_Call) RunAndReturn(run func() []apimode return _c } +// GetDuration provides a mock function with given fields: +func (_m *MockSALMonitorTag) GetDuration() time.Duration { + ret := _m.Called() + + var r0 time.Duration + if rf, ok := ret.Get(0).(func() time.Duration); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(time.Duration) + } + + return r0 +} + +// MockSALMonitorTag_GetDuration_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetDuration' +type MockSALMonitorTag_GetDuration_Call struct { + *mock.Call +} + +// GetDuration is a helper method to define mock.On call +func (_e *MockSALMonitorTag_Expecter) GetDuration() *MockSALMonitorTag_GetDuration_Call { + return &MockSALMonitorTag_GetDuration_Call{Call: _e.mock.On("GetDuration")} +} + +func (_c *MockSALMonitorTag_GetDuration_Call) Run(run func()) *MockSALMonitorTag_GetDuration_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSALMonitorTag_GetDuration_Call) Return(_a0 time.Duration) *MockSALMonitorTag_GetDuration_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSALMonitorTag_GetDuration_Call) RunAndReturn(run func() time.Duration) *MockSALMonitorTag_GetDuration_Call { + _c.Call.Return(run) + return _c +} + +// GetPlcSubscriptionType provides a mock function with given fields: +func (_m *MockSALMonitorTag) GetPlcSubscriptionType() apimodel.PlcSubscriptionType { + ret := _m.Called() + + var r0 apimodel.PlcSubscriptionType + if rf, ok := ret.Get(0).(func() apimodel.PlcSubscriptionType); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(apimodel.PlcSubscriptionType) + } + + return r0 +} + +// MockSALMonitorTag_GetPlcSubscriptionType_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetPlcSubscriptionType' +type MockSALMonitorTag_GetPlcSubscriptionType_Call struct { + *mock.Call +} + +// GetPlcSubscriptionType is a helper method to define mock.On call +func (_e *MockSALMonitorTag_Expecter) GetPlcSubscriptionType() *MockSALMonitorTag_GetPlcSubscriptionType_Call { + return &MockSALMonitorTag_GetPlcSubscriptionType_Call{Call: _e.mock.On("GetPlcSubscriptionType")} +} + +func (_c *MockSALMonitorTag_GetPlcSubscriptionType_Call) Run(run func()) *MockSALMonitorTag_GetPlcSubscriptionType_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSALMonitorTag_GetPlcSubscriptionType_Call) Return(_a0 apimodel.PlcSubscriptionType) *MockSALMonitorTag_GetPlcSubscriptionType_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSALMonitorTag_GetPlcSubscriptionType_Call) RunAndReturn(run func() apimodel.PlcSubscriptionType) *MockSALMonitorTag_GetPlcSubscriptionType_Call { + _c.Call.Return(run) + return _c +} + // GetTagType provides a mock function with given fields: func (_m *MockSALMonitorTag) GetTagType() TagType { ret := _m.Called() @@ -295,6 +379,47 @@ func (_c *MockSALMonitorTag_GetValueType_Call) RunAndReturn(run func() values.Pl return _c } +// String provides a mock function with given fields: +func (_m *MockSALMonitorTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSALMonitorTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockSALMonitorTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockSALMonitorTag_Expecter) String() *MockSALMonitorTag_String_Call { + return &MockSALMonitorTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockSALMonitorTag_String_Call) Run(run func()) *MockSALMonitorTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSALMonitorTag_String_Call) Return(_a0 string) *MockSALMonitorTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSALMonitorTag_String_Call) RunAndReturn(run func() string) *MockSALMonitorTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockSALMonitorTag creates a new instance of MockSALMonitorTag. 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 NewMockSALMonitorTag(t interface { diff --git a/plc4go/internal/cbus/mock_SALTag_test.go b/plc4go/internal/cbus/mock_SALTag_test.go index 3e6c9e4fe94..3bd835b559d 100644 --- a/plc4go/internal/cbus/mock_SALTag_test.go +++ b/plc4go/internal/cbus/mock_SALTag_test.go @@ -334,6 +334,47 @@ func (_c *MockSALTag_GetValueType_Call) RunAndReturn(run func() values.PlcValueT return _c } +// String provides a mock function with given fields: +func (_m *MockSALTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockSALTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockSALTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockSALTag_Expecter) String() *MockSALTag_String_Call { + return &MockSALTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockSALTag_String_Call) Run(run func()) *MockSALTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockSALTag_String_Call) Return(_a0 string) *MockSALTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockSALTag_String_Call) RunAndReturn(run func() string) *MockSALTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockSALTag creates a new instance of MockSALTag. 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 NewMockSALTag(t interface { diff --git a/plc4go/internal/cbus/mock_StatusTag_test.go b/plc4go/internal/cbus/mock_StatusTag_test.go index 92290098209..9216fc1be0f 100644 --- a/plc4go/internal/cbus/mock_StatusTag_test.go +++ b/plc4go/internal/cbus/mock_StatusTag_test.go @@ -377,6 +377,47 @@ func (_c *MockStatusTag_GetValueType_Call) RunAndReturn(run func() values.PlcVal return _c } +// String provides a mock function with given fields: +func (_m *MockStatusTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockStatusTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockStatusTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockStatusTag_Expecter) String() *MockStatusTag_String_Call { + return &MockStatusTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockStatusTag_String_Call) Run(run func()) *MockStatusTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockStatusTag_String_Call) Return(_a0 string) *MockStatusTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockStatusTag_String_Call) RunAndReturn(run func() string) *MockStatusTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockStatusTag creates a new instance of MockStatusTag. 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 NewMockStatusTag(t interface { diff --git a/plc4go/internal/cbus/mock_Tag_test.go b/plc4go/internal/cbus/mock_Tag_test.go index 84da2a48de9..00d6c75e5c4 100644 --- a/plc4go/internal/cbus/mock_Tag_test.go +++ b/plc4go/internal/cbus/mock_Tag_test.go @@ -207,6 +207,47 @@ func (_c *MockTag_GetValueType_Call) RunAndReturn(run func() values.PlcValueType return _c } +// String provides a mock function with given fields: +func (_m *MockTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockTag_Expecter) String() *MockTag_String_Call { + return &MockTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockTag_String_Call) Run(run func()) *MockTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockTag_String_Call) Return(_a0 string) *MockTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockTag_String_Call) RunAndReturn(run func() string) *MockTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockTag creates a new instance of MockTag. 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 NewMockTag(t interface { diff --git a/plc4go/internal/eip/mock_PlcTag_test.go b/plc4go/internal/eip/mock_PlcTag_test.go index 7301644d0e3..c7f1d47fc49 100644 --- a/plc4go/internal/eip/mock_PlcTag_test.go +++ b/plc4go/internal/eip/mock_PlcTag_test.go @@ -391,6 +391,47 @@ func (_c *MockPlcTag_SerializeWithWriteBuffer_Call) RunAndReturn(run func(contex return _c } +// String provides a mock function with given fields: +func (_m *MockPlcTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockPlcTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockPlcTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockPlcTag_Expecter) String() *MockPlcTag_String_Call { + return &MockPlcTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockPlcTag_String_Call) Run(run func()) *MockPlcTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPlcTag_String_Call) Return(_a0 string) *MockPlcTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPlcTag_String_Call) RunAndReturn(run func() string) *MockPlcTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockPlcTag creates a new instance of MockPlcTag. 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 NewMockPlcTag(t interface { diff --git a/plc4go/internal/knxnetip/mock_DeviceTag_test.go b/plc4go/internal/knxnetip/mock_DeviceTag_test.go index 19d3d602e53..a35735c119f 100644 --- a/plc4go/internal/knxnetip/mock_DeviceTag_test.go +++ b/plc4go/internal/knxnetip/mock_DeviceTag_test.go @@ -168,6 +168,47 @@ func (_c *MockDeviceTag_GetValueType_Call) RunAndReturn(run func() values.PlcVal return _c } +// String provides a mock function with given fields: +func (_m *MockDeviceTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockDeviceTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockDeviceTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockDeviceTag_Expecter) String() *MockDeviceTag_String_Call { + return &MockDeviceTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockDeviceTag_String_Call) Run(run func()) *MockDeviceTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockDeviceTag_String_Call) Return(_a0 string) *MockDeviceTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockDeviceTag_String_Call) RunAndReturn(run func() string) *MockDeviceTag_String_Call { + _c.Call.Return(run) + return _c +} + // toKnxAddress provides a mock function with given fields: func (_m *MockDeviceTag) toKnxAddress() readwritemodel.KnxAddress { ret := _m.Called() diff --git a/plc4go/internal/knxnetip/mock_GroupAddressTag_test.go b/plc4go/internal/knxnetip/mock_GroupAddressTag_test.go index 7d88010abea..8a576d707ca 100644 --- a/plc4go/internal/knxnetip/mock_GroupAddressTag_test.go +++ b/plc4go/internal/knxnetip/mock_GroupAddressTag_test.go @@ -252,6 +252,47 @@ func (_c *MockGroupAddressTag_IsPatternTag_Call) RunAndReturn(run func() bool) * return _c } +// String provides a mock function with given fields: +func (_m *MockGroupAddressTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockGroupAddressTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockGroupAddressTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockGroupAddressTag_Expecter) String() *MockGroupAddressTag_String_Call { + return &MockGroupAddressTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockGroupAddressTag_String_Call) Run(run func()) *MockGroupAddressTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockGroupAddressTag_String_Call) Return(_a0 string) *MockGroupAddressTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockGroupAddressTag_String_Call) RunAndReturn(run func() string) *MockGroupAddressTag_String_Call { + _c.Call.Return(run) + return _c +} + // matches provides a mock function with given fields: knxGroupAddress func (_m *MockGroupAddressTag) matches(knxGroupAddress readwritemodel.KnxGroupAddress) bool { ret := _m.Called(knxGroupAddress) diff --git a/plc4go/internal/knxnetip/mock_Tag_test.go b/plc4go/internal/knxnetip/mock_Tag_test.go index 0bda388fc32..e78cb006654 100644 --- a/plc4go/internal/knxnetip/mock_Tag_test.go +++ b/plc4go/internal/knxnetip/mock_Tag_test.go @@ -166,6 +166,47 @@ func (_c *MockTag_GetValueType_Call) RunAndReturn(run func() values.PlcValueType return _c } +// String provides a mock function with given fields: +func (_m *MockTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockTag_Expecter) String() *MockTag_String_Call { + return &MockTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockTag_String_Call) Run(run func()) *MockTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockTag_String_Call) Return(_a0 string) *MockTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockTag_String_Call) RunAndReturn(run func() string) *MockTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockTag creates a new instance of MockTag. 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 NewMockTag(t interface { diff --git a/plc4go/internal/opcua/Subscriber.go b/plc4go/internal/opcua/Subscriber.go index f485994f77d..5b883252380 100644 --- a/plc4go/internal/opcua/Subscriber.go +++ b/plc4go/internal/opcua/Subscriber.go @@ -42,7 +42,7 @@ type Subscriber struct { consumers map[*spiModel.DefaultPlcConsumerRegistration]apiModel.PlcSubscriptionEventConsumer `ignore:"true"` addSubscriber func(subscriber *Subscriber) messageCodec *MessageCodec - subscriptions map[uint32]*SubscriptionHandle + subscriptions map[uint32]*SubscriptionHandle `ignore:"true"` // TODO: we don't have support for non string key maps yet consumersMutex sync.RWMutex diff --git a/plc4go/internal/opcua/Subscriber_plc4xgen.go b/plc4go/internal/opcua/Subscriber_plc4xgen.go index cb44fb71bde..7e3562e8320 100644 --- a/plc4go/internal/opcua/Subscriber_plc4xgen.go +++ b/plc4go/internal/opcua/Subscriber_plc4xgen.go @@ -46,6 +46,13 @@ func (d *Subscriber) SerializeWithWriteBuffer(ctx context.Context, writeBuffer u if err := writeBuffer.WriteBit("addSubscriber", d.addSubscriber != nil); err != nil { return err } + { + _value := fmt.Sprintf("%v", d.messageCodec) + + if err := writeBuffer.WriteString("messageCodec", uint32(len(_value)*8), "UTF-8", _value); err != nil { + return err + } + } if err := writeBuffer.PopContext("Subscriber"); err != nil { return err } diff --git a/plc4go/internal/s7/mock_PlcTag_test.go b/plc4go/internal/s7/mock_PlcTag_test.go index 63522dc12d9..19ede001841 100644 --- a/plc4go/internal/s7/mock_PlcTag_test.go +++ b/plc4go/internal/s7/mock_PlcTag_test.go @@ -514,6 +514,47 @@ func (_c *MockPlcTag_SerializeWithWriteBuffer_Call) RunAndReturn(run func(contex return _c } +// String provides a mock function with given fields: +func (_m *MockPlcTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockPlcTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockPlcTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockPlcTag_Expecter) String() *MockPlcTag_String_Call { + return &MockPlcTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockPlcTag_String_Call) Run(run func()) *MockPlcTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPlcTag_String_Call) Return(_a0 string) *MockPlcTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPlcTag_String_Call) RunAndReturn(run func() string) *MockPlcTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockPlcTag creates a new instance of MockPlcTag. 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 NewMockPlcTag(t interface { diff --git a/plc4go/internal/simulated/mock_Tag_test.go b/plc4go/internal/simulated/mock_Tag_test.go index 93148d24b39..eb09374792f 100644 --- a/plc4go/internal/simulated/mock_Tag_test.go +++ b/plc4go/internal/simulated/mock_Tag_test.go @@ -291,6 +291,47 @@ func (_c *MockTag_GetValueType_Call) RunAndReturn(run func() values.PlcValueType return _c } +// String provides a mock function with given fields: +func (_m *MockTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockTag_Expecter) String() *MockTag_String_Call { + return &MockTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockTag_String_Call) Run(run func()) *MockTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockTag_String_Call) Return(_a0 string) *MockTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockTag_String_Call) RunAndReturn(run func() string) *MockTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockTag creates a new instance of MockTag. 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 NewMockTag(t interface { diff --git a/plc4go/pkg/api/model/mock_PlcSubscriptionRequestBuilder_test.go b/plc4go/pkg/api/model/mock_PlcSubscriptionRequestBuilder_test.go index 88dd96b2842..2bf627b026e 100644 --- a/plc4go/pkg/api/model/mock_PlcSubscriptionRequestBuilder_test.go +++ b/plc4go/pkg/api/model/mock_PlcSubscriptionRequestBuilder_test.go @@ -41,11 +41,11 @@ func (_m *MockPlcSubscriptionRequestBuilder) EXPECT() *MockPlcSubscriptionReques } // AddChangeOfStateTag provides a mock function with given fields: tagName, tag -func (_m *MockPlcSubscriptionRequestBuilder) AddChangeOfStateTag(tagName string, tag PlcTag) PlcSubscriptionRequestBuilder { +func (_m *MockPlcSubscriptionRequestBuilder) AddChangeOfStateTag(tagName string, tag PlcSubscriptionTag) PlcSubscriptionRequestBuilder { ret := _m.Called(tagName, tag) var r0 PlcSubscriptionRequestBuilder - if rf, ok := ret.Get(0).(func(string, PlcTag) PlcSubscriptionRequestBuilder); ok { + if rf, ok := ret.Get(0).(func(string, PlcSubscriptionTag) PlcSubscriptionRequestBuilder); ok { r0 = rf(tagName, tag) } else { if ret.Get(0) != nil { @@ -63,14 +63,14 @@ type MockPlcSubscriptionRequestBuilder_AddChangeOfStateTag_Call struct { // AddChangeOfStateTag is a helper method to define mock.On call // - tagName string -// - tag PlcTag +// - tag PlcSubscriptionTag func (_e *MockPlcSubscriptionRequestBuilder_Expecter) AddChangeOfStateTag(tagName interface{}, tag interface{}) *MockPlcSubscriptionRequestBuilder_AddChangeOfStateTag_Call { return &MockPlcSubscriptionRequestBuilder_AddChangeOfStateTag_Call{Call: _e.mock.On("AddChangeOfStateTag", tagName, tag)} } -func (_c *MockPlcSubscriptionRequestBuilder_AddChangeOfStateTag_Call) Run(run func(tagName string, tag PlcTag)) *MockPlcSubscriptionRequestBuilder_AddChangeOfStateTag_Call { +func (_c *MockPlcSubscriptionRequestBuilder_AddChangeOfStateTag_Call) Run(run func(tagName string, tag PlcSubscriptionTag)) *MockPlcSubscriptionRequestBuilder_AddChangeOfStateTag_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string), args[1].(PlcTag)) + run(args[0].(string), args[1].(PlcSubscriptionTag)) }) return _c } @@ -80,7 +80,7 @@ func (_c *MockPlcSubscriptionRequestBuilder_AddChangeOfStateTag_Call) Return(_a0 return _c } -func (_c *MockPlcSubscriptionRequestBuilder_AddChangeOfStateTag_Call) RunAndReturn(run func(string, PlcTag) PlcSubscriptionRequestBuilder) *MockPlcSubscriptionRequestBuilder_AddChangeOfStateTag_Call { +func (_c *MockPlcSubscriptionRequestBuilder_AddChangeOfStateTag_Call) RunAndReturn(run func(string, PlcSubscriptionTag) PlcSubscriptionRequestBuilder) *MockPlcSubscriptionRequestBuilder_AddChangeOfStateTag_Call { _c.Call.Return(run) return _c } @@ -131,11 +131,11 @@ func (_c *MockPlcSubscriptionRequestBuilder_AddChangeOfStateTagAddress_Call) Run } // AddCyclicTag provides a mock function with given fields: tagName, tag, interval -func (_m *MockPlcSubscriptionRequestBuilder) AddCyclicTag(tagName string, tag PlcTag, interval time.Duration) PlcSubscriptionRequestBuilder { +func (_m *MockPlcSubscriptionRequestBuilder) AddCyclicTag(tagName string, tag PlcSubscriptionTag, interval time.Duration) PlcSubscriptionRequestBuilder { ret := _m.Called(tagName, tag, interval) var r0 PlcSubscriptionRequestBuilder - if rf, ok := ret.Get(0).(func(string, PlcTag, time.Duration) PlcSubscriptionRequestBuilder); ok { + if rf, ok := ret.Get(0).(func(string, PlcSubscriptionTag, time.Duration) PlcSubscriptionRequestBuilder); ok { r0 = rf(tagName, tag, interval) } else { if ret.Get(0) != nil { @@ -153,15 +153,15 @@ type MockPlcSubscriptionRequestBuilder_AddCyclicTag_Call struct { // AddCyclicTag is a helper method to define mock.On call // - tagName string -// - tag PlcTag +// - tag PlcSubscriptionTag // - interval time.Duration func (_e *MockPlcSubscriptionRequestBuilder_Expecter) AddCyclicTag(tagName interface{}, tag interface{}, interval interface{}) *MockPlcSubscriptionRequestBuilder_AddCyclicTag_Call { return &MockPlcSubscriptionRequestBuilder_AddCyclicTag_Call{Call: _e.mock.On("AddCyclicTag", tagName, tag, interval)} } -func (_c *MockPlcSubscriptionRequestBuilder_AddCyclicTag_Call) Run(run func(tagName string, tag PlcTag, interval time.Duration)) *MockPlcSubscriptionRequestBuilder_AddCyclicTag_Call { +func (_c *MockPlcSubscriptionRequestBuilder_AddCyclicTag_Call) Run(run func(tagName string, tag PlcSubscriptionTag, interval time.Duration)) *MockPlcSubscriptionRequestBuilder_AddCyclicTag_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string), args[1].(PlcTag), args[2].(time.Duration)) + run(args[0].(string), args[1].(PlcSubscriptionTag), args[2].(time.Duration)) }) return _c } @@ -171,7 +171,7 @@ func (_c *MockPlcSubscriptionRequestBuilder_AddCyclicTag_Call) Return(_a0 PlcSub return _c } -func (_c *MockPlcSubscriptionRequestBuilder_AddCyclicTag_Call) RunAndReturn(run func(string, PlcTag, time.Duration) PlcSubscriptionRequestBuilder) *MockPlcSubscriptionRequestBuilder_AddCyclicTag_Call { +func (_c *MockPlcSubscriptionRequestBuilder_AddCyclicTag_Call) RunAndReturn(run func(string, PlcSubscriptionTag, time.Duration) PlcSubscriptionRequestBuilder) *MockPlcSubscriptionRequestBuilder_AddCyclicTag_Call { _c.Call.Return(run) return _c } @@ -223,11 +223,11 @@ func (_c *MockPlcSubscriptionRequestBuilder_AddCyclicTagAddress_Call) RunAndRetu } // AddEventTag provides a mock function with given fields: tagName, tag -func (_m *MockPlcSubscriptionRequestBuilder) AddEventTag(tagName string, tag PlcTag) PlcSubscriptionRequestBuilder { +func (_m *MockPlcSubscriptionRequestBuilder) AddEventTag(tagName string, tag PlcSubscriptionTag) PlcSubscriptionRequestBuilder { ret := _m.Called(tagName, tag) var r0 PlcSubscriptionRequestBuilder - if rf, ok := ret.Get(0).(func(string, PlcTag) PlcSubscriptionRequestBuilder); ok { + if rf, ok := ret.Get(0).(func(string, PlcSubscriptionTag) PlcSubscriptionRequestBuilder); ok { r0 = rf(tagName, tag) } else { if ret.Get(0) != nil { @@ -245,14 +245,14 @@ type MockPlcSubscriptionRequestBuilder_AddEventTag_Call struct { // AddEventTag is a helper method to define mock.On call // - tagName string -// - tag PlcTag +// - tag PlcSubscriptionTag func (_e *MockPlcSubscriptionRequestBuilder_Expecter) AddEventTag(tagName interface{}, tag interface{}) *MockPlcSubscriptionRequestBuilder_AddEventTag_Call { return &MockPlcSubscriptionRequestBuilder_AddEventTag_Call{Call: _e.mock.On("AddEventTag", tagName, tag)} } -func (_c *MockPlcSubscriptionRequestBuilder_AddEventTag_Call) Run(run func(tagName string, tag PlcTag)) *MockPlcSubscriptionRequestBuilder_AddEventTag_Call { +func (_c *MockPlcSubscriptionRequestBuilder_AddEventTag_Call) Run(run func(tagName string, tag PlcSubscriptionTag)) *MockPlcSubscriptionRequestBuilder_AddEventTag_Call { _c.Call.Run(func(args mock.Arguments) { - run(args[0].(string), args[1].(PlcTag)) + run(args[0].(string), args[1].(PlcSubscriptionTag)) }) return _c } @@ -262,7 +262,7 @@ func (_c *MockPlcSubscriptionRequestBuilder_AddEventTag_Call) Return(_a0 PlcSubs return _c } -func (_c *MockPlcSubscriptionRequestBuilder_AddEventTag_Call) RunAndReturn(run func(string, PlcTag) PlcSubscriptionRequestBuilder) *MockPlcSubscriptionRequestBuilder_AddEventTag_Call { +func (_c *MockPlcSubscriptionRequestBuilder_AddEventTag_Call) RunAndReturn(run func(string, PlcSubscriptionTag) PlcSubscriptionRequestBuilder) *MockPlcSubscriptionRequestBuilder_AddEventTag_Call { _c.Call.Return(run) return _c } diff --git a/plc4go/pkg/api/model/mock_PlcSubscriptionRequest_test.go b/plc4go/pkg/api/model/mock_PlcSubscriptionRequest_test.go index 80d1749ad59..8570d2713cf 100644 --- a/plc4go/pkg/api/model/mock_PlcSubscriptionRequest_test.go +++ b/plc4go/pkg/api/model/mock_PlcSubscriptionRequest_test.go @@ -128,15 +128,15 @@ func (_c *MockPlcSubscriptionRequest_ExecuteWithContext_Call) RunAndReturn(run f } // GetTag provides a mock function with given fields: tagName -func (_m *MockPlcSubscriptionRequest) GetTag(tagName string) PlcTag { +func (_m *MockPlcSubscriptionRequest) GetTag(tagName string) PlcSubscriptionTag { ret := _m.Called(tagName) - var r0 PlcTag - if rf, ok := ret.Get(0).(func(string) PlcTag); ok { + var r0 PlcSubscriptionTag + if rf, ok := ret.Get(0).(func(string) PlcSubscriptionTag); ok { r0 = rf(tagName) } else { if ret.Get(0) != nil { - r0 = ret.Get(0).(PlcTag) + r0 = ret.Get(0).(PlcSubscriptionTag) } } @@ -161,12 +161,12 @@ func (_c *MockPlcSubscriptionRequest_GetTag_Call) Run(run func(tagName string)) return _c } -func (_c *MockPlcSubscriptionRequest_GetTag_Call) Return(_a0 PlcTag) *MockPlcSubscriptionRequest_GetTag_Call { +func (_c *MockPlcSubscriptionRequest_GetTag_Call) Return(_a0 PlcSubscriptionTag) *MockPlcSubscriptionRequest_GetTag_Call { _c.Call.Return(_a0) return _c } -func (_c *MockPlcSubscriptionRequest_GetTag_Call) RunAndReturn(run func(string) PlcTag) *MockPlcSubscriptionRequest_GetTag_Call { +func (_c *MockPlcSubscriptionRequest_GetTag_Call) RunAndReturn(run func(string) PlcSubscriptionTag) *MockPlcSubscriptionRequest_GetTag_Call { _c.Call.Return(run) return _c } diff --git a/plc4go/pkg/api/model/mock_PlcTag_test.go b/plc4go/pkg/api/model/mock_PlcTag_test.go index 0f04860bac9..1b3806e96ef 100644 --- a/plc4go/pkg/api/model/mock_PlcTag_test.go +++ b/plc4go/pkg/api/model/mock_PlcTag_test.go @@ -164,6 +164,47 @@ func (_c *MockPlcTag_GetValueType_Call) RunAndReturn(run func() values.PlcValueT return _c } +// String provides a mock function with given fields: +func (_m *MockPlcTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockPlcTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockPlcTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockPlcTag_Expecter) String() *MockPlcTag_String_Call { + return &MockPlcTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockPlcTag_String_Call) Run(run func()) *MockPlcTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPlcTag_String_Call) Return(_a0 string) *MockPlcTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPlcTag_String_Call) RunAndReturn(run func() string) *MockPlcTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockPlcTag creates a new instance of MockPlcTag. 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 NewMockPlcTag(t interface { diff --git a/plc4go/pkg/api/model/mock_PlcUnsubscriptionRequestBuilder_test.go b/plc4go/pkg/api/model/mock_PlcUnsubscriptionRequestBuilder_test.go index 8ae840ca031..5efc7ca40c4 100644 --- a/plc4go/pkg/api/model/mock_PlcUnsubscriptionRequestBuilder_test.go +++ b/plc4go/pkg/api/model/mock_PlcUnsubscriptionRequestBuilder_test.go @@ -36,6 +36,105 @@ func (_m *MockPlcUnsubscriptionRequestBuilder) EXPECT() *MockPlcUnsubscriptionRe return &MockPlcUnsubscriptionRequestBuilder_Expecter{mock: &_m.Mock} } +// AddHandles provides a mock function with given fields: PlcSubscriptionHandle +func (_m *MockPlcUnsubscriptionRequestBuilder) AddHandles(PlcSubscriptionHandle ...PlcSubscriptionHandle) { + _va := make([]interface{}, len(PlcSubscriptionHandle)) + for _i := range PlcSubscriptionHandle { + _va[_i] = PlcSubscriptionHandle[_i] + } + var _ca []interface{} + _ca = append(_ca, _va...) + _m.Called(_ca...) +} + +// MockPlcUnsubscriptionRequestBuilder_AddHandles_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'AddHandles' +type MockPlcUnsubscriptionRequestBuilder_AddHandles_Call struct { + *mock.Call +} + +// AddHandles is a helper method to define mock.On call +// - PlcSubscriptionHandle ...PlcSubscriptionHandle +func (_e *MockPlcUnsubscriptionRequestBuilder_Expecter) AddHandles(PlcSubscriptionHandle ...interface{}) *MockPlcUnsubscriptionRequestBuilder_AddHandles_Call { + return &MockPlcUnsubscriptionRequestBuilder_AddHandles_Call{Call: _e.mock.On("AddHandles", + append([]interface{}{}, PlcSubscriptionHandle...)...)} +} + +func (_c *MockPlcUnsubscriptionRequestBuilder_AddHandles_Call) Run(run func(PlcSubscriptionHandle ...PlcSubscriptionHandle)) *MockPlcUnsubscriptionRequestBuilder_AddHandles_Call { + _c.Call.Run(func(args mock.Arguments) { + variadicArgs := make([]PlcSubscriptionHandle, len(args)-0) + for i, a := range args[0:] { + if a != nil { + variadicArgs[i] = a.(PlcSubscriptionHandle) + } + } + run(variadicArgs...) + }) + return _c +} + +func (_c *MockPlcUnsubscriptionRequestBuilder_AddHandles_Call) Return() *MockPlcUnsubscriptionRequestBuilder_AddHandles_Call { + _c.Call.Return() + return _c +} + +func (_c *MockPlcUnsubscriptionRequestBuilder_AddHandles_Call) RunAndReturn(run func(...PlcSubscriptionHandle)) *MockPlcUnsubscriptionRequestBuilder_AddHandles_Call { + _c.Call.Return(run) + return _c +} + +// Build provides a mock function with given fields: +func (_m *MockPlcUnsubscriptionRequestBuilder) Build() (PlcUnsubscriptionRequest, error) { + ret := _m.Called() + + var r0 PlcUnsubscriptionRequest + var r1 error + if rf, ok := ret.Get(0).(func() (PlcUnsubscriptionRequest, error)); ok { + return rf() + } + if rf, ok := ret.Get(0).(func() PlcUnsubscriptionRequest); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(PlcUnsubscriptionRequest) + } + } + + if rf, ok := ret.Get(1).(func() error); ok { + r1 = rf() + } else { + r1 = ret.Error(1) + } + + return r0, r1 +} + +// MockPlcUnsubscriptionRequestBuilder_Build_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'Build' +type MockPlcUnsubscriptionRequestBuilder_Build_Call struct { + *mock.Call +} + +// Build is a helper method to define mock.On call +func (_e *MockPlcUnsubscriptionRequestBuilder_Expecter) Build() *MockPlcUnsubscriptionRequestBuilder_Build_Call { + return &MockPlcUnsubscriptionRequestBuilder_Build_Call{Call: _e.mock.On("Build")} +} + +func (_c *MockPlcUnsubscriptionRequestBuilder_Build_Call) Run(run func()) *MockPlcUnsubscriptionRequestBuilder_Build_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPlcUnsubscriptionRequestBuilder_Build_Call) Return(_a0 PlcUnsubscriptionRequest, _a1 error) *MockPlcUnsubscriptionRequestBuilder_Build_Call { + _c.Call.Return(_a0, _a1) + return _c +} + +func (_c *MockPlcUnsubscriptionRequestBuilder_Build_Call) RunAndReturn(run func() (PlcUnsubscriptionRequest, error)) *MockPlcUnsubscriptionRequestBuilder_Build_Call { + _c.Call.Return(run) + return _c +} + // NewMockPlcUnsubscriptionRequestBuilder creates a new instance of MockPlcUnsubscriptionRequestBuilder. 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 NewMockPlcUnsubscriptionRequestBuilder(t interface { diff --git a/plc4go/pkg/api/model/mock_PlcUnsubscriptionResponse_test.go b/plc4go/pkg/api/model/mock_PlcUnsubscriptionResponse_test.go index eed7927085e..de142033e3f 100644 --- a/plc4go/pkg/api/model/mock_PlcUnsubscriptionResponse_test.go +++ b/plc4go/pkg/api/model/mock_PlcUnsubscriptionResponse_test.go @@ -36,6 +36,49 @@ func (_m *MockPlcUnsubscriptionResponse) EXPECT() *MockPlcUnsubscriptionResponse return &MockPlcUnsubscriptionResponse_Expecter{mock: &_m.Mock} } +// GetRequest provides a mock function with given fields: +func (_m *MockPlcUnsubscriptionResponse) GetRequest() PlcUnsubscriptionRequest { + ret := _m.Called() + + var r0 PlcUnsubscriptionRequest + if rf, ok := ret.Get(0).(func() PlcUnsubscriptionRequest); ok { + r0 = rf() + } else { + if ret.Get(0) != nil { + r0 = ret.Get(0).(PlcUnsubscriptionRequest) + } + } + + return r0 +} + +// MockPlcUnsubscriptionResponse_GetRequest_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'GetRequest' +type MockPlcUnsubscriptionResponse_GetRequest_Call struct { + *mock.Call +} + +// GetRequest is a helper method to define mock.On call +func (_e *MockPlcUnsubscriptionResponse_Expecter) GetRequest() *MockPlcUnsubscriptionResponse_GetRequest_Call { + return &MockPlcUnsubscriptionResponse_GetRequest_Call{Call: _e.mock.On("GetRequest")} +} + +func (_c *MockPlcUnsubscriptionResponse_GetRequest_Call) Run(run func()) *MockPlcUnsubscriptionResponse_GetRequest_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPlcUnsubscriptionResponse_GetRequest_Call) Return(_a0 PlcUnsubscriptionRequest) *MockPlcUnsubscriptionResponse_GetRequest_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPlcUnsubscriptionResponse_GetRequest_Call) RunAndReturn(run func() PlcUnsubscriptionRequest) *MockPlcUnsubscriptionResponse_GetRequest_Call { + _c.Call.Return(run) + return _c +} + // NewMockPlcUnsubscriptionResponse creates a new instance of MockPlcUnsubscriptionResponse. 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 NewMockPlcUnsubscriptionResponse(t interface { diff --git a/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go b/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go index c908c0dd4b5..7bdf38ce7f6 100644 --- a/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go +++ b/plc4go/protocols/knxnetip/readwrite/model/KnxManufacturer.go @@ -680,7 +680,7 @@ const ( KnxManufacturer_M_SEXANKA KnxManufacturer = 634 KnxManufacturer_M_SECURI_FLEX_LTD KnxManufacturer = 635 KnxManufacturer_M_BOKE KnxManufacturer = 636 - KnxManufacturer_M_SBR_SMART_CONTROL KnxManufacturer = 637 + KnxManufacturer_M_SBR_SYSTEM_TECHNICAL KnxManufacturer = 637 KnxManufacturer_M_ABB___RESERVED KnxManufacturer = 638 KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED KnxManufacturer = 639 ) @@ -1327,7 +1327,7 @@ func init() { KnxManufacturer_M_SEXANKA, KnxManufacturer_M_SECURI_FLEX_LTD, KnxManufacturer_M_BOKE, - KnxManufacturer_M_SBR_SMART_CONTROL, + KnxManufacturer_M_SBR_SYSTEM_TECHNICAL, KnxManufacturer_M_ABB___RESERVED, KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED, } @@ -6307,7 +6307,7 @@ func (e KnxManufacturer) Name() string { } case 637: { /* '637' */ - return "SBR Smart Control" + return "SBR System Technical" } case 638: { /* '638' */ @@ -7687,7 +7687,7 @@ func KnxManufacturerByValue(value uint16) (enum KnxManufacturer, ok bool) { case 636: return KnxManufacturer_M_BOKE, true case 637: - return KnxManufacturer_M_SBR_SMART_CONTROL, true + return KnxManufacturer_M_SBR_SYSTEM_TECHNICAL, true case 638: return KnxManufacturer_M_ABB___RESERVED, true case 639: @@ -8972,8 +8972,8 @@ func KnxManufacturerByName(value string) (enum KnxManufacturer, ok bool) { return KnxManufacturer_M_SECURI_FLEX_LTD, true case "M_BOKE": return KnxManufacturer_M_BOKE, true - case "M_SBR_SMART_CONTROL": - return KnxManufacturer_M_SBR_SMART_CONTROL, true + case "M_SBR_SYSTEM_TECHNICAL": + return KnxManufacturer_M_SBR_SYSTEM_TECHNICAL, true case "M_ABB___RESERVED": return KnxManufacturer_M_ABB___RESERVED, true case "M_BUSCH_JAEGER_ELEKTRO___RESERVED": @@ -10319,8 +10319,8 @@ func (e KnxManufacturer) PLC4XEnumName() string { return "M_SECURI_FLEX_LTD" case KnxManufacturer_M_BOKE: return "M_BOKE" - case KnxManufacturer_M_SBR_SMART_CONTROL: - return "M_SBR_SMART_CONTROL" + case KnxManufacturer_M_SBR_SYSTEM_TECHNICAL: + return "M_SBR_SYSTEM_TECHNICAL" case KnxManufacturer_M_ABB___RESERVED: return "M_ABB___RESERVED" case KnxManufacturer_M_BUSCH_JAEGER_ELEKTRO___RESERVED: diff --git a/plc4go/spi/model/DefaultPlcSubscriptionRequestBuilder_plc4xgen.go b/plc4go/spi/model/DefaultPlcSubscriptionRequestBuilder_plc4xgen.go index bf15058ecb2..5d948072338 100644 --- a/plc4go/spi/model/DefaultPlcSubscriptionRequestBuilder_plc4xgen.go +++ b/plc4go/spi/model/DefaultPlcSubscriptionRequestBuilder_plc4xgen.go @@ -95,10 +95,23 @@ func (d *DefaultPlcSubscriptionRequestBuilder) SerializeWithWriteBuffer(ctx cont return err } for name, elem := range d.types { - _value := fmt.Sprintf("%v", elem) - if err := writeBuffer.WriteString(name, uint32(len(_value)*8), "UTF-8", _value); err != nil { - return err + var elem any = elem + if serializable, ok := elem.(utils.Serializable); ok { + if err := writeBuffer.PushContext(name); err != nil { + return err + } + if err := serializable.SerializeWithWriteBuffer(ctx, writeBuffer); err != nil { + return err + } + if err := writeBuffer.PopContext(name); err != nil { + return err + } + } else { + elemAsString := fmt.Sprintf("%v", elem) + if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil { + return err + } } } if err := writeBuffer.PopContext("types", utils.WithRenderAsList(true)); err != nil { diff --git a/plc4go/spi/model/DefaultPlcSubscriptionRequest_plc4xgen.go b/plc4go/spi/model/DefaultPlcSubscriptionRequest_plc4xgen.go index cfd96574c97..c05822e2bf6 100644 --- a/plc4go/spi/model/DefaultPlcSubscriptionRequest_plc4xgen.go +++ b/plc4go/spi/model/DefaultPlcSubscriptionRequest_plc4xgen.go @@ -49,10 +49,23 @@ func (d *DefaultPlcSubscriptionRequest) SerializeWithWriteBuffer(ctx context.Con return err } for name, elem := range d.types { - _value := fmt.Sprintf("%v", elem) - if err := writeBuffer.WriteString(name, uint32(len(_value)*8), "UTF-8", _value); err != nil { - return err + var elem any = elem + if serializable, ok := elem.(utils.Serializable); ok { + if err := writeBuffer.PushContext(name); err != nil { + return err + } + if err := serializable.SerializeWithWriteBuffer(ctx, writeBuffer); err != nil { + return err + } + if err := writeBuffer.PopContext(name); err != nil { + return err + } + } else { + elemAsString := fmt.Sprintf("%v", elem) + if err := writeBuffer.WriteString(name, uint32(len(elemAsString)*8), "UTF-8", elemAsString); err != nil { + return err + } } } if err := writeBuffer.PopContext("types", utils.WithRenderAsList(true)); err != nil { diff --git a/plc4go/spi/model/mock_PlcTag_test.go b/plc4go/spi/model/mock_PlcTag_test.go index 0ed86f7cbe6..488b49ed245 100644 --- a/plc4go/spi/model/mock_PlcTag_test.go +++ b/plc4go/spi/model/mock_PlcTag_test.go @@ -166,6 +166,47 @@ func (_c *MockPlcTag_GetValueType_Call) RunAndReturn(run func() values.PlcValueT return _c } +// String provides a mock function with given fields: +func (_m *MockPlcTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockPlcTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockPlcTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockPlcTag_Expecter) String() *MockPlcTag_String_Call { + return &MockPlcTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockPlcTag_String_Call) Run(run func()) *MockPlcTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPlcTag_String_Call) Return(_a0 string) *MockPlcTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPlcTag_String_Call) RunAndReturn(run func() string) *MockPlcTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockPlcTag creates a new instance of MockPlcTag. 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 NewMockPlcTag(t interface { diff --git a/plc4go/spi/model/render_test.go b/plc4go/spi/model/render_test.go index 94081366b5e..4e799203923 100644 --- a/plc4go/spi/model/render_test.go +++ b/plc4go/spi/model/render_test.go @@ -110,7 +110,7 @@ func TestRenderTestCustom(t *testing.T) { }{ { sut: NewDefaultPlcBrowseItem( - NewMockPlcTag(t), + mockTag(t), "some name", "some datatype", true, @@ -389,3 +389,9 @@ func TestRenderTestCustom(t *testing.T) { }) } } + +func mockTag(t *testing.T) *MockPlcTag { + tag := NewMockPlcTag(t) + tag.EXPECT().String().Return("mocktag").Maybe() + return tag +} diff --git a/plc4go/spi/values/PlcValueHandler_test.go b/plc4go/spi/values/PlcValueHandler_test.go index a29939484af..b30fd339b74 100644 --- a/plc4go/spi/values/PlcValueHandler_test.go +++ b/plc4go/spi/values/PlcValueHandler_test.go @@ -51,6 +51,7 @@ func TestDefaultValueHandler_NewPlcValue(t *testing.T) { expect := tag.EXPECT() expect.GetArrayInfo().Return(nil) expect.GetValueType().Return(apiValues.BOOL) + expect.String().Return("mock") args.tag = tag }, want: NewPlcBOOL(true), @@ -703,6 +704,7 @@ func TestDefaultValueHandler_ParseListType(t *testing.T) { setup: func(t *testing.T, args *args) { tag := NewMockPlcTag(t) tag.EXPECT().GetValueType().Return(apiValues.BOOL) + tag.EXPECT().String().Return("mock") args.tag = tag }, want: NewPlcBOOL(true), @@ -743,6 +745,7 @@ func TestDefaultValueHandler_ParseListType(t *testing.T) { { tag := NewMockPlcTag(t) tag.EXPECT().GetValueType().Return(apiValues.BOOL) + tag.EXPECT().String().Return("mock") args.tag = tag } { @@ -792,6 +795,7 @@ func TestDefaultValueHandler_ParseSimpleType(t *testing.T) { setup: func(t *testing.T, args *args) { tag := NewMockPlcTag(t) tag.EXPECT().GetValueType().Return(apiValues.BOOL) + tag.EXPECT().String().Return("mock") args.tag = tag }, want: NewPlcBOOL(true), @@ -862,6 +866,7 @@ func TestDefaultValueHandler_parseType(t *testing.T) { { tag := NewMockPlcTag(t) tag.EXPECT().GetValueType().Return(apiValues.BOOL) + tag.EXPECT().String().Return("mock") args.tag = tag } { @@ -883,6 +888,7 @@ func TestDefaultValueHandler_parseType(t *testing.T) { setup: func(t *testing.T, args *args) { tag := NewMockPlcTag(t) tag.EXPECT().GetValueType().Return(apiValues.Struct) + tag.EXPECT().String().Return("mock") args.tag = tag }, wantErr: assert.Error, @@ -895,6 +901,7 @@ func TestDefaultValueHandler_parseType(t *testing.T) { setup: func(t *testing.T, args *args) { tag := NewMockPlcTag(t) tag.EXPECT().GetValueType().Return(apiValues.BOOL) + tag.EXPECT().String().Return("mock") args.tag = tag }, want: NewPlcBOOL(true), diff --git a/plc4go/spi/values/mock_PlcTag_test.go b/plc4go/spi/values/mock_PlcTag_test.go index 3b62ff8a064..1b28b0aeaa5 100644 --- a/plc4go/spi/values/mock_PlcTag_test.go +++ b/plc4go/spi/values/mock_PlcTag_test.go @@ -166,6 +166,47 @@ func (_c *MockPlcTag_GetValueType_Call) RunAndReturn(run func() apivalues.PlcVal return _c } +// String provides a mock function with given fields: +func (_m *MockPlcTag) String() string { + ret := _m.Called() + + var r0 string + if rf, ok := ret.Get(0).(func() string); ok { + r0 = rf() + } else { + r0 = ret.Get(0).(string) + } + + return r0 +} + +// MockPlcTag_String_Call is a *mock.Call that shadows Run/Return methods with type explicit version for method 'String' +type MockPlcTag_String_Call struct { + *mock.Call +} + +// String is a helper method to define mock.On call +func (_e *MockPlcTag_Expecter) String() *MockPlcTag_String_Call { + return &MockPlcTag_String_Call{Call: _e.mock.On("String")} +} + +func (_c *MockPlcTag_String_Call) Run(run func()) *MockPlcTag_String_Call { + _c.Call.Run(func(args mock.Arguments) { + run() + }) + return _c +} + +func (_c *MockPlcTag_String_Call) Return(_a0 string) *MockPlcTag_String_Call { + _c.Call.Return(_a0) + return _c +} + +func (_c *MockPlcTag_String_Call) RunAndReturn(run func() string) *MockPlcTag_String_Call { + _c.Call.Return(run) + return _c +} + // NewMockPlcTag creates a new instance of MockPlcTag. 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 NewMockPlcTag(t interface { diff --git a/plc4j/drivers/knxnetip/src/main/generated/org/apache/plc4x/java/knxnetip/readwrite/KnxManufacturer.java b/plc4j/drivers/knxnetip/src/main/generated/org/apache/plc4x/java/knxnetip/readwrite/KnxManufacturer.java index 0d5c7c3b7f9..47825335f4a 100644 --- a/plc4j/drivers/knxnetip/src/main/generated/org/apache/plc4x/java/knxnetip/readwrite/KnxManufacturer.java +++ b/plc4j/drivers/knxnetip/src/main/generated/org/apache/plc4x/java/knxnetip/readwrite/KnxManufacturer.java @@ -731,7 +731,7 @@ public enum KnxManufacturer { M_SEXANKA((int) 634, (int) 691, (String) "SEXANKA"), M_SECURI_FLEX_LTD((int) 635, (int) 692, (String) "Securi-Flex Ltd"), M_BOKE((int) 636, (int) 693, (String) "BOKE"), - M_SBR_SMART_CONTROL((int) 637, (int) 695, (String) "SBR Smart Control"), + M_SBR_SYSTEM_TECHNICAL((int) 637, (int) 695, (String) "SBR System Technical"), M_ABB___RESERVED((int) 638, (int) 43954, (String) "ABB - reserved"), M_BUSCH_JAEGER_ELEKTRO___RESERVED( (int) 639, (int) 43959, (String) "Busch-Jaeger Elektro - reserved");