From bf00d1bae8c1f76400f7b6ac6a967d7f9f6a7ca2 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Sebastian=20R=C3=BChl?= Date: Fri, 5 May 2023 16:59:28 +0200 Subject: [PATCH] test(plc4go/spi): add tests for transport instance --- .../spi/transports/TransportInstance_test.go | 363 ++++++++++ plc4go/spi/transports/pcap/Transport.go | 2 +- plc4go/spi/transports/pcap/Transport_test.go | 399 +++++++++++ .../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 +++++++++++++++ .../transports/utils/TransportLogger_test.go | 163 +++++ 8 files changed, 2957 insertions(+), 1 deletion(-) create mode 100644 plc4go/spi/transports/TransportInstance_test.go create mode 100644 plc4go/spi/transports/pcap/Transport_test.go create mode 100644 plc4go/spi/transports/serial/Transport_test.go create mode 100644 plc4go/spi/transports/tcp/Transport_test.go create mode 100644 plc4go/spi/transports/test/Transport_test.go create mode 100644 plc4go/spi/transports/udp/Transport_test.go create mode 100644 plc4go/spi/transports/utils/TransportLogger_test.go diff --git a/plc4go/spi/transports/TransportInstance_test.go b/plc4go/spi/transports/TransportInstance_test.go new file mode 100644 index 00000000000..bb8b307bd48 --- /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 bb2bd8e5e7c..05013a46054 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 00000000000..848a35ac136 --- /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 00000000000..bdd2cf0a05c --- /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 00000000000..9096f0a3bae --- /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 00000000000..d37f1cae533 --- /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 00000000000..1ece1addacc --- /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 00000000000..50c5373b276 --- /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) + } + }) + } +}