more test cases for plain packet

2 files changed, 69 insertions, 35 deletions

diff --git a/satp/Makefile b/satp/Makefile
index a3f7dcd..68e37ca 100644
--- a/satp/Makefile
+++ b/satp/Makefile
@@ -43,7 +43,7 @@ format:
 	$(GOCMD) fmt
 
 test:
-	$(GOCMD) test
+	$(GOCMD) test -v
 
 bench:
 	@$(GOCMD) test -bench=.
diff --git a/satp/packet_test.go b/satp/packet_test.go
index a69bb10..1284880 100644
--- a/satp/packet_test.go
+++ b/satp/packet_test.go
@@ -43,9 +43,7 @@ const (
 )
 
 var (
-	IPv4Packet   *PlainPacket
 	IPv4Type     = uint16(0x0800)
-	IPv4Ping     *PlainPacket
 	IPv4PingData = [...]byte{
 		0x45, 0x00, 0x00, 0x54, 0xB7, 0xCC, 0x40, 0x00, 0x40, 0x01, 0xAD, 0x73, 0xC0, 0xA8, 0x2A, 0x17,
 		0xC0, 0xA8, 0x2A, 0x01, 0x08, 0x00, 0xB4, 0x04, 0x3D, 0xE2, 0x00, 0x01, 0xE6, 0x00, 0xB1, 0x59,
@@ -54,9 +52,7 @@ var (
 		0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33,
 		0x34, 0x35, 0x36, 0x37}
 
-	IPv6Packet   *PlainPacket
 	IPv6Type     = uint16(0x86DD)
-	IPv6Ping     *PlainPacket
 	IPv6PingData = [...]byte{
 		0x60, 0x0E, 0x9B, 0x1F, 0x00, 0x40, 0x3A, 0x40, 0x2A, 0x02, 0x12, 0x34, 0x00, 0x00, 0x00, 0x00,
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x01, 0x2A, 0x02, 0x12, 0x34, 0x00, 0x00, 0x00, 0x00,
@@ -66,35 +62,13 @@ var (
 		0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F,
 		0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37}
 
-	EthernetFrame  *PlainPacket
 	EthernetType   = uint16(0x6558)
-	ARPRequest     *PlainPacket
 	ARPRequestData = [...]byte{
 		0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xC6, 0x5A, 0xD4, 0xC7, 0x23, 0x43, 0x08, 0x06, 0x00, 0x01,
 		0x08, 0x00, 0x06, 0x04, 0x00, 0x01, 0xC6, 0x5A, 0xD4, 0xC7, 0x23, 0x43, 0xC0, 0xA8, 0x2A, 0x17,
 		0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0xC0, 0xA8, 0x2A, 0x01}
 )
 
-func init() {
-	IPv4Packet = NewPlainPacket()
-	IPv4Packet.SetPayloadType(IPv4Type)
-
-	IPv4Ping = NewPlainPacket()
-	IPv4Ping.SetPayloadType(IPv4Type)
-
-	IPv6Packet = NewPlainPacket()
-	IPv6Packet.SetPayloadType(IPv6Type)
-
-	IPv6Ping = NewPlainPacket()
-	IPv6Ping.SetPayloadType(IPv6Type)
-
-	EthernetFrame = NewPlainPacket()
-	EthernetFrame.SetPayloadType(EthernetType)
-
-	ARPRequest = NewPlainPacket()
-	ARPRequest.SetPayloadType(EthernetType)
-}
-
 func TestPlainPacketPayloadType(t *testing.T) {
 	testvectors := []uint16{0, IPv4Type, IPv6Type, EthernetType, 0xAA55, 0xF00F}
 
@@ -106,22 +80,82 @@ func TestPlainPacketPayloadType(t *testing.T) {
 		result := pkt.getPacket()
 		expected := []byte{byte(vector >> 8), byte(vector)}
 		if bytes.Compare(result, expected) != 0 {
-			t.Fatalf("resulting packet is invalid is: '%v', should be '%v'", result, expected)
+			t.Fatalf("resulting packet is invalid, is: '%v', should be '%v'", result, expected)
 		}
 
 		payloadType := pkt.GetPayloadType()
 		if vector != payloadType {
-			t.Fatalf("resulting payload type is invalid is: '%v', should be '%v'", payloadType, vector)
+			t.Fatalf("resulting payload type is invalid, is: 0x%04X, should be 0x%04X", payloadType, vector)
 		}
 	}
 }
 
 func TestPlainPacketReadFrom(t *testing.T) {
-	// TODO: implement this
+	testvectors := []struct {
+		Data []byte
+		Type uint16
+	}{
+		{IPv4PingData[:], IPv4Type},
+		{IPv6PingData[:], IPv6Type},
+		{ARPRequestData[:], EthernetType},
+	}
+
+	for _, vector := range testvectors {
+		pkt := NewPlainPacket()
+		pkt.SetPayloadType(vector.Type)
+		n, err := pkt.ReadFrom(bytes.NewReader(vector.Data))
+		if err != nil {
+			t.Fatal("unexpected error:", err)
+		}
+		if n != int64(len(vector.Data)) {
+			t.Fatalf("returned length is invalid, is: %d, should be %d", n, len(vector.Data))
+		}
+		expected := []byte{}
+		expected = append(expected, []byte{byte(vector.Type >> 8), byte(vector.Type)}...)
+		expected = append(expected, vector.Data...)
+
+		out := pkt.getPacket()
+		if bytes.Compare(out, expected) != 0 {
+			t.Fatalf("resulting packet is invalid, is: '%v', should be '%v'", out, expected)
+		}
+	}
 }
 
 func TestPlainPacketWriteTo(t *testing.T) {
-	// TODO: implement this
+	testvectors := []struct {
+		Data []byte
+		Type uint16
+	}{
+		{IPv4PingData[:], IPv4Type},
+		{IPv6PingData[:], IPv6Type},
+		{ARPRequestData[:], EthernetType},
+	}
+
+	for _, vector := range testvectors {
+		pkt := NewPlainPacket()
+		in := pkt.buffer[:0]
+		in = append(in, []byte{byte(vector.Type >> 8), byte(vector.Type)}...)
+		in = append(in, vector.Data...)
+		pkt.payload = pkt.payload[:len(vector.Data)]
+
+		out := &bytes.Buffer{}
+		n, err := pkt.WriteTo(out)
+		if err != nil {
+			t.Fatal("unexpected error:", err)
+		}
+		if n != int64(len(vector.Data)) {
+			t.Fatalf("returned length is invalid, is: %d, should be %d", n, len(vector.Data))
+		}
+
+		outType := pkt.GetPayloadType()
+		if outType != vector.Type {
+			t.Fatalf("returned payload type is invalid, is: 0x%04X, should be 0x%04X", outType, vector.Type)
+		}
+		outData := out.Bytes()
+		if bytes.Compare(outData, vector.Data) != 0 {
+			t.Fatalf("resulting packet is invalid, is: '%v', should be '%v'", outData, vector.Data)
+		}
+	}
 }
 
 func generateRandomTestDataPlainPacket() (payloadType uint16, payload []byte) {
@@ -144,7 +178,7 @@ func TestPlainPacketReadWrite(t *testing.T) {
 			t.Fatal("unexpected error:", err)
 		}
 		if n != int64(len(in)) {
-			t.Fatalf("returned length is invalid is: %d, should be %d", n, len(in))
+			t.Fatalf("returned length is invalid, is: %d, should be %d", n, len(in))
 		}
 
 		out := &bytes.Buffer{}
@@ -152,11 +186,11 @@ func TestPlainPacketReadWrite(t *testing.T) {
 			t.Fatal("unexpected error:", err)
 		}
 		if n != int64(len(in)) {
-			t.Fatalf("returned length is invalid is: %d, should be %d", n, len(in))
+			t.Fatalf("returned length is invalid, is: %d, should be %d", n, len(in))
 		}
 
 		if bytes.Compare(in, out.Bytes()) != 0 {
-			t.Fatalf("resulting packet is invalid is: '%v', should be '%v'", out.Bytes(), in)
+			t.Fatalf("resulting packet is invalid, is: '%v', should be '%v'", out.Bytes(), in)
 		}
 	}
 }
@@ -184,7 +218,7 @@ func TestPlainPacketReadWrite(t *testing.T) {
 // 				t.Fatal("unexpected error:", err)
 // 			}
 // 			if bytes.Compare(vector.expected, result) != 0 {
-// 				t.Fatalf("resulting packet is invalid is: '%v', should be '%v'", result, vector.expected)
+// 				t.Fatalf("resulting packet is invalid, is: '%v', should be '%v'", result, vector.expected)
 // 			}
 // 		} else {
 // 			if err == nil {