You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@plc4x.apache.org by sr...@apache.org on 2023/05/05 14:59:38 UTC
[plc4x] branch develop updated: test(plc4go/spi): add tests for transport instance
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 bf00d1bae8 test(plc4go/spi): add tests for transport instance
bf00d1bae8 is described below
commit bf00d1bae8c1f76400f7b6ac6a967d7f9f6a7ca2
Author: Sebastian Rühl <sr...@apache.org>
AuthorDate: Fri May 5 16:59:28 2023 +0200
test(plc4go/spi): add tests for transport instance
---
plc4go/spi/transports/TransportInstance_test.go | 363 +++++++++++
plc4go/spi/transports/pcap/Transport.go | 2 +-
plc4go/spi/transports/pcap/Transport_test.go | 399 ++++++++++++
plc4go/spi/transports/serial/Transport_test.go | 391 ++++++++++++
plc4go/spi/transports/tcp/Transport_test.go | 400 ++++++++++++
plc4go/spi/transports/test/Transport_test.go | 674 +++++++++++++++++++++
plc4go/spi/transports/udp/Transport_test.go | 566 +++++++++++++++++
.../spi/transports/utils/TransportLogger_test.go | 163 +++++
8 files changed, 2957 insertions(+), 1 deletion(-)
diff --git a/plc4go/spi/transports/TransportInstance_test.go b/plc4go/spi/transports/TransportInstance_test.go
new file mode 100644
index 0000000000..bb8b307bd4
--- /dev/null
+++ b/plc4go/spi/transports/TransportInstance_test.go
@@ -0,0 +1,363 @@
+/*
+ * 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 (
+ "bufio"
+ "bytes"
+ "context"
+ "reflect"
+ "testing"
+)
+
+func TestNewDefaultBufferedTransportInstance(t *testing.T) {
+ type args struct {
+ defaultBufferedTransportInstanceRequirements DefaultBufferedTransportInstanceRequirements
+ }
+ tests := []struct {
+ name string
+ args args
+ want DefaultBufferedTransportInstance
+ }{
+ {
+ name: "create it",
+ want: &defaultBufferedTransportInstance{},
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewDefaultBufferedTransportInstance(tt.args.defaultBufferedTransportInstanceRequirements); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewDefaultBufferedTransportInstance() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+type _Test_defaultBufferedTransportInstance_ConnectWithContext_DefaultBufferedTransportInstanceRequirements struct {
+}
+
+func (_ _Test_defaultBufferedTransportInstance_ConnectWithContext_DefaultBufferedTransportInstanceRequirements) GetReader() *bufio.Reader {
+ return nil
+}
+
+func (_ _Test_defaultBufferedTransportInstance_ConnectWithContext_DefaultBufferedTransportInstanceRequirements) Connect() error {
+ return nil
+}
+
+func Test_defaultBufferedTransportInstance_ConnectWithContext(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstanceRequirements DefaultBufferedTransportInstanceRequirements
+ }
+ type args struct {
+ ctx context.Context
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ {
+ name: "connect",
+ fields: fields{
+ DefaultBufferedTransportInstanceRequirements: _Test_defaultBufferedTransportInstance_ConnectWithContext_DefaultBufferedTransportInstanceRequirements{},
+ },
+ args: args{ctx: context.Background()},
+ },
+ {
+ name: "connect canceled",
+ fields: fields{
+ DefaultBufferedTransportInstanceRequirements: _Test_defaultBufferedTransportInstance_ConnectWithContext_DefaultBufferedTransportInstanceRequirements{},
+ },
+ args: args{
+ func() context.Context {
+ ctx, cancel := context.WithCancel(context.Background())
+ cancel()
+ return ctx
+ }(),
+ },
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &defaultBufferedTransportInstance{
+ DefaultBufferedTransportInstanceRequirements: tt.fields.DefaultBufferedTransportInstanceRequirements,
+ }
+ if err := m.ConnectWithContext(tt.args.ctx); (err != nil) != tt.wantErr {
+ t.Errorf("ConnectWithContext() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+type _Test_defaultBufferedTransportInstance_FillBuffer_DefaultBufferedTransportInstanceRequirements struct {
+ reader *bufio.Reader
+}
+
+func (t _Test_defaultBufferedTransportInstance_FillBuffer_DefaultBufferedTransportInstanceRequirements) GetReader() *bufio.Reader {
+ return t.reader
+}
+
+func (_ _Test_defaultBufferedTransportInstance_FillBuffer_DefaultBufferedTransportInstanceRequirements) Connect() error {
+ return nil
+}
+
+func Test_defaultBufferedTransportInstance_FillBuffer(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstanceRequirements DefaultBufferedTransportInstanceRequirements
+ }
+ type args struct {
+ until func(pos uint, currentByte byte, reader *bufio.Reader) bool
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ {
+ name: "fill it",
+ fields: fields{
+ DefaultBufferedTransportInstanceRequirements: _Test_defaultBufferedTransportInstance_FillBuffer_DefaultBufferedTransportInstanceRequirements{},
+ },
+ },
+ {
+ name: "fill it with reader",
+ fields: fields{
+ DefaultBufferedTransportInstanceRequirements: _Test_defaultBufferedTransportInstance_FillBuffer_DefaultBufferedTransportInstanceRequirements{
+ reader: bufio.NewReader(bytes.NewReader([]byte{0x0, 0x0})),
+ },
+ },
+ args: args{func(pos uint, currentByte byte, reader *bufio.Reader) bool {
+ return pos < 1
+ }},
+ },
+ {
+ name: "fill it with reader errors",
+ fields: fields{
+ DefaultBufferedTransportInstanceRequirements: _Test_defaultBufferedTransportInstance_FillBuffer_DefaultBufferedTransportInstanceRequirements{
+ reader: bufio.NewReader(bytes.NewReader([]byte{0x0, 0x0})),
+ },
+ },
+ args: args{func(pos uint, currentByte byte, reader *bufio.Reader) bool {
+ return pos < 2
+ }},
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &defaultBufferedTransportInstance{
+ DefaultBufferedTransportInstanceRequirements: tt.fields.DefaultBufferedTransportInstanceRequirements,
+ }
+ if err := m.FillBuffer(tt.args.until); (err != nil) != tt.wantErr {
+ t.Errorf("FillBuffer() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+type _Test_defaultBufferedTransportInstance_GetNumBytesAvailableInBuffer_DefaultBufferedTransportInstanceRequirements struct {
+ reader *bufio.Reader
+}
+
+func (t _Test_defaultBufferedTransportInstance_GetNumBytesAvailableInBuffer_DefaultBufferedTransportInstanceRequirements) GetReader() *bufio.Reader {
+ return t.reader
+}
+
+func (_ _Test_defaultBufferedTransportInstance_GetNumBytesAvailableInBuffer_DefaultBufferedTransportInstanceRequirements) Connect() error {
+ return nil
+}
+
+func Test_defaultBufferedTransportInstance_GetNumBytesAvailableInBuffer(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstanceRequirements DefaultBufferedTransportInstanceRequirements
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want uint32
+ wantErr bool
+ }{
+ {
+ name: "get it without reader",
+ fields: fields{
+ DefaultBufferedTransportInstanceRequirements: _Test_defaultBufferedTransportInstance_GetNumBytesAvailableInBuffer_DefaultBufferedTransportInstanceRequirements{},
+ },
+ },
+ {
+ name: "get it with reader",
+ fields: fields{
+ DefaultBufferedTransportInstanceRequirements: _Test_defaultBufferedTransportInstance_GetNumBytesAvailableInBuffer_DefaultBufferedTransportInstanceRequirements{
+ reader: bufio.NewReader(bytes.NewReader([]byte{0x0, 0x0})),
+ },
+ },
+ want: 2,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &defaultBufferedTransportInstance{
+ DefaultBufferedTransportInstanceRequirements: tt.fields.DefaultBufferedTransportInstanceRequirements,
+ }
+ got, err := m.GetNumBytesAvailableInBuffer()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("GetNumBytesAvailableInBuffer() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if got != tt.want {
+ t.Errorf("GetNumBytesAvailableInBuffer() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+type _Test_defaultBufferedTransportInstance_PeekReadableByteser_DefaultBufferedTransportInstanceRequirements struct {
+ reader *bufio.Reader
+}
+
+func (t _Test_defaultBufferedTransportInstance_PeekReadableByteser_DefaultBufferedTransportInstanceRequirements) GetReader() *bufio.Reader {
+ return t.reader
+}
+
+func (_ _Test_defaultBufferedTransportInstance_PeekReadableByteser_DefaultBufferedTransportInstanceRequirements) Connect() error {
+ return nil
+}
+
+func Test_defaultBufferedTransportInstance_PeekReadableBytes(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstanceRequirements DefaultBufferedTransportInstanceRequirements
+ }
+ type args struct {
+ numBytes uint32
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ want []byte
+ wantErr bool
+ }{
+ {
+ name: "peek it without reader",
+ fields: fields{
+ DefaultBufferedTransportInstanceRequirements: _Test_defaultBufferedTransportInstance_PeekReadableByteser_DefaultBufferedTransportInstanceRequirements{},
+ },
+ wantErr: true,
+ },
+ {
+ name: "peek it with reader",
+ fields: fields{
+ DefaultBufferedTransportInstanceRequirements: _Test_defaultBufferedTransportInstance_PeekReadableByteser_DefaultBufferedTransportInstanceRequirements{
+ reader: bufio.NewReader(bytes.NewReader([]byte{0x0, 0x0})),
+ },
+ },
+ args: args{numBytes: 2},
+ want: []byte{0x0, 0x0},
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &defaultBufferedTransportInstance{
+ DefaultBufferedTransportInstanceRequirements: tt.fields.DefaultBufferedTransportInstanceRequirements,
+ }
+ got, err := m.PeekReadableBytes(tt.args.numBytes)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("PeekReadableBytes() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("PeekReadableBytes() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+type _Test_defaultBufferedTransportInstance_Read_DefaultBufferedTransportInstanceRequirements struct {
+ reader *bufio.Reader
+}
+
+func (t _Test_defaultBufferedTransportInstance_Read_DefaultBufferedTransportInstanceRequirements) GetReader() *bufio.Reader {
+ return t.reader
+}
+
+func (_ _Test_defaultBufferedTransportInstance_Read_DefaultBufferedTransportInstanceRequirements) Connect() error {
+ return nil
+}
+
+func Test_defaultBufferedTransportInstance_Read(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstanceRequirements DefaultBufferedTransportInstanceRequirements
+ }
+ type args struct {
+ numBytes uint32
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ want []byte
+ wantErr bool
+ }{
+ {
+ name: "read it without reader",
+ fields: fields{
+ DefaultBufferedTransportInstanceRequirements: _Test_defaultBufferedTransportInstance_Read_DefaultBufferedTransportInstanceRequirements{},
+ },
+ wantErr: true,
+ },
+ {
+ name: "read it with reader",
+ fields: fields{
+ DefaultBufferedTransportInstanceRequirements: _Test_defaultBufferedTransportInstance_Read_DefaultBufferedTransportInstanceRequirements{
+ reader: bufio.NewReader(bytes.NewReader([]byte{0x0, 0x0})),
+ },
+ },
+ args: args{numBytes: 2},
+ want: []byte{0x0, 0x0},
+ },
+ {
+ name: "read it with reader errors",
+ fields: fields{
+ DefaultBufferedTransportInstanceRequirements: _Test_defaultBufferedTransportInstance_Read_DefaultBufferedTransportInstanceRequirements{
+ reader: bufio.NewReader(bytes.NewReader([]byte{0x0})),
+ },
+ },
+ args: args{numBytes: 2},
+ wantErr: true,
+ },
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &defaultBufferedTransportInstance{
+ DefaultBufferedTransportInstanceRequirements: tt.fields.DefaultBufferedTransportInstanceRequirements,
+ }
+ got, err := m.Read(tt.args.numBytes)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("Read() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("Read() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
diff --git a/plc4go/spi/transports/pcap/Transport.go b/plc4go/spi/transports/pcap/Transport.go
index bb2bd8e5e7..05013a4605 100644
--- a/plc4go/spi/transports/pcap/Transport.go
+++ b/plc4go/spi/transports/pcap/Transport.go
@@ -192,7 +192,7 @@ func (m *TransportInstance) IsConnected() bool {
}
func (m *TransportInstance) Write(_ []byte) error {
- panic("Write to pcap not supported")
+ return errors.New("Write to pcap not supported")
}
func (m *TransportInstance) GetReader() *bufio.Reader {
diff --git a/plc4go/spi/transports/pcap/Transport_test.go b/plc4go/spi/transports/pcap/Transport_test.go
new file mode 100644
index 0000000000..848a35ac13
--- /dev/null
+++ b/plc4go/spi/transports/pcap/Transport_test.go
@@ -0,0 +1,399 @@
+/*
+ * 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 pcap
+
+import (
+ "bufio"
+ "github.com/apache/plc4x/plc4go/spi/transports"
+ "github.com/gopacket/gopacket/pcap"
+ "net/url"
+ "reflect"
+ "sync"
+ "testing"
+)
+
+func TestNewPcapTransportInstance(t *testing.T) {
+ type args struct {
+ transportFile string
+ transportType TransportType
+ portRange string
+ speedFactor float32
+ transport *Transport
+ }
+ tests := []struct {
+ name string
+ args args
+ want *TransportInstance
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewPcapTransportInstance(tt.args.transportFile, tt.args.transportType, tt.args.portRange, tt.args.speedFactor, tt.args.transport); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewPcapTransportInstance() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestNewTransport(t *testing.T) {
+ tests := []struct {
+ name string
+ want *Transport
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewTransport(); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewTransport() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Close(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ transportFile string
+ transportType TransportType
+ portRange string
+ speedFactor float32
+ connected bool
+ transport *Transport
+ handle *pcap.Handle
+ mutex sync.Mutex
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ transportFile: tt.fields.transportFile,
+ transportType: tt.fields.transportType,
+ portRange: tt.fields.portRange,
+ speedFactor: tt.fields.speedFactor,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ handle: tt.fields.handle,
+ mutex: tt.fields.mutex,
+ reader: tt.fields.reader,
+ }
+ if err := m.Close(); (err != nil) != tt.wantErr {
+ t.Errorf("Close() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Connect(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ transportFile string
+ transportType TransportType
+ portRange string
+ speedFactor float32
+ connected bool
+ transport *Transport
+ handle *pcap.Handle
+ mutex sync.Mutex
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ transportFile: tt.fields.transportFile,
+ transportType: tt.fields.transportType,
+ portRange: tt.fields.portRange,
+ speedFactor: tt.fields.speedFactor,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ handle: tt.fields.handle,
+ mutex: tt.fields.mutex,
+ reader: tt.fields.reader,
+ }
+ if err := m.Connect(); (err != nil) != tt.wantErr {
+ t.Errorf("Connect() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_GetReader(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ transportFile string
+ transportType TransportType
+ portRange string
+ speedFactor float32
+ connected bool
+ transport *Transport
+ handle *pcap.Handle
+ mutex sync.Mutex
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want *bufio.Reader
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ transportFile: tt.fields.transportFile,
+ transportType: tt.fields.transportType,
+ portRange: tt.fields.portRange,
+ speedFactor: tt.fields.speedFactor,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ handle: tt.fields.handle,
+ mutex: tt.fields.mutex,
+ reader: tt.fields.reader,
+ }
+ if got := m.GetReader(); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("GetReader() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_IsConnected(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ transportFile string
+ transportType TransportType
+ portRange string
+ speedFactor float32
+ connected bool
+ transport *Transport
+ handle *pcap.Handle
+ mutex sync.Mutex
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ transportFile: tt.fields.transportFile,
+ transportType: tt.fields.transportType,
+ portRange: tt.fields.portRange,
+ speedFactor: tt.fields.speedFactor,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ handle: tt.fields.handle,
+ mutex: tt.fields.mutex,
+ reader: tt.fields.reader,
+ }
+ if got := m.IsConnected(); got != tt.want {
+ t.Errorf("IsConnected() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_String(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ transportFile string
+ transportType TransportType
+ portRange string
+ speedFactor float32
+ connected bool
+ transport *Transport
+ handle *pcap.Handle
+ mutex sync.Mutex
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ transportFile: tt.fields.transportFile,
+ transportType: tt.fields.transportType,
+ portRange: tt.fields.portRange,
+ speedFactor: tt.fields.speedFactor,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ handle: tt.fields.handle,
+ mutex: tt.fields.mutex,
+ reader: tt.fields.reader,
+ }
+ if got := m.String(); got != tt.want {
+ t.Errorf("String() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Write(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ transportFile string
+ transportType TransportType
+ portRange string
+ speedFactor float32
+ connected bool
+ transport *Transport
+ handle *pcap.Handle
+ mutex sync.Mutex
+ reader *bufio.Reader
+ }
+ type args struct {
+ in0 []byte
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ transportFile: tt.fields.transportFile,
+ transportType: tt.fields.transportType,
+ portRange: tt.fields.portRange,
+ speedFactor: tt.fields.speedFactor,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ handle: tt.fields.handle,
+ mutex: tt.fields.mutex,
+ reader: tt.fields.reader,
+ }
+ if err := m.Write(tt.args.in0); (err != nil) != tt.wantErr {
+ t.Errorf("Write() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransport_CreateTransportInstance(t *testing.T) {
+ type args struct {
+ transportUrl url.URL
+ options map[string][]string
+ }
+ tests := []struct {
+ name string
+ args args
+ want transports.TransportInstance
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ got, err := m.CreateTransportInstance(tt.args.transportUrl, tt.args.options)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("CreateTransportInstance() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("CreateTransportInstance() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_GetTransportCode(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ if got := m.GetTransportCode(); got != tt.want {
+ t.Errorf("GetTransportCode() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_GetTransportName(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ if got := m.GetTransportName(); got != tt.want {
+ t.Errorf("GetTransportName() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_String(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ if got := m.String(); got != tt.want {
+ t.Errorf("String() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
diff --git a/plc4go/spi/transports/serial/Transport_test.go b/plc4go/spi/transports/serial/Transport_test.go
new file mode 100644
index 0000000000..bdd2cf0a05
--- /dev/null
+++ b/plc4go/spi/transports/serial/Transport_test.go
@@ -0,0 +1,391 @@
+/*
+ * 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 serial
+
+import (
+ "bufio"
+ "github.com/apache/plc4x/plc4go/spi/transports"
+ "io"
+ "net"
+ "net/url"
+ "reflect"
+ "testing"
+)
+
+func TestNewTransport(t *testing.T) {
+ tests := []struct {
+ name string
+ want *Transport
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewTransport(); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewTransport() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestNewTransportInstance(t *testing.T) {
+ type args struct {
+ serialPortName string
+ baudRate uint
+ connectTimeout uint32
+ transport *Transport
+ }
+ tests := []struct {
+ name string
+ args args
+ want *TransportInstance
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewTransportInstance(tt.args.serialPortName, tt.args.baudRate, tt.args.connectTimeout, tt.args.transport); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewTransportInstance() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Close(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ SerialPortName string
+ BaudRate uint
+ ConnectTimeout uint32
+ transport *Transport
+ serialPort io.ReadWriteCloser
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ SerialPortName: tt.fields.SerialPortName,
+ BaudRate: tt.fields.BaudRate,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ serialPort: tt.fields.serialPort,
+ reader: tt.fields.reader,
+ }
+ if err := m.Close(); (err != nil) != tt.wantErr {
+ t.Errorf("Close() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Connect(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ SerialPortName string
+ BaudRate uint
+ ConnectTimeout uint32
+ transport *Transport
+ serialPort io.ReadWriteCloser
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ SerialPortName: tt.fields.SerialPortName,
+ BaudRate: tt.fields.BaudRate,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ serialPort: tt.fields.serialPort,
+ reader: tt.fields.reader,
+ }
+ if err := m.Connect(); (err != nil) != tt.wantErr {
+ t.Errorf("Connect() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_GetReader(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ SerialPortName string
+ BaudRate uint
+ ConnectTimeout uint32
+ transport *Transport
+ serialPort io.ReadWriteCloser
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want *bufio.Reader
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ SerialPortName: tt.fields.SerialPortName,
+ BaudRate: tt.fields.BaudRate,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ serialPort: tt.fields.serialPort,
+ reader: tt.fields.reader,
+ }
+ if got := m.GetReader(); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("GetReader() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_IsConnected(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ SerialPortName string
+ BaudRate uint
+ ConnectTimeout uint32
+ transport *Transport
+ serialPort io.ReadWriteCloser
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ SerialPortName: tt.fields.SerialPortName,
+ BaudRate: tt.fields.BaudRate,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ serialPort: tt.fields.serialPort,
+ reader: tt.fields.reader,
+ }
+ if got := m.IsConnected(); got != tt.want {
+ t.Errorf("IsConnected() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_String(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ SerialPortName string
+ BaudRate uint
+ ConnectTimeout uint32
+ transport *Transport
+ serialPort io.ReadWriteCloser
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ SerialPortName: tt.fields.SerialPortName,
+ BaudRate: tt.fields.BaudRate,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ serialPort: tt.fields.serialPort,
+ reader: tt.fields.reader,
+ }
+ if got := m.String(); got != tt.want {
+ t.Errorf("String() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Write(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ SerialPortName string
+ BaudRate uint
+ ConnectTimeout uint32
+ transport *Transport
+ serialPort io.ReadWriteCloser
+ reader *bufio.Reader
+ }
+ type args struct {
+ data []byte
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ SerialPortName: tt.fields.SerialPortName,
+ BaudRate: tt.fields.BaudRate,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ serialPort: tt.fields.serialPort,
+ reader: tt.fields.reader,
+ }
+ if err := m.Write(tt.args.data); (err != nil) != tt.wantErr {
+ t.Errorf("Write() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransport_CreateTransportInstance(t *testing.T) {
+ type args struct {
+ transportUrl url.URL
+ options map[string][]string
+ }
+ tests := []struct {
+ name string
+ args args
+ want transports.TransportInstance
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ got, err := m.CreateTransportInstance(tt.args.transportUrl, tt.args.options)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("CreateTransportInstance() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("CreateTransportInstance() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_CreateTransportInstanceForLocalAddress(t *testing.T) {
+ type args struct {
+ transportUrl url.URL
+ options map[string][]string
+ in2 *net.UDPAddr
+ }
+ tests := []struct {
+ name string
+ args args
+ want transports.TransportInstance
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ got, err := m.CreateTransportInstanceForLocalAddress(tt.args.transportUrl, tt.args.options, tt.args.in2)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("CreateTransportInstanceForLocalAddress() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("CreateTransportInstanceForLocalAddress() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_GetTransportCode(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ if got := m.GetTransportCode(); got != tt.want {
+ t.Errorf("GetTransportCode() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_GetTransportName(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ if got := m.GetTransportName(); got != tt.want {
+ t.Errorf("GetTransportName() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_String(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ if got := m.String(); got != tt.want {
+ t.Errorf("String() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
diff --git a/plc4go/spi/transports/tcp/Transport_test.go b/plc4go/spi/transports/tcp/Transport_test.go
new file mode 100644
index 0000000000..9096f0a3ba
--- /dev/null
+++ b/plc4go/spi/transports/tcp/Transport_test.go
@@ -0,0 +1,400 @@
+/*
+ * 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 tcp
+
+import (
+ "bufio"
+ "context"
+ "github.com/apache/plc4x/plc4go/spi/transports"
+ "net"
+ "net/url"
+ "reflect"
+ "testing"
+)
+
+func TestNewTcpTransportInstance(t *testing.T) {
+ type args struct {
+ remoteAddress *net.TCPAddr
+ connectTimeout uint32
+ transport *Transport
+ }
+ tests := []struct {
+ name string
+ args args
+ want *TransportInstance
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewTcpTransportInstance(tt.args.remoteAddress, tt.args.connectTimeout, tt.args.transport); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewTcpTransportInstance() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestNewTransport(t *testing.T) {
+ tests := []struct {
+ name string
+ want *Transport
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewTransport(); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewTransport() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Close(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ RemoteAddress *net.TCPAddr
+ LocalAddress *net.TCPAddr
+ ConnectTimeout uint32
+ transport *Transport
+ tcpConn net.Conn
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ RemoteAddress: tt.fields.RemoteAddress,
+ LocalAddress: tt.fields.LocalAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ tcpConn: tt.fields.tcpConn,
+ reader: tt.fields.reader,
+ }
+ if err := m.Close(); (err != nil) != tt.wantErr {
+ t.Errorf("Close() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Connect(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ RemoteAddress *net.TCPAddr
+ LocalAddress *net.TCPAddr
+ ConnectTimeout uint32
+ transport *Transport
+ tcpConn net.Conn
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ RemoteAddress: tt.fields.RemoteAddress,
+ LocalAddress: tt.fields.LocalAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ tcpConn: tt.fields.tcpConn,
+ reader: tt.fields.reader,
+ }
+ if err := m.Connect(); (err != nil) != tt.wantErr {
+ t.Errorf("Connect() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_ConnectWithContext(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ RemoteAddress *net.TCPAddr
+ LocalAddress *net.TCPAddr
+ ConnectTimeout uint32
+ transport *Transport
+ tcpConn net.Conn
+ reader *bufio.Reader
+ }
+ type args struct {
+ ctx context.Context
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ RemoteAddress: tt.fields.RemoteAddress,
+ LocalAddress: tt.fields.LocalAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ tcpConn: tt.fields.tcpConn,
+ reader: tt.fields.reader,
+ }
+ if err := m.ConnectWithContext(tt.args.ctx); (err != nil) != tt.wantErr {
+ t.Errorf("ConnectWithContext() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_GetReader(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ RemoteAddress *net.TCPAddr
+ LocalAddress *net.TCPAddr
+ ConnectTimeout uint32
+ transport *Transport
+ tcpConn net.Conn
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want *bufio.Reader
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ RemoteAddress: tt.fields.RemoteAddress,
+ LocalAddress: tt.fields.LocalAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ tcpConn: tt.fields.tcpConn,
+ reader: tt.fields.reader,
+ }
+ if got := m.GetReader(); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("GetReader() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_IsConnected(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ RemoteAddress *net.TCPAddr
+ LocalAddress *net.TCPAddr
+ ConnectTimeout uint32
+ transport *Transport
+ tcpConn net.Conn
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ RemoteAddress: tt.fields.RemoteAddress,
+ LocalAddress: tt.fields.LocalAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ tcpConn: tt.fields.tcpConn,
+ reader: tt.fields.reader,
+ }
+ if got := m.IsConnected(); got != tt.want {
+ t.Errorf("IsConnected() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_String(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ RemoteAddress *net.TCPAddr
+ LocalAddress *net.TCPAddr
+ ConnectTimeout uint32
+ transport *Transport
+ tcpConn net.Conn
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ RemoteAddress: tt.fields.RemoteAddress,
+ LocalAddress: tt.fields.LocalAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ tcpConn: tt.fields.tcpConn,
+ reader: tt.fields.reader,
+ }
+ if got := m.String(); got != tt.want {
+ t.Errorf("String() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Write(t *testing.T) {
+ type fields struct {
+ DefaultBufferedTransportInstance transports.DefaultBufferedTransportInstance
+ RemoteAddress *net.TCPAddr
+ LocalAddress *net.TCPAddr
+ ConnectTimeout uint32
+ transport *Transport
+ tcpConn net.Conn
+ reader *bufio.Reader
+ }
+ type args struct {
+ data []byte
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ DefaultBufferedTransportInstance: tt.fields.DefaultBufferedTransportInstance,
+ RemoteAddress: tt.fields.RemoteAddress,
+ LocalAddress: tt.fields.LocalAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ transport: tt.fields.transport,
+ tcpConn: tt.fields.tcpConn,
+ reader: tt.fields.reader,
+ }
+ if err := m.Write(tt.args.data); (err != nil) != tt.wantErr {
+ t.Errorf("Write() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransport_CreateTransportInstance(t *testing.T) {
+ type args struct {
+ transportUrl url.URL
+ options map[string][]string
+ }
+ tests := []struct {
+ name string
+ args args
+ want transports.TransportInstance
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ got, err := m.CreateTransportInstance(tt.args.transportUrl, tt.args.options)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("CreateTransportInstance() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("CreateTransportInstance() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_GetTransportCode(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ if got := m.GetTransportCode(); got != tt.want {
+ t.Errorf("GetTransportCode() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_GetTransportName(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ if got := m.GetTransportName(); got != tt.want {
+ t.Errorf("GetTransportName() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_String(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ if got := m.String(); got != tt.want {
+ t.Errorf("String() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
diff --git a/plc4go/spi/transports/test/Transport_test.go b/plc4go/spi/transports/test/Transport_test.go
new file mode 100644
index 0000000000..d37f1cae53
--- /dev/null
+++ b/plc4go/spi/transports/test/Transport_test.go
@@ -0,0 +1,674 @@
+/*
+ * 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 test
+
+import (
+ "bufio"
+ "context"
+ "github.com/apache/plc4x/plc4go/spi/transports"
+ "net/url"
+ "reflect"
+ "testing"
+)
+
+func TestNewTransport(t *testing.T) {
+ tests := []struct {
+ name string
+ want *Transport
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewTransport(); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewTransport() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestNewTransportInstance(t *testing.T) {
+ type args struct {
+ transport *Transport
+ }
+ tests := []struct {
+ name string
+ args args
+ want *TransportInstance
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewTransportInstance(tt.args.transport); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewTransportInstance() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Close(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ tests := []struct {
+ name string
+ fields fields
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ if err := m.Close(); (err != nil) != tt.wantErr {
+ t.Errorf("Close() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Connect(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ tests := []struct {
+ name string
+ fields fields
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ if err := m.Connect(); (err != nil) != tt.wantErr {
+ t.Errorf("Connect() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_ConnectWithContext(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ type args struct {
+ in0 context.Context
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ if err := m.ConnectWithContext(tt.args.in0); (err != nil) != tt.wantErr {
+ t.Errorf("ConnectWithContext() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_DrainWriteBuffer(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ type args struct {
+ numBytes uint32
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ want []byte
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ if got := m.DrainWriteBuffer(tt.args.numBytes); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("DrainWriteBuffer() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_FillBuffer(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ type args struct {
+ until func(pos uint, currentByte byte, reader *bufio.Reader) bool
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ if err := m.FillBuffer(tt.args.until); (err != nil) != tt.wantErr {
+ t.Errorf("FillBuffer() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_FillReadBuffer(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ type args struct {
+ data []byte
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ m.FillReadBuffer(tt.args.data)
+ })
+ }
+}
+
+func TestTransportInstance_GetNumBytesAvailableInBuffer(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want uint32
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ got, err := m.GetNumBytesAvailableInBuffer()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("GetNumBytesAvailableInBuffer() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if got != tt.want {
+ t.Errorf("GetNumBytesAvailableInBuffer() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_GetNumDrainableBytes(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want uint32
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ if got := m.GetNumDrainableBytes(); got != tt.want {
+ t.Errorf("GetNumDrainableBytes() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_IsConnected(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ if got := m.IsConnected(); got != tt.want {
+ t.Errorf("IsConnected() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_PeekReadableBytes(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ type args struct {
+ numBytes uint32
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ want []byte
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ got, err := m.PeekReadableBytes(tt.args.numBytes)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("PeekReadableBytes() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("PeekReadableBytes() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Read(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ type args struct {
+ numBytes uint32
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ want []byte
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ got, err := m.Read(tt.args.numBytes)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("Read() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("Read() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_SetWriteInterceptor(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ type args struct {
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ m.SetWriteInterceptor(tt.args.writeInterceptor)
+ })
+ }
+}
+
+func TestTransportInstance_String(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ if got := m.String(); got != tt.want {
+ t.Errorf("String() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Write(t *testing.T) {
+ type fields struct {
+ readBuffer []byte
+ writeBuffer []byte
+ connected bool
+ transport *Transport
+ writeInterceptor func(transportInstance *TransportInstance, data []byte)
+ }
+ type args struct {
+ data []byte
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ readBuffer: tt.fields.readBuffer,
+ writeBuffer: tt.fields.writeBuffer,
+ connected: tt.fields.connected,
+ transport: tt.fields.transport,
+ writeInterceptor: tt.fields.writeInterceptor,
+ }
+ if err := m.Write(tt.args.data); (err != nil) != tt.wantErr {
+ t.Errorf("Write() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransport_AddPreregisteredInstances(t *testing.T) {
+ type fields struct {
+ preregisteredInstances map[url.URL]transports.TransportInstance
+ }
+ type args struct {
+ transportUrl url.URL
+ preregisteredInstance transports.TransportInstance
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &Transport{
+ preregisteredInstances: tt.fields.preregisteredInstances,
+ }
+ if err := m.AddPreregisteredInstances(tt.args.transportUrl, tt.args.preregisteredInstance); (err != nil) != tt.wantErr {
+ t.Errorf("AddPreregisteredInstances() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransport_CreateTransportInstance(t *testing.T) {
+ type fields struct {
+ preregisteredInstances map[url.URL]transports.TransportInstance
+ }
+ type args struct {
+ transportUrl url.URL
+ options map[string][]string
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ want transports.TransportInstance
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &Transport{
+ preregisteredInstances: tt.fields.preregisteredInstances,
+ }
+ got, err := m.CreateTransportInstance(tt.args.transportUrl, tt.args.options)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("CreateTransportInstance() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("CreateTransportInstance() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_GetTransportCode(t *testing.T) {
+ type fields struct {
+ preregisteredInstances map[url.URL]transports.TransportInstance
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &Transport{
+ preregisteredInstances: tt.fields.preregisteredInstances,
+ }
+ if got := m.GetTransportCode(); got != tt.want {
+ t.Errorf("GetTransportCode() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_GetTransportName(t *testing.T) {
+ type fields struct {
+ preregisteredInstances map[url.URL]transports.TransportInstance
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &Transport{
+ preregisteredInstances: tt.fields.preregisteredInstances,
+ }
+ if got := m.GetTransportName(); got != tt.want {
+ t.Errorf("GetTransportName() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_String(t *testing.T) {
+ type fields struct {
+ preregisteredInstances map[url.URL]transports.TransportInstance
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &Transport{
+ preregisteredInstances: tt.fields.preregisteredInstances,
+ }
+ if got := m.String(); got != tt.want {
+ t.Errorf("String() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
diff --git a/plc4go/spi/transports/udp/Transport_test.go b/plc4go/spi/transports/udp/Transport_test.go
new file mode 100644
index 0000000000..1ece1addac
--- /dev/null
+++ b/plc4go/spi/transports/udp/Transport_test.go
@@ -0,0 +1,566 @@
+/*
+ * 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 udp
+
+import (
+ "bufio"
+ "context"
+ "github.com/apache/plc4x/plc4go/spi/transports"
+ "net"
+ "net/url"
+ "reflect"
+ "testing"
+)
+
+func TestNewTransport(t *testing.T) {
+ tests := []struct {
+ name string
+ want *Transport
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewTransport(); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewTransport() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestNewTransportInstance(t *testing.T) {
+ type args struct {
+ localAddress *net.UDPAddr
+ remoteAddress *net.UDPAddr
+ connectTimeout uint32
+ soReUse bool
+ transport *Transport
+ }
+ tests := []struct {
+ name string
+ args args
+ want *TransportInstance
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewTransportInstance(tt.args.localAddress, tt.args.remoteAddress, tt.args.connectTimeout, tt.args.soReUse, tt.args.transport); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewTransportInstance() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Close(t *testing.T) {
+ type fields struct {
+ LocalAddress *net.UDPAddr
+ RemoteAddress *net.UDPAddr
+ ConnectTimeout uint32
+ SoReUse bool
+ transport *Transport
+ udpConn *net.UDPConn
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ LocalAddress: tt.fields.LocalAddress,
+ RemoteAddress: tt.fields.RemoteAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ SoReUse: tt.fields.SoReUse,
+ transport: tt.fields.transport,
+ udpConn: tt.fields.udpConn,
+ reader: tt.fields.reader,
+ }
+ if err := m.Close(); (err != nil) != tt.wantErr {
+ t.Errorf("Close() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Connect(t *testing.T) {
+ type fields struct {
+ LocalAddress *net.UDPAddr
+ RemoteAddress *net.UDPAddr
+ ConnectTimeout uint32
+ SoReUse bool
+ transport *Transport
+ udpConn *net.UDPConn
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ LocalAddress: tt.fields.LocalAddress,
+ RemoteAddress: tt.fields.RemoteAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ SoReUse: tt.fields.SoReUse,
+ transport: tt.fields.transport,
+ udpConn: tt.fields.udpConn,
+ reader: tt.fields.reader,
+ }
+ if err := m.Connect(); (err != nil) != tt.wantErr {
+ t.Errorf("Connect() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_ConnectWithContext(t *testing.T) {
+ type fields struct {
+ LocalAddress *net.UDPAddr
+ RemoteAddress *net.UDPAddr
+ ConnectTimeout uint32
+ SoReUse bool
+ transport *Transport
+ udpConn *net.UDPConn
+ reader *bufio.Reader
+ }
+ type args struct {
+ ctx context.Context
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ LocalAddress: tt.fields.LocalAddress,
+ RemoteAddress: tt.fields.RemoteAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ SoReUse: tt.fields.SoReUse,
+ transport: tt.fields.transport,
+ udpConn: tt.fields.udpConn,
+ reader: tt.fields.reader,
+ }
+ if err := m.ConnectWithContext(tt.args.ctx); (err != nil) != tt.wantErr {
+ t.Errorf("ConnectWithContext() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_FillBuffer(t *testing.T) {
+ type fields struct {
+ LocalAddress *net.UDPAddr
+ RemoteAddress *net.UDPAddr
+ ConnectTimeout uint32
+ SoReUse bool
+ transport *Transport
+ udpConn *net.UDPConn
+ reader *bufio.Reader
+ }
+ type args struct {
+ until func(pos uint, currentByte byte, reader *bufio.Reader) bool
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ LocalAddress: tt.fields.LocalAddress,
+ RemoteAddress: tt.fields.RemoteAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ SoReUse: tt.fields.SoReUse,
+ transport: tt.fields.transport,
+ udpConn: tt.fields.udpConn,
+ reader: tt.fields.reader,
+ }
+ if err := m.FillBuffer(tt.args.until); (err != nil) != tt.wantErr {
+ t.Errorf("FillBuffer() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_GetNumBytesAvailableInBuffer(t *testing.T) {
+ type fields struct {
+ LocalAddress *net.UDPAddr
+ RemoteAddress *net.UDPAddr
+ ConnectTimeout uint32
+ SoReUse bool
+ transport *Transport
+ udpConn *net.UDPConn
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want uint32
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ LocalAddress: tt.fields.LocalAddress,
+ RemoteAddress: tt.fields.RemoteAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ SoReUse: tt.fields.SoReUse,
+ transport: tt.fields.transport,
+ udpConn: tt.fields.udpConn,
+ reader: tt.fields.reader,
+ }
+ got, err := m.GetNumBytesAvailableInBuffer()
+ if (err != nil) != tt.wantErr {
+ t.Errorf("GetNumBytesAvailableInBuffer() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if got != tt.want {
+ t.Errorf("GetNumBytesAvailableInBuffer() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_IsConnected(t *testing.T) {
+ type fields struct {
+ LocalAddress *net.UDPAddr
+ RemoteAddress *net.UDPAddr
+ ConnectTimeout uint32
+ SoReUse bool
+ transport *Transport
+ udpConn *net.UDPConn
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ LocalAddress: tt.fields.LocalAddress,
+ RemoteAddress: tt.fields.RemoteAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ SoReUse: tt.fields.SoReUse,
+ transport: tt.fields.transport,
+ udpConn: tt.fields.udpConn,
+ reader: tt.fields.reader,
+ }
+ if got := m.IsConnected(); got != tt.want {
+ t.Errorf("IsConnected() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_PeekReadableBytes(t *testing.T) {
+ type fields struct {
+ LocalAddress *net.UDPAddr
+ RemoteAddress *net.UDPAddr
+ ConnectTimeout uint32
+ SoReUse bool
+ transport *Transport
+ udpConn *net.UDPConn
+ reader *bufio.Reader
+ }
+ type args struct {
+ numBytes uint32
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ want []byte
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ LocalAddress: tt.fields.LocalAddress,
+ RemoteAddress: tt.fields.RemoteAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ SoReUse: tt.fields.SoReUse,
+ transport: tt.fields.transport,
+ udpConn: tt.fields.udpConn,
+ reader: tt.fields.reader,
+ }
+ got, err := m.PeekReadableBytes(tt.args.numBytes)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("PeekReadableBytes() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("PeekReadableBytes() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Read(t *testing.T) {
+ type fields struct {
+ LocalAddress *net.UDPAddr
+ RemoteAddress *net.UDPAddr
+ ConnectTimeout uint32
+ SoReUse bool
+ transport *Transport
+ udpConn *net.UDPConn
+ reader *bufio.Reader
+ }
+ type args struct {
+ numBytes uint32
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ want []byte
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ LocalAddress: tt.fields.LocalAddress,
+ RemoteAddress: tt.fields.RemoteAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ SoReUse: tt.fields.SoReUse,
+ transport: tt.fields.transport,
+ udpConn: tt.fields.udpConn,
+ reader: tt.fields.reader,
+ }
+ got, err := m.Read(tt.args.numBytes)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("Read() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("Read() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_String(t *testing.T) {
+ type fields struct {
+ LocalAddress *net.UDPAddr
+ RemoteAddress *net.UDPAddr
+ ConnectTimeout uint32
+ SoReUse bool
+ transport *Transport
+ udpConn *net.UDPConn
+ reader *bufio.Reader
+ }
+ tests := []struct {
+ name string
+ fields fields
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ LocalAddress: tt.fields.LocalAddress,
+ RemoteAddress: tt.fields.RemoteAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ SoReUse: tt.fields.SoReUse,
+ transport: tt.fields.transport,
+ udpConn: tt.fields.udpConn,
+ reader: tt.fields.reader,
+ }
+ if got := m.String(); got != tt.want {
+ t.Errorf("String() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportInstance_Write(t *testing.T) {
+ type fields struct {
+ LocalAddress *net.UDPAddr
+ RemoteAddress *net.UDPAddr
+ ConnectTimeout uint32
+ SoReUse bool
+ transport *Transport
+ udpConn *net.UDPConn
+ reader *bufio.Reader
+ }
+ type args struct {
+ data []byte
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := &TransportInstance{
+ LocalAddress: tt.fields.LocalAddress,
+ RemoteAddress: tt.fields.RemoteAddress,
+ ConnectTimeout: tt.fields.ConnectTimeout,
+ SoReUse: tt.fields.SoReUse,
+ transport: tt.fields.transport,
+ udpConn: tt.fields.udpConn,
+ reader: tt.fields.reader,
+ }
+ if err := m.Write(tt.args.data); (err != nil) != tt.wantErr {
+ t.Errorf("Write() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransport_CreateTransportInstance(t *testing.T) {
+ type args struct {
+ transportUrl url.URL
+ options map[string][]string
+ }
+ tests := []struct {
+ name string
+ args args
+ want transports.TransportInstance
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ got, err := m.CreateTransportInstance(tt.args.transportUrl, tt.args.options)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("CreateTransportInstance() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("CreateTransportInstance() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_CreateTransportInstanceForLocalAddress(t *testing.T) {
+ type args struct {
+ transportUrl url.URL
+ options map[string][]string
+ localAddress *net.UDPAddr
+ }
+ tests := []struct {
+ name string
+ args args
+ want transports.TransportInstance
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ got, err := m.CreateTransportInstanceForLocalAddress(tt.args.transportUrl, tt.args.options, tt.args.localAddress)
+ if (err != nil) != tt.wantErr {
+ t.Errorf("CreateTransportInstanceForLocalAddress() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("CreateTransportInstanceForLocalAddress() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_GetTransportCode(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ if got := m.GetTransportCode(); got != tt.want {
+ t.Errorf("GetTransportCode() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_GetTransportName(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ if got := m.GetTransportName(); got != tt.want {
+ t.Errorf("GetTransportName() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransport_String(t *testing.T) {
+ tests := []struct {
+ name string
+ want string
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ m := Transport{}
+ if got := m.String(); got != tt.want {
+ t.Errorf("String() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
diff --git a/plc4go/spi/transports/utils/TransportLogger_test.go b/plc4go/spi/transports/utils/TransportLogger_test.go
new file mode 100644
index 0000000000..50c5373b27
--- /dev/null
+++ b/plc4go/spi/transports/utils/TransportLogger_test.go
@@ -0,0 +1,163 @@
+/*
+ * 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 (
+ "github.com/rs/zerolog"
+ "io"
+ "reflect"
+ "testing"
+)
+
+func TestNewTransportLogger(t *testing.T) {
+ type args struct {
+ source io.ReadWriteCloser
+ options []Option
+ }
+ tests := []struct {
+ name string
+ args args
+ want *TransportLogger
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := NewTransportLogger(tt.args.source, tt.args.options...); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("NewTransportLogger() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportLogger_Close(t1 *testing.T) {
+ type fields struct {
+ source io.ReadWriteCloser
+ log zerolog.Logger
+ }
+ tests := []struct {
+ name string
+ fields fields
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t1.Run(tt.name, func(t1 *testing.T) {
+ t := &TransportLogger{
+ source: tt.fields.source,
+ log: tt.fields.log,
+ }
+ if err := t.Close(); (err != nil) != tt.wantErr {
+ t1.Errorf("Close() error = %v, wantErr %v", err, tt.wantErr)
+ }
+ })
+ }
+}
+
+func TestTransportLogger_Read(t1 *testing.T) {
+ type fields struct {
+ source io.ReadWriteCloser
+ log zerolog.Logger
+ }
+ type args struct {
+ p []byte
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ want int
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t1.Run(tt.name, func(t1 *testing.T) {
+ t := &TransportLogger{
+ source: tt.fields.source,
+ log: tt.fields.log,
+ }
+ got, err := t.Read(tt.args.p)
+ if (err != nil) != tt.wantErr {
+ t1.Errorf("Read() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if got != tt.want {
+ t1.Errorf("Read() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestTransportLogger_Write(t1 *testing.T) {
+ type fields struct {
+ source io.ReadWriteCloser
+ log zerolog.Logger
+ }
+ type args struct {
+ p []byte
+ }
+ tests := []struct {
+ name string
+ fields fields
+ args args
+ want int
+ wantErr bool
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t1.Run(tt.name, func(t1 *testing.T) {
+ t := &TransportLogger{
+ source: tt.fields.source,
+ log: tt.fields.log,
+ }
+ got, err := t.Write(tt.args.p)
+ if (err != nil) != tt.wantErr {
+ t1.Errorf("Write() error = %v, wantErr %v", err, tt.wantErr)
+ return
+ }
+ if got != tt.want {
+ t1.Errorf("Write() got = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}
+
+func TestWithLogger(t *testing.T) {
+ type args struct {
+ log zerolog.Logger
+ }
+ tests := []struct {
+ name string
+ args args
+ want Option
+ }{
+ // TODO: Add test cases.
+ }
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ if got := WithLogger(tt.args.log); !reflect.DeepEqual(got, tt.want) {
+ t.Errorf("WithLogger() = %v, want %v", got, tt.want)
+ }
+ })
+ }
+}