This is an automated email from the ASF dual-hosted git repository.
sruehl pushed a commit to branch develop
in repository https://gitbox.apache.org/repos/asf/plc4x.git
The following commit(s) were added to refs/heads/develop by this push:
new b8ad48ea50 fix(plc4go): post merge cleanup
b8ad48ea50 is described below
commit b8ad48ea5084bf61eda12e16c6d4c2cffc674321
Author: Sebastian Rühl <[email protected]>
AuthorDate: Thu May 28 10:31:54 2026 +0200
fix(plc4go): post merge cleanup
---
.asf.yaml | 61 +++--
plc4go/go.mod | 1 -
plc4go/go.sum | 2 -
plc4go/pkg/api/cache/mocks_test.go | 33 +++
plc4go/pkg/api/mocks_test.go | 33 +++
plc4go/spi/TransportErrorHandler.go | 19 ++
plc4go/spi/default/defaultCodec_plc4xgen.go | 19 ++
plc4go/spi/default/defaultConnection_plc4xgen.go | 4 +
plc4go/spi/default/mocks_test.go | 332 ++++++++++++++---------
plc4go/spi/mocks_test.go | 67 +++++
plc4go/spi/testutils/mocks_test.go | 51 ++++
plc4go/spi/transports/errors.go | 19 ++
plc4go/spi/transports/mocks_test.go | 142 ++++------
plc4go/spi/utils/base64Stringer.go | 72 ++---
14 files changed, 564 insertions(+), 291 deletions(-)
diff --git a/.asf.yaml b/.asf.yaml
index 497ed10b00..f7c077e998 100644
--- a/.asf.yaml
+++ b/.asf.yaml
@@ -27,24 +27,24 @@ github:
dependabot_updates: false
labels:
- - java
- - cpp
- - c
- - go
- - python
- - net
- - ab
- - ads
- - ethernetip
- - firmata
- - knx
- - modbus
- - opcua
- - s7
- - siemens
- - bacnet
- - can
- - iot
+ - java
+ - cpp
+ - c
+ - go
+ - python
+ - net
+ - ab
+ - ads
+ - ethernetip
+ - firmata
+ - knx
+ - modbus
+ - opcua
+ - s7
+ - siemens
+ - bacnet
+ - can
+ - iot
features:
wiki: true
@@ -81,18 +81,19 @@ github:
delete_comment_discussion: "Re: [D] {title}"
rulesets:
- - name: "Default Branch Protection"
- type: branch
- branches:
- includes:
- - "~DEFAULT_BRANCH"
- - "release/*"
- - "rel/*"
- excludes: []
- bypass_teams:
- - root
- restrict_deletion: true
- restrict_force_push: true
+ - name: "Default Branch Protection"
+ type: branch
+ branches:
+ includes:
+ - "~DEFAULT_BRANCH"
+ - "release/*"
+ - "rel/*"
+ excludes: [ ]
+ bypass_teams:
+ - root
+ restrict_deletion: true
+ restrict_force_push: true
+
notifications:
commits: [email protected]
issues: [email protected]
diff --git a/plc4go/go.mod b/plc4go/go.mod
index ac3de759d8..c989b14ae0 100644
--- a/plc4go/go.mod
+++ b/plc4go/go.mod
@@ -29,7 +29,6 @@ require (
github.com/google/uuid v1.6.0
github.com/gopacket/gopacket v1.6.0
github.com/jacobsa/go-serial v0.0.0-20180131005756-15cf729a72d4
- github.com/pkg/errors v0.9.1
github.com/rs/zerolog v1.35.1
github.com/stretchr/testify v1.11.1
golang.org/x/net v0.55.0
diff --git a/plc4go/go.sum b/plc4go/go.sum
index fd3740d6bc..6d0be1e259 100644
--- a/plc4go/go.sum
+++ b/plc4go/go.sum
@@ -25,8 +25,6 @@ github.com/mattn/go-colorable v0.1.14/go.mod
h1:6LmQG8QLFO4G5z1gPvYEzlUgJ2wF+stg
github.com/mattn/go-isatty v0.0.22
h1:j8l17JJ9i6VGPUFUYoTUKPSgKe/83EYU2zBC7YNKMw4=
github.com/mattn/go-isatty v0.0.22/go.mod
h1:ZXfXG4SQHsB/w3ZeOYbR0PrPwLy+n6xiMrJlRFqopa4=
github.com/pkg/diff v0.0.0-20210226163009-20ebb0f2a09e/go.mod
h1:pJLUxLENpZxwdsKMEsNbx1VGcRFpLqf3715MtcvvzbA=
-github.com/pkg/errors v0.9.1 h1:FEBLx1zS214owpjy7qsBeixbURkuhQAwrK5UwLGTwt4=
-github.com/pkg/errors v0.9.1/go.mod
h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2
h1:Jamvg5psRIccs7FGNTlIRMkT8wgtp5eCXdBlqhYGL6U=
github.com/pmezard/go-difflib v1.0.1-0.20181226105442-5d4384ee4fb2/go.mod
h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
github.com/rogpeppe/go-internal v1.9.0/go.mod
h1:WtVeX8xhTBvf0smdhujwtBcq4Qrzq/fJaraNFVN+nFs=
diff --git a/plc4go/pkg/api/cache/mocks_test.go
b/plc4go/pkg/api/cache/mocks_test.go
index b90f26a087..1892d463d8 100644
--- a/plc4go/pkg/api/cache/mocks_test.go
+++ b/plc4go/pkg/api/cache/mocks_test.go
@@ -615,6 +615,39 @@ func (_c *mocktracedPlcConnection_GetTracer_Call)
RunAndReturn(run func() tracer
return _c
}
+// Invalidate provides a mock function for the type mocktracedPlcConnection
+func (_mock *mocktracedPlcConnection) Invalidate() {
+ _mock.Called()
+ return
+}
+
+// mocktracedPlcConnection_Invalidate_Call is a *mock.Call that shadows
Run/Return methods with type explicit version for method 'Invalidate'
+type mocktracedPlcConnection_Invalidate_Call struct {
+ *mock.Call
+}
+
+// Invalidate is a helper method to define mock.On call
+func (_e *mocktracedPlcConnection_Expecter) Invalidate()
*mocktracedPlcConnection_Invalidate_Call {
+ return &mocktracedPlcConnection_Invalidate_Call{Call:
_e.mock.On("Invalidate")}
+}
+
+func (_c *mocktracedPlcConnection_Invalidate_Call) Run(run func())
*mocktracedPlcConnection_Invalidate_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *mocktracedPlcConnection_Invalidate_Call) Return()
*mocktracedPlcConnection_Invalidate_Call {
+ _c.Call.Return()
+ return _c
+}
+
+func (_c *mocktracedPlcConnection_Invalidate_Call) RunAndReturn(run func())
*mocktracedPlcConnection_Invalidate_Call {
+ _c.Run(run)
+ return _c
+}
+
// IsConnected provides a mock function for the type mocktracedPlcConnection
func (_mock *mocktracedPlcConnection) IsConnected() bool {
ret := _mock.Called()
diff --git a/plc4go/pkg/api/mocks_test.go b/plc4go/pkg/api/mocks_test.go
index 83d5ae6d63..c87a5f32c3 100644
--- a/plc4go/pkg/api/mocks_test.go
+++ b/plc4go/pkg/api/mocks_test.go
@@ -247,6 +247,39 @@ func (_c *MockPlcConnection_GetMetadata_Call)
RunAndReturn(run func() model.PlcC
return _c
}
+// Invalidate provides a mock function for the type MockPlcConnection
+func (_mock *MockPlcConnection) Invalidate() {
+ _mock.Called()
+ return
+}
+
+// MockPlcConnection_Invalidate_Call is a *mock.Call that shadows Run/Return
methods with type explicit version for method 'Invalidate'
+type MockPlcConnection_Invalidate_Call struct {
+ *mock.Call
+}
+
+// Invalidate is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) Invalidate()
*MockPlcConnection_Invalidate_Call {
+ return &MockPlcConnection_Invalidate_Call{Call:
_e.mock.On("Invalidate")}
+}
+
+func (_c *MockPlcConnection_Invalidate_Call) Run(run func())
*MockPlcConnection_Invalidate_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_Invalidate_Call) Return()
*MockPlcConnection_Invalidate_Call {
+ _c.Call.Return()
+ return _c
+}
+
+func (_c *MockPlcConnection_Invalidate_Call) RunAndReturn(run func())
*MockPlcConnection_Invalidate_Call {
+ _c.Run(run)
+ return _c
+}
+
// IsConnected provides a mock function for the type MockPlcConnection
func (_mock *MockPlcConnection) IsConnected() bool {
ret := _mock.Called()
diff --git a/plc4go/spi/TransportErrorHandler.go
b/plc4go/spi/TransportErrorHandler.go
index 8002edecec..5f06e840aa 100644
--- a/plc4go/spi/TransportErrorHandler.go
+++ b/plc4go/spi/TransportErrorHandler.go
@@ -1,3 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
package spi
import "github.com/apache/plc4x/plc4go/spi/transports"
diff --git a/plc4go/spi/default/defaultCodec_plc4xgen.go
b/plc4go/spi/default/defaultCodec_plc4xgen.go
index 8309659824..a5a81c0f6f 100644
--- a/plc4go/spi/default/defaultCodec_plc4xgen.go
+++ b/plc4go/spi/default/defaultCodec_plc4xgen.go
@@ -157,6 +157,25 @@ func (d *defaultCodec) SerializeWithWriteBuffer(ctx
context.Context, writeBuffer
}
}
}
+
+ if d.transportErrorHandler != nil {
+ if serializableField, ok :=
any(d.transportErrorHandler).(utils.Serializable); ok {
+ if err :=
writeBuffer.PushContext("transportErrorHandler"); err != nil {
+ return err
+ }
+ if err :=
serializableField.SerializeWithWriteBuffer(ctx, writeBuffer); err != nil {
+ return err
+ }
+ if err :=
writeBuffer.PopContext("transportErrorHandler"); err != nil {
+ return err
+ }
+ } else {
+ stringValue := fmt.Sprintf("%v",
d.transportErrorHandler)
+ if err :=
writeBuffer.WriteString("transportErrorHandler", uint32(len(stringValue)*8),
stringValue); err != nil {
+ return err
+ }
+ }
+ }
if err := writeBuffer.PopContext("defaultCodec"); err != nil {
return err
}
diff --git a/plc4go/spi/default/defaultConnection_plc4xgen.go
b/plc4go/spi/default/defaultConnection_plc4xgen.go
index df48556ac6..b3841b8eac 100644
--- a/plc4go/spi/default/defaultConnection_plc4xgen.go
+++ b/plc4go/spi/default/defaultConnection_plc4xgen.go
@@ -53,6 +53,10 @@ func (d *defaultConnection) SerializeWithWriteBuffer(ctx
context.Context, writeB
return err
}
+ if err := writeBuffer.WriteBit("invalidated", d.invalidated.Load());
err != nil {
+ return err
+ }
+
if d.tagHandler != nil {
if serializableField, ok :=
any(d.tagHandler).(utils.Serializable); ok {
if err := writeBuffer.PushContext("tagHandler"); err !=
nil {
diff --git a/plc4go/spi/default/mocks_test.go b/plc4go/spi/default/mocks_test.go
index 08ac97bd52..a3ac75cba8 100644
--- a/plc4go/spi/default/mocks_test.go
+++ b/plc4go/spi/default/mocks_test.go
@@ -771,46 +771,6 @@ func (_c *MockDefaultCodec_GetTransportInstance_Call)
RunAndReturn(run func() tr
return _c
}
-// SetTransportErrorHandler provides a mock function for the type
MockDefaultCodec
-func (_mock *MockDefaultCodec) SetTransportErrorHandler(handler
transports.TransportErrorHandler) {
- _mock.Called(handler)
- return
-}
-
-// MockDefaultCodec_SetTransportErrorHandler_Call is a *mock.Call that shadows
Run/Return methods with type explicit version for method
'SetTransportErrorHandler'
-type MockDefaultCodec_SetTransportErrorHandler_Call struct {
- *mock.Call
-}
-
-// SetTransportErrorHandler is a helper method to define mock.On call
-// - handler transports.TransportErrorHandler
-func (_e *MockDefaultCodec_Expecter) SetTransportErrorHandler(handler
interface{}) *MockDefaultCodec_SetTransportErrorHandler_Call {
- return &MockDefaultCodec_SetTransportErrorHandler_Call{Call:
_e.mock.On("SetTransportErrorHandler", handler)}
-}
-
-func (_c *MockDefaultCodec_SetTransportErrorHandler_Call) Run(run func(handler
transports.TransportErrorHandler))
*MockDefaultCodec_SetTransportErrorHandler_Call {
- _c.Call.Run(func(args mock.Arguments) {
- var arg0 transports.TransportErrorHandler
- if args[0] != nil {
- arg0 = args[0].(transports.TransportErrorHandler)
- }
- run(
- arg0,
- )
- })
- return _c
-}
-
-func (_c *MockDefaultCodec_SetTransportErrorHandler_Call) Return()
*MockDefaultCodec_SetTransportErrorHandler_Call {
- _c.Call.Return()
- return _c
-}
-
-func (_c *MockDefaultCodec_SetTransportErrorHandler_Call) RunAndReturn(run
func(handler transports.TransportErrorHandler))
*MockDefaultCodec_SetTransportErrorHandler_Call {
- _c.Run(run)
- return _c
-}
-
// IsRunning provides a mock function for the type MockDefaultCodec
func (_mock *MockDefaultCodec) IsRunning() bool {
ret := _mock.Called()
@@ -1111,6 +1071,46 @@ func (_c
*MockDefaultCodec_SerializeWithWriteBuffer_Call) RunAndReturn(run func(
return _c
}
+// SetTransportErrorHandler provides a mock function for the type
MockDefaultCodec
+func (_mock *MockDefaultCodec) SetTransportErrorHandler(handler
transports.TransportErrorHandler) {
+ _mock.Called(handler)
+ return
+}
+
+// MockDefaultCodec_SetTransportErrorHandler_Call is a *mock.Call that shadows
Run/Return methods with type explicit version for method
'SetTransportErrorHandler'
+type MockDefaultCodec_SetTransportErrorHandler_Call struct {
+ *mock.Call
+}
+
+// SetTransportErrorHandler is a helper method to define mock.On call
+// - handler transports.TransportErrorHandler
+func (_e *MockDefaultCodec_Expecter) SetTransportErrorHandler(handler
interface{}) *MockDefaultCodec_SetTransportErrorHandler_Call {
+ return &MockDefaultCodec_SetTransportErrorHandler_Call{Call:
_e.mock.On("SetTransportErrorHandler", handler)}
+}
+
+func (_c *MockDefaultCodec_SetTransportErrorHandler_Call) Run(run func(handler
transports.TransportErrorHandler))
*MockDefaultCodec_SetTransportErrorHandler_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ var arg0 transports.TransportErrorHandler
+ if args[0] != nil {
+ arg0 = args[0].(transports.TransportErrorHandler)
+ }
+ run(
+ arg0,
+ )
+ })
+ return _c
+}
+
+func (_c *MockDefaultCodec_SetTransportErrorHandler_Call) Return()
*MockDefaultCodec_SetTransportErrorHandler_Call {
+ _c.Call.Return()
+ return _c
+}
+
+func (_c *MockDefaultCodec_SetTransportErrorHandler_Call) RunAndReturn(run
func(handler transports.TransportErrorHandler))
*MockDefaultCodec_SetTransportErrorHandler_Call {
+ _c.Run(run)
+ return _c
+}
+
// NewMockDefaultConnectionRequirements creates a new instance of
MockDefaultConnectionRequirements. 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 NewMockDefaultConnectionRequirements(t interface {
@@ -1580,6 +1580,39 @@ func (_c
*MockDefaultConnection_GetTransportInstance_Call) RunAndReturn(run func
return _c
}
+// Invalidate provides a mock function for the type MockDefaultConnection
+func (_mock *MockDefaultConnection) Invalidate() {
+ _mock.Called()
+ return
+}
+
+// MockDefaultConnection_Invalidate_Call is a *mock.Call that shadows
Run/Return methods with type explicit version for method 'Invalidate'
+type MockDefaultConnection_Invalidate_Call struct {
+ *mock.Call
+}
+
+// Invalidate is a helper method to define mock.On call
+func (_e *MockDefaultConnection_Expecter) Invalidate()
*MockDefaultConnection_Invalidate_Call {
+ return &MockDefaultConnection_Invalidate_Call{Call:
_e.mock.On("Invalidate")}
+}
+
+func (_c *MockDefaultConnection_Invalidate_Call) Run(run func())
*MockDefaultConnection_Invalidate_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockDefaultConnection_Invalidate_Call) Return()
*MockDefaultConnection_Invalidate_Call {
+ _c.Call.Return()
+ return _c
+}
+
+func (_c *MockDefaultConnection_Invalidate_Call) RunAndReturn(run func())
*MockDefaultConnection_Invalidate_Call {
+ _c.Run(run)
+ return _c
+}
+
// IsConnected provides a mock function for the type MockDefaultConnection
func (_mock *MockDefaultConnection) IsConnected() bool {
ret := _mock.Called()
@@ -1624,6 +1657,50 @@ func (_c *MockDefaultConnection_IsConnected_Call)
RunAndReturn(run func() bool)
return _c
}
+// IsInvalidated provides a mock function for the type MockDefaultConnection
+func (_mock *MockDefaultConnection) IsInvalidated() bool {
+ ret := _mock.Called()
+
+ if len(ret) == 0 {
+ panic("no return value specified for IsInvalidated")
+ }
+
+ var r0 bool
+ if returnFunc, ok := ret.Get(0).(func() bool); ok {
+ r0 = returnFunc()
+ } else {
+ r0 = ret.Get(0).(bool)
+ }
+ return r0
+}
+
+// MockDefaultConnection_IsInvalidated_Call is a *mock.Call that shadows
Run/Return methods with type explicit version for method 'IsInvalidated'
+type MockDefaultConnection_IsInvalidated_Call struct {
+ *mock.Call
+}
+
+// IsInvalidated is a helper method to define mock.On call
+func (_e *MockDefaultConnection_Expecter) IsInvalidated()
*MockDefaultConnection_IsInvalidated_Call {
+ return &MockDefaultConnection_IsInvalidated_Call{Call:
_e.mock.On("IsInvalidated")}
+}
+
+func (_c *MockDefaultConnection_IsInvalidated_Call) Run(run func())
*MockDefaultConnection_IsInvalidated_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockDefaultConnection_IsInvalidated_Call) Return(b bool)
*MockDefaultConnection_IsInvalidated_Call {
+ _c.Call.Return(b)
+ return _c
+}
+
+func (_c *MockDefaultConnection_IsInvalidated_Call) RunAndReturn(run func()
bool) *MockDefaultConnection_IsInvalidated_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
// Ping provides a mock function for the type MockDefaultConnection
func (_mock *MockDefaultConnection) Ping(ctx context.Context) error {
ret := _mock.Called(ctx)
@@ -3039,6 +3116,39 @@ func (_c *MockPlcConnection_GetMetadata_Call)
RunAndReturn(run func() model.PlcC
return _c
}
+// Invalidate provides a mock function for the type MockPlcConnection
+func (_mock *MockPlcConnection) Invalidate() {
+ _mock.Called()
+ return
+}
+
+// MockPlcConnection_Invalidate_Call is a *mock.Call that shadows Run/Return
methods with type explicit version for method 'Invalidate'
+type MockPlcConnection_Invalidate_Call struct {
+ *mock.Call
+}
+
+// Invalidate is a helper method to define mock.On call
+func (_e *MockPlcConnection_Expecter) Invalidate()
*MockPlcConnection_Invalidate_Call {
+ return &MockPlcConnection_Invalidate_Call{Call:
_e.mock.On("Invalidate")}
+}
+
+func (_c *MockPlcConnection_Invalidate_Call) Run(run func())
*MockPlcConnection_Invalidate_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ run()
+ })
+ return _c
+}
+
+func (_c *MockPlcConnection_Invalidate_Call) Return()
*MockPlcConnection_Invalidate_Call {
+ _c.Call.Return()
+ return _c
+}
+
+func (_c *MockPlcConnection_Invalidate_Call) RunAndReturn(run func())
*MockPlcConnection_Invalidate_Call {
+ _c.Run(run)
+ return _c
+}
+
// IsConnected provides a mock function for the type MockPlcConnection
func (_mock *MockPlcConnection) IsConnected() bool {
ret := _mock.Called()
@@ -4362,6 +4472,57 @@ func (_m *MockTransportInstance) EXPECT()
*MockTransportInstance_Expecter {
return &MockTransportInstance_Expecter{mock: &_m.Mock}
}
+// ClassifyError provides a mock function for the type MockTransportInstance
+func (_mock *MockTransportInstance) ClassifyError(err error)
transports.TransportErrorKind {
+ ret := _mock.Called(err)
+
+ if len(ret) == 0 {
+ panic("no return value specified for ClassifyError")
+ }
+
+ var r0 transports.TransportErrorKind
+ if returnFunc, ok := ret.Get(0).(func(error)
transports.TransportErrorKind); ok {
+ r0 = returnFunc(err)
+ } else {
+ r0 = ret.Get(0).(transports.TransportErrorKind)
+ }
+ return r0
+}
+
+// MockTransportInstance_ClassifyError_Call is a *mock.Call that shadows
Run/Return methods with type explicit version for method 'ClassifyError'
+type MockTransportInstance_ClassifyError_Call struct {
+ *mock.Call
+}
+
+// ClassifyError is a helper method to define mock.On call
+// - err error
+func (_e *MockTransportInstance_Expecter) ClassifyError(err interface{})
*MockTransportInstance_ClassifyError_Call {
+ return &MockTransportInstance_ClassifyError_Call{Call:
_e.mock.On("ClassifyError", err)}
+}
+
+func (_c *MockTransportInstance_ClassifyError_Call) Run(run func(err error))
*MockTransportInstance_ClassifyError_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ var arg0 error
+ if args[0] != nil {
+ arg0 = args[0].(error)
+ }
+ run(
+ arg0,
+ )
+ })
+ return _c
+}
+
+func (_c *MockTransportInstance_ClassifyError_Call) Return(transportErrorKind
transports.TransportErrorKind) *MockTransportInstance_ClassifyError_Call {
+ _c.Call.Return(transportErrorKind)
+ return _c
+}
+
+func (_c *MockTransportInstance_ClassifyError_Call) RunAndReturn(run func(err
error) transports.TransportErrorKind) *MockTransportInstance_ClassifyError_Call
{
+ _c.Call.Return(run)
+ return _c
+}
+
// Close provides a mock function for the type MockTransportInstance
func (_mock *MockTransportInstance) Close() error {
ret := _mock.Called()
@@ -4567,57 +4728,6 @@ func (_c
*MockTransportInstance_GetNumBytesAvailableInBuffer_Call) RunAndReturn(
return _c
}
-// ClassifyError provides a mock function for the type MockTransportInstance
-func (_mock *MockTransportInstance) ClassifyError(err error)
transports.TransportErrorKind {
- ret := _mock.Called(err)
-
- if len(ret) == 0 {
- panic("no return value specified for ClassifyError")
- }
-
- var r0 transports.TransportErrorKind
- if returnFunc, ok := ret.Get(0).(func(error)
transports.TransportErrorKind); ok {
- r0 = returnFunc(err)
- } else {
- r0 = ret.Get(0).(transports.TransportErrorKind)
- }
- return r0
-}
-
-// MockTransportInstance_ClassifyError_Call is a *mock.Call that shadows
Run/Return methods with type explicit version for method 'ClassifyError'
-type MockTransportInstance_ClassifyError_Call struct {
- *mock.Call
-}
-
-// ClassifyError is a helper method to define mock.On call
-// - err error
-func (_e *MockTransportInstance_Expecter) ClassifyError(err interface{})
*MockTransportInstance_ClassifyError_Call {
- return &MockTransportInstance_ClassifyError_Call{Call:
_e.mock.On("ClassifyError", err)}
-}
-
-func (_c *MockTransportInstance_ClassifyError_Call) Run(run func(err error))
*MockTransportInstance_ClassifyError_Call {
- _c.Call.Run(func(args mock.Arguments) {
- var arg0 error
- if args[0] != nil {
- arg0 = args[0].(error)
- }
- run(
- arg0,
- )
- })
- return _c
-}
-
-func (_c *MockTransportInstance_ClassifyError_Call) Return(kind
transports.TransportErrorKind) *MockTransportInstance_ClassifyError_Call {
- _c.Call.Return(kind)
- return _c
-}
-
-func (_c *MockTransportInstance_ClassifyError_Call) RunAndReturn(run func(err
error) transports.TransportErrorKind) *MockTransportInstance_ClassifyError_Call
{
- _c.Call.Return(run)
- return _c
-}
-
// IsConnected provides a mock function for the type MockTransportInstance
func (_mock *MockTransportInstance) IsConnected() bool {
ret := _mock.Called()
@@ -4798,46 +4908,6 @@ func (_c *MockTransportInstance_Read_Call)
RunAndReturn(run func(ctx context.Con
return _c
}
-// SetTransportErrorHandler provides a mock function for the type
MockTransportInstance
-func (_mock *MockTransportInstance) SetTransportErrorHandler(handler
transports.TransportErrorHandler) {
- _mock.Called(handler)
- return
-}
-
-// MockTransportInstance_SetTransportErrorHandler_Call is a *mock.Call that
shadows Run/Return methods with type explicit version for method
'SetTransportErrorHandler'
-type MockTransportInstance_SetTransportErrorHandler_Call struct {
- *mock.Call
-}
-
-// SetTransportErrorHandler is a helper method to define mock.On call
-// - handler transports.TransportErrorHandler
-func (_e *MockTransportInstance_Expecter) SetTransportErrorHandler(handler
interface{}) *MockTransportInstance_SetTransportErrorHandler_Call {
- return &MockTransportInstance_SetTransportErrorHandler_Call{Call:
_e.mock.On("SetTransportErrorHandler", handler)}
-}
-
-func (_c *MockTransportInstance_SetTransportErrorHandler_Call) Run(run
func(handler transports.TransportErrorHandler))
*MockTransportInstance_SetTransportErrorHandler_Call {
- _c.Call.Run(func(args mock.Arguments) {
- var arg0 transports.TransportErrorHandler
- if args[0] != nil {
- arg0 = args[0].(transports.TransportErrorHandler)
- }
- run(
- arg0,
- )
- })
- return _c
-}
-
-func (_c *MockTransportInstance_SetTransportErrorHandler_Call) Return()
*MockTransportInstance_SetTransportErrorHandler_Call {
- _c.Call.Return()
- return _c
-}
-
-func (_c *MockTransportInstance_SetTransportErrorHandler_Call)
RunAndReturn(run func(handler transports.TransportErrorHandler))
*MockTransportInstance_SetTransportErrorHandler_Call {
- _c.Call.Return(run)
- return _c
-}
-
// Reset provides a mock function for the type MockTransportInstance
func (_mock *MockTransportInstance) Reset() {
_mock.Called()
diff --git a/plc4go/spi/mocks_test.go b/plc4go/spi/mocks_test.go
index fdc4bbc88d..a5a44ae72b 100644
--- a/plc4go/spi/mocks_test.go
+++ b/plc4go/spi/mocks_test.go
@@ -2885,6 +2885,73 @@ func (_c *MockTransportAware_RegisterTransport_Call)
RunAndReturn(run func(trans
return _c
}
+// NewMockTransportErrorHandlerSetter creates a new instance of
MockTransportErrorHandlerSetter. 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 NewMockTransportErrorHandlerSetter(t interface {
+ mock.TestingT
+ Cleanup(func())
+}) *MockTransportErrorHandlerSetter {
+ mock := &MockTransportErrorHandlerSetter{}
+ mock.Mock.Test(t)
+
+ t.Cleanup(func() { mock.AssertExpectations(t) })
+
+ return mock
+}
+
+// MockTransportErrorHandlerSetter is an autogenerated mock type for the
TransportErrorHandlerSetter type
+type MockTransportErrorHandlerSetter struct {
+ mock.Mock
+}
+
+type MockTransportErrorHandlerSetter_Expecter struct {
+ mock *mock.Mock
+}
+
+func (_m *MockTransportErrorHandlerSetter) EXPECT()
*MockTransportErrorHandlerSetter_Expecter {
+ return &MockTransportErrorHandlerSetter_Expecter{mock: &_m.Mock}
+}
+
+// SetTransportErrorHandler provides a mock function for the type
MockTransportErrorHandlerSetter
+func (_mock *MockTransportErrorHandlerSetter) SetTransportErrorHandler(handler
transports.TransportErrorHandler) {
+ _mock.Called(handler)
+ return
+}
+
+// MockTransportErrorHandlerSetter_SetTransportErrorHandler_Call is a
*mock.Call that shadows Run/Return methods with type explicit version for
method 'SetTransportErrorHandler'
+type MockTransportErrorHandlerSetter_SetTransportErrorHandler_Call struct {
+ *mock.Call
+}
+
+// SetTransportErrorHandler is a helper method to define mock.On call
+// - handler transports.TransportErrorHandler
+func (_e *MockTransportErrorHandlerSetter_Expecter)
SetTransportErrorHandler(handler interface{})
*MockTransportErrorHandlerSetter_SetTransportErrorHandler_Call {
+ return
&MockTransportErrorHandlerSetter_SetTransportErrorHandler_Call{Call:
_e.mock.On("SetTransportErrorHandler", handler)}
+}
+
+func (_c *MockTransportErrorHandlerSetter_SetTransportErrorHandler_Call)
Run(run func(handler transports.TransportErrorHandler))
*MockTransportErrorHandlerSetter_SetTransportErrorHandler_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ var arg0 transports.TransportErrorHandler
+ if args[0] != nil {
+ arg0 = args[0].(transports.TransportErrorHandler)
+ }
+ run(
+ arg0,
+ )
+ })
+ return _c
+}
+
+func (_c *MockTransportErrorHandlerSetter_SetTransportErrorHandler_Call)
Return() *MockTransportErrorHandlerSetter_SetTransportErrorHandler_Call {
+ _c.Call.Return()
+ return _c
+}
+
+func (_c *MockTransportErrorHandlerSetter_SetTransportErrorHandler_Call)
RunAndReturn(run func(handler transports.TransportErrorHandler))
*MockTransportErrorHandlerSetter_SetTransportErrorHandler_Call {
+ _c.Run(run)
+ return _c
+}
+
// NewMockTransportInstanceExposer creates a new instance of
MockTransportInstanceExposer. 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 NewMockTransportInstanceExposer(t interface {
diff --git a/plc4go/spi/testutils/mocks_test.go
b/plc4go/spi/testutils/mocks_test.go
index 569e99bf9e..99bef570fd 100644
--- a/plc4go/spi/testutils/mocks_test.go
+++ b/plc4go/spi/testutils/mocks_test.go
@@ -168,6 +168,57 @@ func (_m *MockTestTransportInstance) EXPECT()
*MockTestTransportInstance_Expecte
return &MockTestTransportInstance_Expecter{mock: &_m.Mock}
}
+// ClassifyError provides a mock function for the type
MockTestTransportInstance
+func (_mock *MockTestTransportInstance) ClassifyError(err error)
transports.TransportErrorKind {
+ ret := _mock.Called(err)
+
+ if len(ret) == 0 {
+ panic("no return value specified for ClassifyError")
+ }
+
+ var r0 transports.TransportErrorKind
+ if returnFunc, ok := ret.Get(0).(func(error)
transports.TransportErrorKind); ok {
+ r0 = returnFunc(err)
+ } else {
+ r0 = ret.Get(0).(transports.TransportErrorKind)
+ }
+ return r0
+}
+
+// MockTestTransportInstance_ClassifyError_Call is a *mock.Call that shadows
Run/Return methods with type explicit version for method 'ClassifyError'
+type MockTestTransportInstance_ClassifyError_Call struct {
+ *mock.Call
+}
+
+// ClassifyError is a helper method to define mock.On call
+// - err error
+func (_e *MockTestTransportInstance_Expecter) ClassifyError(err interface{})
*MockTestTransportInstance_ClassifyError_Call {
+ return &MockTestTransportInstance_ClassifyError_Call{Call:
_e.mock.On("ClassifyError", err)}
+}
+
+func (_c *MockTestTransportInstance_ClassifyError_Call) Run(run func(err
error)) *MockTestTransportInstance_ClassifyError_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ var arg0 error
+ if args[0] != nil {
+ arg0 = args[0].(error)
+ }
+ run(
+ arg0,
+ )
+ })
+ return _c
+}
+
+func (_c *MockTestTransportInstance_ClassifyError_Call)
Return(transportErrorKind transports.TransportErrorKind)
*MockTestTransportInstance_ClassifyError_Call {
+ _c.Call.Return(transportErrorKind)
+ return _c
+}
+
+func (_c *MockTestTransportInstance_ClassifyError_Call) RunAndReturn(run
func(err error) transports.TransportErrorKind)
*MockTestTransportInstance_ClassifyError_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
// Close provides a mock function for the type MockTestTransportInstance
func (_mock *MockTestTransportInstance) Close() error {
ret := _mock.Called()
diff --git a/plc4go/spi/transports/errors.go b/plc4go/spi/transports/errors.go
index a83f313298..11a82c86d7 100644
--- a/plc4go/spi/transports/errors.go
+++ b/plc4go/spi/transports/errors.go
@@ -1,3 +1,22 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
package transports
import (
diff --git a/plc4go/spi/transports/mocks_test.go
b/plc4go/spi/transports/mocks_test.go
index eebffe96c4..5e4ccd8819 100644
--- a/plc4go/spi/transports/mocks_test.go
+++ b/plc4go/spi/transports/mocks_test.go
@@ -546,6 +546,57 @@ func (_m *MockTransportInstance) EXPECT()
*MockTransportInstance_Expecter {
return &MockTransportInstance_Expecter{mock: &_m.Mock}
}
+// ClassifyError provides a mock function for the type MockTransportInstance
+func (_mock *MockTransportInstance) ClassifyError(err error)
TransportErrorKind {
+ ret := _mock.Called(err)
+
+ if len(ret) == 0 {
+ panic("no return value specified for ClassifyError")
+ }
+
+ var r0 TransportErrorKind
+ if returnFunc, ok := ret.Get(0).(func(error) TransportErrorKind); ok {
+ r0 = returnFunc(err)
+ } else {
+ r0 = ret.Get(0).(TransportErrorKind)
+ }
+ return r0
+}
+
+// MockTransportInstance_ClassifyError_Call is a *mock.Call that shadows
Run/Return methods with type explicit version for method 'ClassifyError'
+type MockTransportInstance_ClassifyError_Call struct {
+ *mock.Call
+}
+
+// ClassifyError is a helper method to define mock.On call
+// - err error
+func (_e *MockTransportInstance_Expecter) ClassifyError(err interface{})
*MockTransportInstance_ClassifyError_Call {
+ return &MockTransportInstance_ClassifyError_Call{Call:
_e.mock.On("ClassifyError", err)}
+}
+
+func (_c *MockTransportInstance_ClassifyError_Call) Run(run func(err error))
*MockTransportInstance_ClassifyError_Call {
+ _c.Call.Run(func(args mock.Arguments) {
+ var arg0 error
+ if args[0] != nil {
+ arg0 = args[0].(error)
+ }
+ run(
+ arg0,
+ )
+ })
+ return _c
+}
+
+func (_c *MockTransportInstance_ClassifyError_Call) Return(transportErrorKind
TransportErrorKind) *MockTransportInstance_ClassifyError_Call {
+ _c.Call.Return(transportErrorKind)
+ return _c
+}
+
+func (_c *MockTransportInstance_ClassifyError_Call) RunAndReturn(run func(err
error) TransportErrorKind) *MockTransportInstance_ClassifyError_Call {
+ _c.Call.Return(run)
+ return _c
+}
+
// Close provides a mock function for the type MockTransportInstance
func (_mock *MockTransportInstance) Close() error {
ret := _mock.Called()
@@ -751,57 +802,6 @@ func (_c
*MockTransportInstance_GetNumBytesAvailableInBuffer_Call) RunAndReturn(
return _c
}
-// ClassifyError provides a mock function for the type MockTransportInstance
-func (_mock *MockTransportInstance) ClassifyError(err error)
TransportErrorKind {
- ret := _mock.Called(err)
-
- if len(ret) == 0 {
- panic("no return value specified for ClassifyError")
- }
-
- var r0 TransportErrorKind
- if returnFunc, ok := ret.Get(0).(func(error) TransportErrorKind); ok {
- r0 = returnFunc(err)
- } else {
- r0 = ret.Get(0).(TransportErrorKind)
- }
- return r0
-}
-
-// MockTransportInstance_ClassifyError_Call is a *mock.Call that shadows
Run/Return methods with type explicit version for method 'ClassifyError'
-type MockTransportInstance_ClassifyError_Call struct {
- *mock.Call
-}
-
-// ClassifyError is a helper method to define mock.On call
-// - err error
-func (_e *MockTransportInstance_Expecter) ClassifyError(err interface{})
*MockTransportInstance_ClassifyError_Call {
- return &MockTransportInstance_ClassifyError_Call{Call:
_e.mock.On("ClassifyError", err)}
-}
-
-func (_c *MockTransportInstance_ClassifyError_Call) Run(run func(err error))
*MockTransportInstance_ClassifyError_Call {
- _c.Call.Run(func(args mock.Arguments) {
- var arg0 error
- if args[0] != nil {
- arg0 = args[0].(error)
- }
- run(
- arg0,
- )
- })
- return _c
-}
-
-func (_c *MockTransportInstance_ClassifyError_Call) Return(kind
TransportErrorKind) *MockTransportInstance_ClassifyError_Call {
- _c.Call.Return(kind)
- return _c
-}
-
-func (_c *MockTransportInstance_ClassifyError_Call) RunAndReturn(run func(err
error) TransportErrorKind) *MockTransportInstance_ClassifyError_Call {
- _c.Call.Return(run)
- return _c
-}
-
// IsConnected provides a mock function for the type MockTransportInstance
func (_mock *MockTransportInstance) IsConnected() bool {
ret := _mock.Called()
@@ -982,46 +982,6 @@ func (_c *MockTransportInstance_Read_Call)
RunAndReturn(run func(ctx context.Con
return _c
}
-// SetTransportErrorHandler provides a mock function for the type
MockTransportInstance
-func (_mock *MockTransportInstance) SetTransportErrorHandler(handler
TransportErrorHandler) {
- _mock.Called(handler)
- return
-}
-
-// MockTransportInstance_SetTransportErrorHandler_Call is a *mock.Call that
shadows Run/Return methods with type explicit version for method
'SetTransportErrorHandler'
-type MockTransportInstance_SetTransportErrorHandler_Call struct {
- *mock.Call
-}
-
-// SetTransportErrorHandler is a helper method to define mock.On call
-// - handler TransportErrorHandler
-func (_e *MockTransportInstance_Expecter) SetTransportErrorHandler(handler
interface{}) *MockTransportInstance_SetTransportErrorHandler_Call {
- return &MockTransportInstance_SetTransportErrorHandler_Call{Call:
_e.mock.On("SetTransportErrorHandler", handler)}
-}
-
-func (_c *MockTransportInstance_SetTransportErrorHandler_Call) Run(run
func(handler TransportErrorHandler))
*MockTransportInstance_SetTransportErrorHandler_Call {
- _c.Call.Run(func(args mock.Arguments) {
- var arg0 TransportErrorHandler
- if args[0] != nil {
- arg0 = args[0].(TransportErrorHandler)
- }
- run(
- arg0,
- )
- })
- return _c
-}
-
-func (_c *MockTransportInstance_SetTransportErrorHandler_Call) Return()
*MockTransportInstance_SetTransportErrorHandler_Call {
- _c.Call.Return()
- return _c
-}
-
-func (_c *MockTransportInstance_SetTransportErrorHandler_Call)
RunAndReturn(run func(handler TransportErrorHandler))
*MockTransportInstance_SetTransportErrorHandler_Call {
- _c.Call.Return(run)
- return _c
-}
-
// Reset provides a mock function for the type MockTransportInstance
func (_mock *MockTransportInstance) Reset() {
_mock.Called()
diff --git a/plc4go/spi/utils/base64Stringer.go
b/plc4go/spi/utils/base64Stringer.go
index 098421debb..97f994c5f4 100644
--- a/plc4go/spi/utils/base64Stringer.go
+++ b/plc4go/spi/utils/base64Stringer.go
@@ -1,36 +1,36 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- * https://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-package utils
-
-import (
- "encoding/base64"
-)
-
-// Base64Stringer is a helper to print byte slices as base64 encoded strings
-// and can be used in structured logging, so that String() is only called when
-// the log level requires it.
-type Base64Stringer []byte
-
-func (b Base64Stringer) String() string {
- if b == nil {
- return "<nil>"
- }
- return base64.StdEncoding.EncodeToString(b)
-}
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership. The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License. You may obtain a copy of the License at
+ *
+ * https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied. See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+
+package utils
+
+import (
+ "encoding/base64"
+)
+
+// Base64Stringer is a helper to print byte slices as base64 encoded strings
+// and can be used in structured logging, so that String() is only called when
+// the log level requires it.
+type Base64Stringer []byte
+
+func (b Base64Stringer) String() string {
+ if b == nil {
+ return "<nil>"
+ }
+ return base64.StdEncoding.EncodeToString(b)
+}
