- add some methods for VLAN

- fix VLAN.UnmarshalBinary and VLANs.UnmarshalBinary on handing empty slice

Author: hujun-open

etherconn.go

@@ -147,12 +147,23 @@ const (
 	NOVLANTAG = 0xffff
 )
 
-// VLAN reprents a VLAN tag
+// VLAN reprents a VLAN tag.
+// Note: VLAN shouldn't be used directly, use VLANs instead even if there is only one tag
 type VLAN struct {
 	ID        uint16
 	EtherType uint16
 }
 
+// Equal return true if both v's ID and EtherType equals to vlan
+func (vlan VLAN) Equal(v VLAN) bool {
+	return v.ID == vlan.ID && v.EtherType == vlan.EtherType
+}
+
+// IsUnspecified return true if both vlan's ID and EtherType is zero
+func (vlan VLAN) IsUnspecified() bool {
+	return vlan.ID == 0 && vlan.EtherType == 0
+}
+
 // MarshalBinary implements encoding.BinaryMarshaler interface
 func (vlan VLAN) MarshalBinary() (data []byte, err error) {
 	data = make([]byte, 4)
@@ -163,8 +174,13 @@ func (vlan VLAN) MarshalBinary() (data []byte, err error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler interface
 func (vlan *VLAN) UnmarshalBinary(data []byte) error {
+	if len(data) == 0 {
+		vlan.ID = 0
+		vlan.EtherType = 0
+		return nil
+	}
 	if len(data) < 4 {
-		return fmt.Errorf("can't unmarshal VLAN from a byte slice less than 4 bytes")
+		return fmt.Errorf("can't unmarshal VLAN from a byte slice less than 4 bytes, got %d bytes", len(data))
 	}
 	vlan.ID = binary.BigEndian.Uint16(data[:2])
 	vlan.EtherType = binary.BigEndian.Uint16(data[2:4])
@@ -194,8 +210,13 @@ func (vlans VLANs) MarshalBinary() (data []byte, err error) {
 
 // UnmarshalBinary implements encoding.BinaryUnmarshaler interface
 func (vlans *VLANs) UnmarshalBinary(data []byte) error {
+	if len(data) == 0 {
+		*vlans = []*VLAN{}
+		return nil
+	}
+
 	if len(data) < 4 {
-		return fmt.Errorf("can't unmarshal VLANs from a byte slice less than 4 bytes")
+		return fmt.Errorf("can't unmarshal VLANs from a byte slice less than 4 bytes, got %d bytes", len(data))
 	}
 	*vlans = []*VLAN{}
 	for start := 0; start+4 <= len(data); start += 4 {

etherconn_test.go

@@ -950,6 +950,13 @@ func TestVLANs(t *testing.T) {
 			},
 			shouldFail: true,
 		},
+		{
+			v:          etherconn.VLANs{},
+			vs:         "",
+			newIDs:     []uint16{},
+			newv:       etherconn.VLANs{},
+			shouldFail: false,
+		},
 	}
 	testFunc := func(c testVLANsCase) error {
 		if len(c.vbs) != 0 {
@@ -1030,6 +1037,68 @@ func (tvlanc *testVLANsMarshalCase) dotest() error {
 	return nil
 }
 
+func TestVLANMarshalBinary(t *testing.T) {
+	type tcase struct {
+		vlan            etherconn.VLAN
+		expectedMarshal []byte
+		unmarshalBytes  []byte
+		shouldFail      bool
+	}
+	testcaseList := []tcase{
+		{
+			vlan: etherconn.VLAN{
+				ID:        33,
+				EtherType: etherconn.DefaultVLANEtype,
+			},
+			expectedMarshal: []byte{0, 33, 0x81, 0},
+		},
+		{
+			vlan:            etherconn.VLAN{},
+			expectedMarshal: []byte{0, 0, 0, 0},
+		},
+		{
+			vlan:            etherconn.VLAN{},
+			expectedMarshal: []byte{0, 0, 0, 0},
+			unmarshalBytes:  []byte{},
+		},
+	}
+	testFunc := func(c tcase) error {
+		buf, err := c.vlan.MarshalBinary()
+		if err != nil {
+			return err
+		}
+		if !bytes.Equal(buf, c.expectedMarshal) {
+			return fmt.Errorf("marshal result %v is different from expected %v", buf, c.expectedMarshal)
+		}
+		if c.unmarshalBytes != nil {
+			newv := new(etherconn.VLAN)
+			err = newv.UnmarshalBinary(c.unmarshalBytes)
+			if err != nil {
+				return err
+			}
+			if newv == nil {
+				t.Log("newv is nil")
+			}
+			if !newv.Equal(c.vlan) {
+				return fmt.Errorf("unmarshaled result %v is different from original one %v", newv, c.vlan)
+			}
+
+		}
+		return nil
+	}
+	for i, c := range testcaseList {
+		t.Logf("test case %d", i)
+		err := testFunc(c)
+		if err != nil {
+			if !c.shouldFail {
+				t.Fatalf("test case %d fails, %v", i, err)
+			} else {
+				t.Logf("case %d fails as expected, %v", i, err)
+			}
+		}
+	}
+}
+
 func TestVLANsUnMarhal(t *testing.T) {
 	testCaseList := []testVLANsMarshalCase{
 		//case 0,qinq with .