| /* |
| * Copyright 2020-present Open Networking Foundation |
| |
| * Licensed 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 |
| |
| * http://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 l2oam |
| |
| import ( |
| "encoding/binary" |
| "encoding/hex" |
| "fmt" |
| "reflect" |
| "testing" |
| |
| "github.com/google/gopacket" |
| "github.com/google/gopacket/layers" |
| ) |
| |
| func TestGenerateDiscoverySOLICIT(t *testing.T) { |
| tests := []struct { |
| name string |
| want gopacket.SerializableLayer |
| }{ |
| // TODO: Add test cases. |
| { |
| name: "GenerateDiscoverySOLICIT-1", |
| want: &DiscoverySolicit{ |
| // IEEE 1904.2 |
| Opcode: 0xfd, |
| DiscoveryType: 0x01, |
| // Vendor-specific |
| VendorType: 0xfe, |
| Length: 37, |
| // Vendor ID |
| VendorIDType: 0xfd, |
| VendorIDLength: 3, |
| VendorID: []byte{0x2a, 0xea, 0x15}, |
| // Controller Priority |
| CPType: 0x05, |
| CPLength: 1, |
| CPValue: []byte{128}, |
| //NetworkID |
| NWType: 0x06, |
| NWLength: 16, |
| NWValue: []byte("tibitcom.com"), |
| //Device Type |
| DVType: 0x07, |
| DVLength: 1, |
| DVValue: []byte{1}, |
| //Supported CLient Protocols |
| SCPType: 0x08, |
| SCPLength: 1, |
| SCPValue: []byte{0x03}, |
| //Padding |
| PadType: 0xff, |
| PadLength: 1, |
| PadValue: []byte{0}, |
| }, |
| }, |
| } |
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| if got := GenerateDiscoverySOLICIT(); !reflect.DeepEqual(got, tt.want) { |
| t.Errorf("GenerateDiscoverySOLICIT() = %v, want %v", got, tt.want) |
| } |
| }) |
| } |
| } |
| |
| func TestDiscoverySolicit_String(t *testing.T) { |
| type fields struct { |
| BaseLayer layers.BaseLayer |
| Opcode uint8 |
| DiscoveryType uint8 |
| VendorType uint8 |
| Length uint16 |
| VendorIDType uint8 |
| VendorIDLength uint16 |
| VendorID []byte |
| CPType uint8 |
| CPLength uint16 |
| CPValue []byte |
| NWType uint8 |
| NWLength uint16 |
| NWValue []byte |
| DVType uint8 |
| DVLength uint16 |
| DVValue []byte |
| SCPType uint8 |
| SCPLength uint16 |
| SCPValue []byte |
| PadType uint8 |
| PadLength uint16 |
| PadValue []byte |
| } |
| tests := []struct { |
| name string |
| fields fields |
| want string |
| }{ |
| // TODO: Add test cases. |
| { |
| name: "String-1", |
| fields: fields{ |
| // IEEE 1904.2 |
| Opcode: 0xfd, |
| DiscoveryType: 0x01, |
| // Vendor-specific |
| VendorType: 0xfe, |
| Length: 37, |
| // Vendor ID |
| VendorIDType: 0xfd, |
| VendorIDLength: 3, |
| VendorID: []byte{0x2a, 0xea, 0x15}, |
| // Controller Priority |
| CPType: 0x05, |
| CPLength: 1, |
| CPValue: []byte{128}, |
| //NetworkID |
| NWType: 0x06, |
| NWLength: 16, |
| NWValue: []byte("tibitcom.com"), |
| //Device Type |
| DVType: 0x07, |
| DVLength: 1, |
| DVValue: []byte{1}, |
| //Supported CLient Protocols |
| SCPType: 0x08, |
| SCPLength: 1, |
| SCPValue: []byte{0x03}, |
| //Padding |
| PadType: 0xff, |
| PadLength: 1, |
| PadValue: []byte{0}, |
| }, |
| want: fmt.Sprintf("Opcode:253, DiscoveryType:1, VendorType:254, Length:37, VendorIDType:253, VendorIDLength:3, VendorID:2aea15, CPType:5, CPLength:1, CPValue:80, NWType:6, NWLength:16, NWValue:%v, DVType:7, DVLength:1, DVValue:01, SCPType:8, SCPLength:1, SCPValue:03", hex.EncodeToString([]byte("tibitcom.com"))), |
| }, |
| } |
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| d := &DiscoverySolicit{ |
| BaseLayer: tt.fields.BaseLayer, |
| Opcode: tt.fields.Opcode, |
| DiscoveryType: tt.fields.DiscoveryType, |
| VendorType: tt.fields.VendorType, |
| Length: tt.fields.Length, |
| VendorIDType: tt.fields.VendorIDType, |
| VendorIDLength: tt.fields.VendorIDLength, |
| VendorID: tt.fields.VendorID, |
| CPType: tt.fields.CPType, |
| CPLength: tt.fields.CPLength, |
| CPValue: tt.fields.CPValue, |
| NWType: tt.fields.NWType, |
| NWLength: tt.fields.NWLength, |
| NWValue: tt.fields.NWValue, |
| DVType: tt.fields.DVType, |
| DVLength: tt.fields.DVLength, |
| DVValue: tt.fields.DVValue, |
| SCPType: tt.fields.SCPType, |
| SCPLength: tt.fields.SCPLength, |
| SCPValue: tt.fields.SCPValue, |
| PadType: tt.fields.PadType, |
| PadLength: tt.fields.PadLength, |
| PadValue: tt.fields.PadValue, |
| } |
| if got := d.String(); got != tt.want { |
| t.Errorf("DiscoverySolicit.String() = %v, want %v", got, tt.want) |
| } |
| }) |
| } |
| } |
| |
| func TestDiscoverySolicit_Len(t *testing.T) { |
| type fields struct { |
| BaseLayer layers.BaseLayer |
| Opcode uint8 |
| DiscoveryType uint8 |
| VendorType uint8 |
| Length uint16 |
| VendorIDType uint8 |
| VendorIDLength uint16 |
| VendorID []byte |
| CPType uint8 |
| CPLength uint16 |
| CPValue []byte |
| NWType uint8 |
| NWLength uint16 |
| NWValue []byte |
| DVType uint8 |
| DVLength uint16 |
| DVValue []byte |
| SCPType uint8 |
| SCPLength uint16 |
| SCPValue []byte |
| PadType uint8 |
| PadLength uint16 |
| PadValue []byte |
| } |
| tests := []struct { |
| name string |
| fields fields |
| want int |
| }{ |
| // TODO: Add test cases. |
| { |
| name: "Len-1", |
| fields: fields{ |
| // IEEE 1904.2 |
| Opcode: 0xfd, |
| DiscoveryType: 0x01, |
| // Vendor-specific |
| VendorType: 0xfe, |
| Length: 37, |
| // Vendor ID |
| VendorIDType: 0xfd, |
| VendorIDLength: 3, |
| VendorID: []byte{0x2a, 0xea, 0x15}, |
| // Controller Priority |
| CPType: 0x05, |
| CPLength: 1, |
| CPValue: []byte{128}, |
| //NetworkID |
| NWType: 0x06, |
| NWLength: 16, |
| NWValue: []byte("tibitcom.com"), |
| //Device Type |
| DVType: 0x07, |
| DVLength: 1, |
| DVValue: []byte{1}, |
| //Supported CLient Protocols |
| SCPType: 0x08, |
| SCPLength: 1, |
| SCPValue: []byte{0x03}, |
| //Padding |
| PadType: 0xff, |
| PadLength: 1, |
| PadValue: []byte{0}, |
| }, |
| want: 46, |
| }, |
| } |
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| d := &DiscoverySolicit{ |
| BaseLayer: tt.fields.BaseLayer, |
| Opcode: tt.fields.Opcode, |
| DiscoveryType: tt.fields.DiscoveryType, |
| VendorType: tt.fields.VendorType, |
| Length: tt.fields.Length, |
| VendorIDType: tt.fields.VendorIDType, |
| VendorIDLength: tt.fields.VendorIDLength, |
| VendorID: tt.fields.VendorID, |
| CPType: tt.fields.CPType, |
| CPLength: tt.fields.CPLength, |
| CPValue: tt.fields.CPValue, |
| NWType: tt.fields.NWType, |
| NWLength: tt.fields.NWLength, |
| NWValue: tt.fields.NWValue, |
| DVType: tt.fields.DVType, |
| DVLength: tt.fields.DVLength, |
| DVValue: tt.fields.DVValue, |
| SCPType: tt.fields.SCPType, |
| SCPLength: tt.fields.SCPLength, |
| SCPValue: tt.fields.SCPValue, |
| PadType: tt.fields.PadType, |
| PadLength: tt.fields.PadLength, |
| PadValue: tt.fields.PadValue, |
| } |
| if got := d.Len(); got != tt.want { |
| t.Errorf("DiscoverySolicit.Len() = %v, want %v", got, tt.want) |
| } |
| }) |
| } |
| } |
| |
| func TestDiscoverySolicit_LayerType(t *testing.T) { |
| type fields struct { |
| BaseLayer layers.BaseLayer |
| Opcode uint8 |
| DiscoveryType uint8 |
| VendorType uint8 |
| Length uint16 |
| VendorIDType uint8 |
| VendorIDLength uint16 |
| VendorID []byte |
| CPType uint8 |
| CPLength uint16 |
| CPValue []byte |
| NWType uint8 |
| NWLength uint16 |
| NWValue []byte |
| DVType uint8 |
| DVLength uint16 |
| DVValue []byte |
| SCPType uint8 |
| SCPLength uint16 |
| SCPValue []byte |
| PadType uint8 |
| PadLength uint16 |
| PadValue []byte |
| } |
| tests := []struct { |
| name string |
| fields fields |
| want gopacket.LayerType |
| }{ |
| // TODO: Add test cases. |
| { |
| name: "LayerType-1", |
| want: layers.LayerTypeEthernet, |
| }, |
| } |
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| d := &DiscoverySolicit{ |
| BaseLayer: tt.fields.BaseLayer, |
| Opcode: tt.fields.Opcode, |
| DiscoveryType: tt.fields.DiscoveryType, |
| VendorType: tt.fields.VendorType, |
| Length: tt.fields.Length, |
| VendorIDType: tt.fields.VendorIDType, |
| VendorIDLength: tt.fields.VendorIDLength, |
| VendorID: tt.fields.VendorID, |
| CPType: tt.fields.CPType, |
| CPLength: tt.fields.CPLength, |
| CPValue: tt.fields.CPValue, |
| NWType: tt.fields.NWType, |
| NWLength: tt.fields.NWLength, |
| NWValue: tt.fields.NWValue, |
| DVType: tt.fields.DVType, |
| DVLength: tt.fields.DVLength, |
| DVValue: tt.fields.DVValue, |
| SCPType: tt.fields.SCPType, |
| SCPLength: tt.fields.SCPLength, |
| SCPValue: tt.fields.SCPValue, |
| PadType: tt.fields.PadType, |
| PadLength: tt.fields.PadLength, |
| PadValue: tt.fields.PadValue, |
| } |
| if got := d.LayerType(); !reflect.DeepEqual(got, tt.want) { |
| t.Errorf("DiscoverySolicit.LayerType() = %v, want %v", got, tt.want) |
| } |
| }) |
| } |
| } |
| |
| func TestDiscoverySolicit_SerializeTo(t *testing.T) { |
| type fields struct { |
| BaseLayer layers.BaseLayer |
| Opcode uint8 |
| DiscoveryType uint8 |
| VendorType uint8 |
| Length uint16 |
| VendorIDType uint8 |
| VendorIDLength uint16 |
| VendorID []byte |
| CPType uint8 |
| CPLength uint16 |
| CPValue []byte |
| NWType uint8 |
| NWLength uint16 |
| NWValue []byte |
| DVType uint8 |
| DVLength uint16 |
| DVValue []byte |
| SCPType uint8 |
| SCPLength uint16 |
| SCPValue []byte |
| PadType uint8 |
| PadLength uint16 |
| PadValue []byte |
| } |
| type args struct { |
| b gopacket.SerializeBuffer |
| opts gopacket.SerializeOptions |
| } |
| tests := []struct { |
| name string |
| fields fields |
| args args |
| wantErr bool |
| }{ |
| // TODO: Add test cases. |
| { |
| name: "SerializeTo-1", |
| fields: fields{ |
| // IEEE 1904.2 |
| Opcode: 0xfd, |
| DiscoveryType: 0x01, |
| // Vendor-specific |
| VendorType: 0xfe, |
| Length: 37, |
| // Vendor ID |
| VendorIDType: 0xfd, |
| VendorIDLength: 3, |
| VendorID: []byte{0x2a, 0xea, 0x15}, |
| // Controller Priority |
| CPType: 0x05, |
| CPLength: 1, |
| CPValue: []byte{128}, |
| //NetworkID |
| NWType: 0x06, |
| NWLength: 16, |
| NWValue: []byte("tibitcom.com"), |
| //Device Type |
| DVType: 0x07, |
| DVLength: 1, |
| DVValue: []byte{1}, |
| //Supported CLient Protocols |
| SCPType: 0x08, |
| SCPLength: 1, |
| SCPValue: []byte{0x03}, |
| //Padding |
| PadType: 0xff, |
| PadLength: 1, |
| PadValue: []byte{0}, |
| }, |
| args: args{ |
| b: gopacket.NewSerializeBufferExpectedSize(0, 36), |
| opts: gopacket.SerializeOptions{}, |
| }, |
| wantErr: false, |
| }, |
| } |
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| d := &DiscoverySolicit{ |
| BaseLayer: tt.fields.BaseLayer, |
| Opcode: tt.fields.Opcode, |
| DiscoveryType: tt.fields.DiscoveryType, |
| VendorType: tt.fields.VendorType, |
| Length: tt.fields.Length, |
| VendorIDType: tt.fields.VendorIDType, |
| VendorIDLength: tt.fields.VendorIDLength, |
| VendorID: tt.fields.VendorID, |
| CPType: tt.fields.CPType, |
| CPLength: tt.fields.CPLength, |
| CPValue: tt.fields.CPValue, |
| NWType: tt.fields.NWType, |
| NWLength: tt.fields.NWLength, |
| NWValue: tt.fields.NWValue, |
| DVType: tt.fields.DVType, |
| DVLength: tt.fields.DVLength, |
| DVValue: tt.fields.DVValue, |
| SCPType: tt.fields.SCPType, |
| SCPLength: tt.fields.SCPLength, |
| SCPValue: tt.fields.SCPValue, |
| PadType: tt.fields.PadType, |
| PadLength: tt.fields.PadLength, |
| PadValue: tt.fields.PadValue, |
| } |
| if err := d.SerializeTo(tt.args.b, tt.args.opts); (err != nil) != tt.wantErr { |
| t.Errorf("DiscoverySolicit.SerializeTo error = %v, wantErr %v", err, tt.wantErr) |
| } |
| |
| data := tt.args.b.Bytes() |
| cnt := 0 |
| digits := 0 |
| if !reflect.DeepEqual(d.Opcode, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo Opcode error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.DiscoveryType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo DiscoveryType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.VendorType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo VendorType error") |
| } |
| cnt++ |
| |
| if !reflect.DeepEqual(d.Length, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.SerializeTo Length error") |
| } |
| cnt += 2 |
| |
| if !reflect.DeepEqual(d.VendorIDType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo VendorIDType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.VendorIDLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.SerializeTo VendorIDLength error") |
| } |
| cnt += 2 |
| digits = int(d.VendorIDLength) |
| if !reflect.DeepEqual(d.VendorID, data[cnt:cnt+digits]) { |
| t.Error("DiscoverySolicit.SerializeTo VendorID error") |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.CPType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo CPType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.CPLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.SerializeTo CPLength error") |
| } |
| cnt += 2 |
| digits = int(d.CPLength) |
| if !reflect.DeepEqual(d.CPValue, data[cnt:cnt+digits]) { |
| t.Error("DiscoverySolicit.SerializeTo CPValue error") |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.NWType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo NWType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.NWLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.SerializeTo NWLength error") |
| } |
| cnt += 2 |
| //digits = int(d.NWLength) |
| for _, dvalue := range d.NWValue { |
| if !reflect.DeepEqual(dvalue, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo NWValue error") |
| } |
| cnt++ |
| } |
| // if !reflect.DeepEqual(string(d.NWValue), string(data[cnt:cnt+digits])) { |
| // t.Errorf("DiscoverySolicit.SerializeTo NWValue error %x %x", d.NWValue, data[cnt:cnt+digits]) |
| // } |
| cnt += 4 |
| if !reflect.DeepEqual(d.DVType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo DVType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.DVLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.SerializeTo DVLength error") |
| } |
| cnt += 2 |
| digits = int(d.DVLength) |
| if !reflect.DeepEqual(d.DVValue, data[cnt:cnt+digits]) { |
| t.Error("DiscoverySolicit.SerializeTo DVValue error") |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.SCPType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo SCPType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.SCPLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.SerializeTo SCPLength error") |
| } |
| cnt += 2 |
| digits = int(d.SCPLength) |
| if !reflect.DeepEqual(d.SCPValue, data[cnt:cnt+digits]) { |
| t.Error("DiscoverySolicit.SerializeTo SCPValue error") |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.PadType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo PadType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.PadLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.SerializeTo PadLength error") |
| } |
| cnt += 2 |
| digits = int(d.PadLength) |
| if !reflect.DeepEqual(d.PadValue, data[cnt:cnt+digits]) { |
| t.Error("DiscoverySolicit.SerializeTo PadValue error") |
| } |
| |
| }) |
| } |
| } |
| |
| func TestDiscoverySolicit_Decode(t *testing.T) { |
| type fields struct { |
| BaseLayer layers.BaseLayer |
| Opcode uint8 |
| DiscoveryType uint8 |
| VendorType uint8 |
| Length uint16 |
| VendorIDType uint8 |
| VendorIDLength uint16 |
| VendorID []byte |
| CPType uint8 |
| CPLength uint16 |
| CPValue []byte |
| NWType uint8 |
| NWLength uint16 |
| NWValue []byte |
| DVType uint8 |
| DVLength uint16 |
| DVValue []byte |
| SCPType uint8 |
| SCPLength uint16 |
| SCPValue []byte |
| PadType uint8 |
| PadLength uint16 |
| PadValue []byte |
| } |
| type args struct { |
| data []byte |
| } |
| tests := []struct { |
| name string |
| fields fields |
| args args |
| wantErr bool |
| }{ |
| // TODO: Add test cases. |
| { |
| name: "Decode-1", |
| args: args{ |
| data: []byte{0xfd, 0x01, 0xfe, 0x00, 0x25, 0xfd, 0x00, 0x03, 0x2a, 0xea, 0x15, 0x05, 0x00, 0x01, 0x80, 0x06, 0x00, 0x10, 0x74, 0x69, 0x62, 0x69, 0x74, 0x63, 0x6f, 0x6d, 0x2e, 0x63, 0x6f, 0x6d, 0x00, 0x00, 0x00, 0x00, 0x07, 0x00, 0x01, 0x01, 0x08, 0x00, 0x01, 0x03, 0xff, 0x00, 0x01, 0x00}, |
| }, |
| wantErr: false, |
| }, |
| } |
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| d := &DiscoverySolicit{ |
| BaseLayer: tt.fields.BaseLayer, |
| Opcode: tt.fields.Opcode, |
| DiscoveryType: tt.fields.DiscoveryType, |
| VendorType: tt.fields.VendorType, |
| Length: tt.fields.Length, |
| VendorIDType: tt.fields.VendorIDType, |
| VendorIDLength: tt.fields.VendorIDLength, |
| VendorID: tt.fields.VendorID, |
| CPType: tt.fields.CPType, |
| CPLength: tt.fields.CPLength, |
| CPValue: tt.fields.CPValue, |
| NWType: tt.fields.NWType, |
| NWLength: tt.fields.NWLength, |
| NWValue: tt.fields.NWValue, |
| DVType: tt.fields.DVType, |
| DVLength: tt.fields.DVLength, |
| DVValue: tt.fields.DVValue, |
| SCPType: tt.fields.SCPType, |
| SCPLength: tt.fields.SCPLength, |
| SCPValue: tt.fields.SCPValue, |
| PadType: tt.fields.PadType, |
| PadLength: tt.fields.PadLength, |
| PadValue: tt.fields.PadValue, |
| } |
| if err := d.Decode(tt.args.data); (err != nil) != tt.wantErr { |
| t.Errorf("DiscoverySolicit.Decode error = %v, wantErr %v", err, tt.wantErr) |
| } |
| |
| cnt := 0 |
| digits := 0 |
| |
| if !reflect.DeepEqual(d.Opcode, tt.args.data[cnt]) { |
| t.Errorf("DiscoverySolicit.Decode Opcode error Opcode=%x,data=%x,cnt=%x", d.Opcode, tt.args.data[cnt:], cnt) |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.DiscoveryType, tt.args.data[cnt]) { |
| t.Errorf("DiscoverySolicit.Decode DiscoveryType error DiscoveryType=%X data=%x", d.DiscoveryType, tt.args.data[cnt:cnt+1]) |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.VendorType, tt.args.data[cnt]) { |
| t.Errorf("DiscoverySolicit.Decode VendorType error %x %x", tt.args.data[cnt], d.VendorType) |
| } |
| cnt++ |
| |
| if !reflect.DeepEqual(d.Length, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Errorf("DiscoverySolicit.Decode Length error Length=%x data[cnt:cnt+2]=%x", string(d.Length), string(binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2]))) |
| } |
| cnt += 2 |
| |
| if !reflect.DeepEqual(d.VendorIDType, tt.args.data[cnt]) { |
| t.Errorf("DiscoverySolicit.Decode VendorIDType error VendorIDType=%x data=%x", d.VendorIDType, tt.args.data[cnt]) |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.VendorIDLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Errorf("DiscoverySolicit.Decode VendorIDLength error VendorIDLength=%x data[cnt:cnt+2]=%x", d.VendorIDLength, tt.args.data[cnt:cnt+2]) |
| } |
| cnt += 2 |
| digits = int(d.VendorIDLength) |
| if !reflect.DeepEqual(d.VendorID, tt.args.data[cnt:cnt+digits]) { |
| t.Errorf("DiscoverySolicit.Decode VendorID error %v %v", d.VendorID, tt.args.data[cnt:cnt+3]) |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.CPType, tt.args.data[cnt]) { |
| t.Error("DiscoverySolicit.Decode CPType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.CPLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.Decode CPLength error") |
| } |
| cnt += 2 |
| digits = int(d.CPLength) |
| if !reflect.DeepEqual(d.CPValue, tt.args.data[cnt:cnt+digits]) { |
| t.Errorf("DiscoverySolicit.Decode CPValue error %x %x", tt.args.data[14:15], d.CPValue) |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.NWType, tt.args.data[cnt]) { |
| t.Error("DiscoverySolicit.Decode NWType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.NWLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.Decode NWLength error") |
| } |
| cnt += 2 |
| //digits = int(d.NWLength) |
| for _, dvalue := range d.NWValue { |
| if !reflect.DeepEqual(dvalue, tt.args.data[cnt]) { |
| t.Errorf("DiscoverySolicit.Decode NWValue error %x %x", dvalue, tt.args.data[cnt]) |
| } |
| cnt++ |
| } |
| // if !reflect.DeepEqual(string(d.NWValue), string(tt.args.data[cnt:cnt+digits])) { |
| // t.Errorf("DiscoverySolicit.Decode NWValue error %x %x", d.NWValue, tt.args.data[cnt:cnt+digits]) |
| // } |
| // cnt += 4 |
| if !reflect.DeepEqual(d.DVType, tt.args.data[cnt]) { |
| t.Errorf("DiscoverySolicit.Decode DVType error %x %x", d.DVType, tt.args.data[cnt]) |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.DVLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Errorf("DiscoverySolicit.Decode DVLength error %x %x", d.DVLength, tt.args.data[cnt:cnt+2]) |
| } |
| cnt += 2 |
| digits = int(d.DVLength) |
| if !reflect.DeepEqual(d.DVValue, tt.args.data[cnt:cnt+digits]) { |
| t.Errorf("DiscoverySolicit.Decode DVValue error %x %x", d.DVValue, tt.args.data[cnt:cnt+digits]) |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.SCPType, tt.args.data[cnt]) { |
| t.Errorf("DiscoverySolicit.Decode SCPType error %x %x", d.SCPType, tt.args.data[cnt]) |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.SCPLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.Decode SCPLength error") |
| } |
| cnt += 2 |
| digits = int(d.SCPLength) |
| if !reflect.DeepEqual(d.SCPValue, tt.args.data[cnt:cnt+digits]) { |
| t.Errorf("DiscoverySolicit.Decode SCPValue error cnt= %x digits=%x", cnt, digits) |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.PadType, tt.args.data[cnt]) { |
| t.Error("DiscoverySolicit.Decode PadType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.PadLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.Decode PadLength error") |
| } |
| cnt += 2 |
| digits = int(d.PadLength) |
| if !reflect.DeepEqual(d.PadValue, tt.args.data[cnt:cnt+digits]) { |
| t.Errorf("DiscoverySolicit.Decode PadValue error %x %x", d.PadValue, tt.args.data[cnt:cnt+digits]) |
| } |
| |
| }) |
| } |
| } |
| |
| func TestDiscoveryHello_String(t *testing.T) { |
| type fields struct { |
| BaseLayer layers.BaseLayer |
| Opcode uint8 |
| DiscoveryType uint8 |
| VendorType uint8 |
| Length uint16 |
| VendorIDType uint8 |
| VendorIDLength uint16 |
| VendorID []byte |
| NWType uint8 |
| NWLength uint16 |
| NWValue []byte |
| DVType uint8 |
| DVLength uint16 |
| DVValue []byte |
| SCPType uint8 |
| SCPLength uint16 |
| SCPValue []byte |
| TunnelType uint8 |
| TunnelLength uint16 |
| TunnelValue []byte |
| PadType uint8 |
| PadLength uint16 |
| PadValue []byte |
| } |
| tests := []struct { |
| name string |
| fields fields |
| want string |
| }{ |
| // TODO: Add test cases. |
| { |
| name: "String-1", |
| fields: fields{ |
| Opcode: 0xfd, |
| DiscoveryType: 0x01, |
| VendorType: 0xfe, |
| Length: 0x25, |
| VendorIDType: 0xfd, |
| VendorIDLength: 3, |
| VendorID: []byte{0x2a, 0xea, 0x15}, |
| NWType: 0x06, |
| NWLength: 16, |
| NWValue: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16}, |
| DVType: 0x07, |
| DVLength: 1, |
| DVValue: []byte{2}, |
| SCPType: 0x08, |
| SCPLength: 1, |
| SCPValue: []byte{0x03}, |
| TunnelType: 0x0a, |
| TunnelLength: 2, |
| TunnelValue: []byte{0x00, 0x01}, |
| PadType: 0xff, |
| PadLength: 1, |
| PadValue: []byte{0}, |
| }, |
| want: "Opcode:253, DiscoveryType:1, VendorType:254, Length:37, VendorIDType:253, VendorIDLength:3, VendorID:2aea15, NWType:6, NWLength:16, NWValue:01020304050607080910111213141516, DVType:7, DVLength:1, DVValue:02, SCPType:8, SCPLength:1, SCPValue:03, TunnelType:10, TunnelLength:2, TunnelValue:0001, PadType:255, PadLength:1, PadValue:00", |
| }, |
| } |
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| d := &DiscoveryHello{ |
| BaseLayer: tt.fields.BaseLayer, |
| Opcode: tt.fields.Opcode, |
| DiscoveryType: tt.fields.DiscoveryType, |
| VendorType: tt.fields.VendorType, |
| Length: tt.fields.Length, |
| VendorIDType: tt.fields.VendorIDType, |
| VendorIDLength: tt.fields.VendorIDLength, |
| VendorID: tt.fields.VendorID, |
| NWType: tt.fields.NWType, |
| NWLength: tt.fields.NWLength, |
| NWValue: tt.fields.NWValue, |
| DVType: tt.fields.DVType, |
| DVLength: tt.fields.DVLength, |
| DVValue: tt.fields.DVValue, |
| SCPType: tt.fields.SCPType, |
| SCPLength: tt.fields.SCPLength, |
| SCPValue: tt.fields.SCPValue, |
| TunnelType: tt.fields.TunnelType, |
| TunnelLength: tt.fields.TunnelLength, |
| TunnelValue: tt.fields.TunnelValue, |
| PadType: tt.fields.PadType, |
| PadLength: tt.fields.PadLength, |
| PadValue: tt.fields.PadValue, |
| } |
| if got := d.String(); got != tt.want { |
| t.Errorf("DiscoveryHello.String() = %v, want %v", got, tt.want) |
| } |
| }) |
| } |
| } |
| |
| func TestDiscoveryHello_Len(t *testing.T) { |
| type fields struct { |
| BaseLayer layers.BaseLayer |
| Opcode uint8 |
| DiscoveryType uint8 |
| VendorType uint8 |
| Length uint16 |
| VendorIDType uint8 |
| VendorIDLength uint16 |
| VendorID []byte |
| NWType uint8 |
| NWLength uint16 |
| NWValue []byte |
| DVType uint8 |
| DVLength uint16 |
| DVValue []byte |
| SCPType uint8 |
| SCPLength uint16 |
| SCPValue []byte |
| TunnelType uint8 |
| TunnelLength uint16 |
| TunnelValue []byte |
| PadType uint8 |
| PadLength uint16 |
| PadValue []byte |
| } |
| tests := []struct { |
| name string |
| fields fields |
| want int |
| }{ |
| // TODO: Add test cases. |
| { |
| name: "Len-1", |
| fields: fields{ |
| Opcode: 0xfd, |
| DiscoveryType: 0x01, |
| VendorType: 0xfe, |
| Length: 0x25, |
| VendorIDType: 0xfd, |
| VendorIDLength: 3, |
| VendorID: []byte{0x2a, 0xea, 0x15}, |
| NWType: 0x06, |
| NWLength: 16, |
| NWValue: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16}, |
| DVType: 0x07, |
| DVLength: 1, |
| DVValue: []byte{2}, |
| SCPType: 0x08, |
| SCPLength: 1, |
| SCPValue: []byte{0x03}, |
| TunnelType: 0x0a, |
| TunnelLength: 2, |
| TunnelValue: []byte{0x00, 0x01}, |
| PadType: 0xff, |
| PadLength: 1, |
| PadValue: []byte{0}, |
| }, |
| want: 46, |
| }, |
| } |
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| d := &DiscoveryHello{ |
| BaseLayer: tt.fields.BaseLayer, |
| Opcode: tt.fields.Opcode, |
| DiscoveryType: tt.fields.DiscoveryType, |
| VendorType: tt.fields.VendorType, |
| Length: tt.fields.Length, |
| VendorIDType: tt.fields.VendorIDType, |
| VendorIDLength: tt.fields.VendorIDLength, |
| VendorID: tt.fields.VendorID, |
| NWType: tt.fields.NWType, |
| NWLength: tt.fields.NWLength, |
| NWValue: tt.fields.NWValue, |
| DVType: tt.fields.DVType, |
| DVLength: tt.fields.DVLength, |
| DVValue: tt.fields.DVValue, |
| SCPType: tt.fields.SCPType, |
| SCPLength: tt.fields.SCPLength, |
| SCPValue: tt.fields.SCPValue, |
| TunnelType: tt.fields.TunnelType, |
| TunnelLength: tt.fields.TunnelLength, |
| TunnelValue: tt.fields.TunnelValue, |
| PadType: tt.fields.PadType, |
| PadLength: tt.fields.PadLength, |
| PadValue: tt.fields.PadValue, |
| } |
| if got := d.Len(); got != tt.want { |
| t.Errorf("DiscoveryHello.Len() = %v, want %v", got, tt.want) |
| } |
| }) |
| } |
| } |
| |
| func TestDiscoveryHello_LayerType(t *testing.T) { |
| type fields struct { |
| BaseLayer layers.BaseLayer |
| Opcode uint8 |
| DiscoveryType uint8 |
| VendorType uint8 |
| Length uint16 |
| VendorIDType uint8 |
| VendorIDLength uint16 |
| VendorID []byte |
| NWType uint8 |
| NWLength uint16 |
| NWValue []byte |
| DVType uint8 |
| DVLength uint16 |
| DVValue []byte |
| SCPType uint8 |
| SCPLength uint16 |
| SCPValue []byte |
| TunnelType uint8 |
| TunnelLength uint16 |
| TunnelValue []byte |
| PadType uint8 |
| PadLength uint16 |
| PadValue []byte |
| } |
| tests := []struct { |
| name string |
| fields fields |
| want gopacket.LayerType |
| }{ |
| // TODO: Add test cases. |
| { |
| name: "LayerType-1", |
| want: layers.LayerTypeEthernet, |
| }, |
| } |
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| d := &DiscoveryHello{ |
| BaseLayer: tt.fields.BaseLayer, |
| Opcode: tt.fields.Opcode, |
| DiscoveryType: tt.fields.DiscoveryType, |
| VendorType: tt.fields.VendorType, |
| Length: tt.fields.Length, |
| VendorIDType: tt.fields.VendorIDType, |
| VendorIDLength: tt.fields.VendorIDLength, |
| VendorID: tt.fields.VendorID, |
| NWType: tt.fields.NWType, |
| NWLength: tt.fields.NWLength, |
| NWValue: tt.fields.NWValue, |
| DVType: tt.fields.DVType, |
| DVLength: tt.fields.DVLength, |
| DVValue: tt.fields.DVValue, |
| SCPType: tt.fields.SCPType, |
| SCPLength: tt.fields.SCPLength, |
| SCPValue: tt.fields.SCPValue, |
| TunnelType: tt.fields.TunnelType, |
| TunnelLength: tt.fields.TunnelLength, |
| TunnelValue: tt.fields.TunnelValue, |
| PadType: tt.fields.PadType, |
| PadLength: tt.fields.PadLength, |
| PadValue: tt.fields.PadValue, |
| } |
| if got := d.LayerType(); !reflect.DeepEqual(got, tt.want) { |
| t.Errorf("DiscoveryHello.LayerType() = %v, want %v", got, tt.want) |
| } |
| }) |
| } |
| } |
| |
| func TestDiscoveryHello_SerializeTo(t *testing.T) { |
| type fields struct { |
| BaseLayer layers.BaseLayer |
| Opcode uint8 |
| DiscoveryType uint8 |
| VendorType uint8 |
| Length uint16 |
| VendorIDType uint8 |
| VendorIDLength uint16 |
| VendorID []byte |
| NWType uint8 |
| NWLength uint16 |
| NWValue []byte |
| DVType uint8 |
| DVLength uint16 |
| DVValue []byte |
| SCPType uint8 |
| SCPLength uint16 |
| SCPValue []byte |
| TunnelType uint8 |
| TunnelLength uint16 |
| TunnelValue []byte |
| PadType uint8 |
| PadLength uint16 |
| PadValue []byte |
| } |
| type args struct { |
| b gopacket.SerializeBuffer |
| opts gopacket.SerializeOptions |
| } |
| tests := []struct { |
| name string |
| fields fields |
| args args |
| wantErr bool |
| }{ |
| // TODO: Add test cases. |
| { |
| name: "SerializeTo-1", |
| fields: fields{ |
| Opcode: 0xfd, |
| DiscoveryType: 0x01, |
| VendorType: 0xfe, |
| Length: 0x25, |
| VendorIDType: 0xfd, |
| VendorIDLength: 3, |
| VendorID: []byte{0x2a, 0xea, 0x15}, |
| NWType: 0x06, |
| NWLength: 16, |
| NWValue: []byte{0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16}, |
| DVType: 0x07, |
| DVLength: 1, |
| DVValue: []byte{2}, |
| SCPType: 0x08, |
| SCPLength: 1, |
| SCPValue: []byte{0x03}, |
| TunnelType: 0x0a, |
| TunnelLength: 2, |
| TunnelValue: []byte{0x00, 0x01}, |
| PadType: 0xff, |
| PadLength: 1, |
| PadValue: []byte{0}, |
| }, |
| args: args{ |
| b: gopacket.NewSerializeBufferExpectedSize(0, 46), |
| opts: gopacket.SerializeOptions{}, |
| }, |
| wantErr: false, |
| }, |
| } |
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| d := &DiscoveryHello{ |
| BaseLayer: tt.fields.BaseLayer, |
| Opcode: tt.fields.Opcode, |
| DiscoveryType: tt.fields.DiscoveryType, |
| VendorType: tt.fields.VendorType, |
| Length: tt.fields.Length, |
| VendorIDType: tt.fields.VendorIDType, |
| VendorIDLength: tt.fields.VendorIDLength, |
| VendorID: tt.fields.VendorID, |
| NWType: tt.fields.NWType, |
| NWLength: tt.fields.NWLength, |
| NWValue: tt.fields.NWValue, |
| DVType: tt.fields.DVType, |
| DVLength: tt.fields.DVLength, |
| DVValue: tt.fields.DVValue, |
| SCPType: tt.fields.SCPType, |
| SCPLength: tt.fields.SCPLength, |
| SCPValue: tt.fields.SCPValue, |
| TunnelType: tt.fields.TunnelType, |
| TunnelLength: tt.fields.TunnelLength, |
| TunnelValue: tt.fields.TunnelValue, |
| PadType: tt.fields.PadType, |
| PadLength: tt.fields.PadLength, |
| PadValue: tt.fields.PadValue, |
| } |
| if err := d.SerializeTo(tt.args.b, tt.args.opts); (err != nil) != tt.wantErr { |
| t.Errorf("DiscoveryHello.SerializeTo() error = %v, wantErr %v", err, tt.wantErr) |
| } |
| |
| data := tt.args.b.Bytes() |
| cnt := 0 |
| digits := 0 |
| if !reflect.DeepEqual(d.Opcode, data[cnt]) { |
| t.Errorf("DiscoverySolicit.SerializeTo Opcode error Opcode=%x,data=%x,cnt=%x", d.Opcode, data[cnt:], cnt) |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.DiscoveryType, data[cnt]) { |
| t.Errorf("DiscoverySolicit.SerializeTo DiscoveryType error DiscoveryType=%X data=%x", d.DiscoveryType, data[cnt:cnt+1]) |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.VendorType, data[cnt]) { |
| t.Errorf("DiscoverySolicit.SerializeTo VendorType error %x %x", data[cnt], d.VendorType) |
| } |
| cnt++ |
| |
| if !reflect.DeepEqual(d.Length, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Errorf("DiscoverySolicit.SerializeTo Length error Length=%x data[cnt:cnt+2]=%x", string(d.Length), string(binary.BigEndian.Uint16(data[cnt:cnt+2]))) |
| } |
| cnt += 2 |
| |
| if !reflect.DeepEqual(d.VendorIDType, data[cnt]) { |
| t.Errorf("DiscoverySolicit.SerializeTo VendorIDType error VendorIDType=%x data=%x", d.VendorIDType, data[cnt]) |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.VendorIDLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Errorf("DiscoverySolicit.SerializeTo VendorIDLength error VendorIDLength=%x data[cnt:cnt+2]=%x", d.VendorIDLength, data[cnt:cnt+2]) |
| } |
| cnt += 2 |
| digits = int(d.VendorIDLength) |
| if !reflect.DeepEqual(d.VendorID, data[cnt:cnt+digits]) { |
| t.Errorf("DiscoverySolicit.SerializeTo VendorID error %v %v", d.VendorID, data[cnt:cnt+3]) |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.NWType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo NWType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.NWLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.SerializeTo NWLength error") |
| } |
| cnt += 2 |
| //digits = int(d.NWLength) |
| for _, dvalue := range d.NWValue { |
| if !reflect.DeepEqual(dvalue, data[cnt]) { |
| t.Errorf("DiscoverySolicit.SerializeTo NWValue error %x %x", dvalue, data[cnt]) |
| } |
| cnt++ |
| } |
| // if !reflect.DeepEqual(string(d.NWValue), string(data[cnt:cnt+digits])) { |
| // t.Errorf("DiscoverySolicit.SerializeTo NWValue error %x %x", d.NWValue, data[cnt:cnt+digits]) |
| // } |
| // cnt += 16 |
| if !reflect.DeepEqual(d.DVType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo DVType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.DVLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.SerializeTo DVLength error") |
| } |
| cnt += 2 |
| digits = int(d.DVLength) |
| if !reflect.DeepEqual(d.DVValue, data[cnt:cnt+digits]) { |
| t.Error("DiscoverySolicit.SerializeTo DVValue error") |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.SCPType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo SCPType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.SCPLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.SerializeTo SCPLength error") |
| } |
| cnt += 2 |
| digits = int(d.SCPLength) |
| if !reflect.DeepEqual(d.SCPValue, data[cnt:cnt+digits]) { |
| t.Error("DiscoverySolicit.SerializeTo SCPValue error") |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.TunnelType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo TunnelType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.TunnelLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.SerializeTo TunnelLength error") |
| } |
| cnt += 2 |
| digits = int(d.TunnelLength) |
| if !reflect.DeepEqual(d.TunnelValue, data[cnt:cnt+digits]) { |
| t.Error("DiscoverySolicit.SerializeTo TunnelValue error") |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.PadType, data[cnt]) { |
| t.Error("DiscoverySolicit.SerializeTo PadType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.PadLength, binary.BigEndian.Uint16(data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.SerializeTo PadLength error") |
| } |
| cnt += 2 |
| digits = int(d.PadLength) |
| if !reflect.DeepEqual(d.PadValue, data[cnt:cnt+digits]) { |
| t.Errorf("DiscoverySolicit.SerializeTo PadValue error %x %x", d.PadValue, data[cnt:cnt+digits]) |
| } |
| }) |
| } |
| } |
| |
| func TestDiscoveryHello_Decode(t *testing.T) { |
| type fields struct { |
| BaseLayer layers.BaseLayer |
| Opcode uint8 |
| DiscoveryType uint8 |
| VendorType uint8 |
| Length uint16 |
| VendorIDType uint8 |
| VendorIDLength uint16 |
| VendorID []byte |
| NWType uint8 |
| NWLength uint16 |
| NWValue []byte |
| DVType uint8 |
| DVLength uint16 |
| DVValue []byte |
| SCPType uint8 |
| SCPLength uint16 |
| SCPValue []byte |
| TunnelType uint8 |
| TunnelLength uint16 |
| TunnelValue []byte |
| PadType uint8 |
| PadLength uint16 |
| PadValue []byte |
| } |
| type args struct { |
| data []byte |
| } |
| tests := []struct { |
| name string |
| fields fields |
| args args |
| wantErr bool |
| }{ |
| // TODO: Add test cases. |
| { |
| name: "Decode-1", |
| args: args{ |
| data: []byte{0xfd, 0x02, 0xfe, 0x00, 0x26, 0xfd, 0x00, 0x03, 0x2a, 0xea, 0x15, 0x06, 0x00, 0x10, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x07, 0x00, 0x01, 0x02, 0x08, 0x00, 0x01, 0x03, 0x0a, 0x00, 0x02, 0x00, 0x01, 0xff, 0x00, 0x01, 0x00}, |
| }, |
| wantErr: false, |
| }, |
| } |
| for _, tt := range tests { |
| t.Run(tt.name, func(t *testing.T) { |
| d := &DiscoveryHello{ |
| BaseLayer: tt.fields.BaseLayer, |
| Opcode: tt.fields.Opcode, |
| DiscoveryType: tt.fields.DiscoveryType, |
| VendorType: tt.fields.VendorType, |
| Length: tt.fields.Length, |
| VendorIDType: tt.fields.VendorIDType, |
| VendorIDLength: tt.fields.VendorIDLength, |
| VendorID: tt.fields.VendorID, |
| NWType: tt.fields.NWType, |
| NWLength: tt.fields.NWLength, |
| NWValue: tt.fields.NWValue, |
| DVType: tt.fields.DVType, |
| DVLength: tt.fields.DVLength, |
| DVValue: tt.fields.DVValue, |
| SCPType: tt.fields.SCPType, |
| SCPLength: tt.fields.SCPLength, |
| SCPValue: tt.fields.SCPValue, |
| TunnelType: tt.fields.TunnelType, |
| TunnelLength: tt.fields.TunnelLength, |
| TunnelValue: tt.fields.TunnelValue, |
| PadType: tt.fields.PadType, |
| PadLength: tt.fields.PadLength, |
| PadValue: tt.fields.PadValue, |
| } |
| if err := d.Decode(tt.args.data); (err != nil) != tt.wantErr { |
| t.Errorf("DiscoveryHello.Decode() error = %v, wantErr %v", err, tt.wantErr) |
| } |
| |
| cnt := 0 |
| digits := 0 |
| if !reflect.DeepEqual(d.Opcode, tt.args.data[cnt]) { |
| t.Errorf("DiscoverySolicit.Decode Opcode error Opcode=%x,data=%x,cnt=%x", d.Opcode, tt.args.data[cnt:], cnt) |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.DiscoveryType, tt.args.data[cnt]) { |
| t.Errorf("DiscoverySolicit.Decode DiscoveryType error DiscoveryType=%X data=%x", d.DiscoveryType, tt.args.data[cnt:cnt+1]) |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.VendorType, tt.args.data[cnt]) { |
| t.Errorf("DiscoverySolicit.Decode VendorType error %x %x", tt.args.data[cnt], d.VendorType) |
| } |
| cnt++ |
| |
| if !reflect.DeepEqual(d.Length, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Errorf("DiscoverySolicit.Decode Length error Length=%x data[cnt:cnt+2]=%x", string(d.Length), string(binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2]))) |
| } |
| cnt += 2 |
| |
| if !reflect.DeepEqual(d.VendorIDType, tt.args.data[cnt]) { |
| t.Errorf("DiscoverySolicit.Decode VendorIDType error VendorIDType=%x data=%x", d.VendorIDType, tt.args.data[cnt]) |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.VendorIDLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Errorf("DiscoverySolicit.Decode VendorIDLength error VendorIDLength=%x data[cnt:cnt+2]=%x", d.VendorIDLength, tt.args.data[cnt:cnt+2]) |
| } |
| cnt += 2 |
| digits = int(d.VendorIDLength) |
| if !reflect.DeepEqual(d.VendorID, tt.args.data[cnt:cnt+digits]) { |
| t.Errorf("DiscoverySolicit.Decode VendorID error %v %v", d.VendorID, tt.args.data[cnt:cnt+3]) |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.NWType, tt.args.data[cnt]) { |
| t.Error("DiscoverySolicit.Decode NWType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.NWLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.Decode NWLength error") |
| } |
| cnt += 2 |
| //digits = int(d.NWLength) |
| for _, dvalue := range d.NWValue { |
| if !reflect.DeepEqual(dvalue, tt.args.data[cnt]) { |
| t.Errorf("DiscoverySolicit.Decode NWValue error %x %x", dvalue, tt.args.data[cnt]) |
| } |
| cnt++ |
| } |
| // if !reflect.DeepEqual(string(d.NWValue), string(tt.args.data[cnt:cnt+digits])) { |
| // t.Errorf("DiscoverySolicit.Decode NWValue error %x %x", d.NWValue, tt.args.data[cnt:cnt+digits]) |
| // } |
| // cnt += 16 |
| if !reflect.DeepEqual(d.DVType, tt.args.data[cnt]) { |
| t.Error("DiscoverySolicit.Decode DVType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.DVLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.Decode DVLength error") |
| } |
| cnt += 2 |
| digits = int(d.DVLength) |
| if !reflect.DeepEqual(d.DVValue, tt.args.data[cnt:cnt+digits]) { |
| t.Error("DiscoverySolicit.Decode DVValue error") |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.SCPType, tt.args.data[cnt]) { |
| t.Error("DiscoverySolicit.Decode SCPType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.SCPLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.Decode SCPLength error") |
| } |
| cnt += 2 |
| digits = int(d.SCPLength) |
| if !reflect.DeepEqual(d.SCPValue, tt.args.data[cnt:cnt+digits]) { |
| t.Error("DiscoverySolicit.Decode SCPValue error") |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.TunnelType, tt.args.data[cnt]) { |
| t.Error("DiscoverySolicit.Decode TunnelType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.TunnelLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.Decode TunnelLength error") |
| } |
| cnt += 2 |
| digits = int(d.TunnelLength) |
| if !reflect.DeepEqual(d.TunnelValue, tt.args.data[cnt:cnt+digits]) { |
| t.Error("DiscoverySolicit.Decode TunnelValue error") |
| } |
| cnt += digits |
| if !reflect.DeepEqual(d.PadType, tt.args.data[cnt]) { |
| t.Error("DiscoverySolicit.Decode PadType error") |
| } |
| cnt++ |
| if !reflect.DeepEqual(d.PadLength, binary.BigEndian.Uint16(tt.args.data[cnt:cnt+2])) { |
| t.Error("DiscoverySolicit.Decode PadLength error") |
| } |
| cnt += 2 |
| digits = int(d.PadLength) |
| if !reflect.DeepEqual(d.PadValue, tt.args.data[cnt:cnt+digits]) { |
| t.Errorf("DiscoverySolicit.Decode PadValue error %x %x", d.PadValue, tt.args.data[cnt:cnt+digits]) |
| } |
| }) |
| } |
| } |