some more testcases

1 files changed, 96 insertions, 142 deletions

diff --git a/satp/packet_test.go b/satp/packet_test.go
index 98c1cdb..056727f 100644
--- a/satp/packet_test.go
+++ b/satp/packet_test.go
@@ -249,6 +249,66 @@ func TestEncryptedPacketHeader(t *testing.T) {
 	}
 }
 
+// func TestEncryptedPacketSetAuthTagLen(t *testing.T) {
+// TODO: implement this
+// }
+
+func TestEncryptedPacketReadFrom(t *testing.T) {
+	testvectors := []struct {
+		Data           []byte
+		SequenceNumber uint32
+		SenderID       uint16
+		Mux            uint16
+		valid          bool
+	}{
+		{[]byte{}, 0, 0, 0, false},
+		{[]byte{0, 0, 0}, 0, 0, 0, false},
+		{[]byte{0, 0, 0, 0, 0, 0, 0}, 0, 0, 0, false},
+		{[]byte{0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 0, 0, false},
+		{[]byte{0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, 0, 0, 0, true},
+		{[]byte{1, 2, 3, 4, 5, 6, 7, 8, 0, 0}, 0x01020304, 0x0506, 0x0708, true},
+	}
+
+	for _, vector := range testvectors {
+		pkt := NewEncryptedPacket()
+		n, err := pkt.ReadFrom(bytes.NewReader(vector.Data))
+		if vector.valid {
+			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))
+			}
+			seq := pkt.GetSequenceNumber()
+			if seq != vector.SequenceNumber {
+				t.Fatalf("returned sequence number, is: 0x%08X, should be 0x%08X", seq, vector.SequenceNumber)
+			}
+			sid := pkt.GetSenderID()
+			if sid != vector.SenderID {
+				t.Fatalf("returned sender id, is: 0x%04X, should be 0x%04X", sid, vector.SenderID)
+			}
+			mux := pkt.GetMux()
+			if mux != vector.Mux {
+				t.Fatalf("returned mux, is: 0x%04X, should be 0x%04X", mux, vector.Mux)
+			}
+
+			expected := vector.Data[8:]
+			out := pkt.payload
+			if bytes.Compare(out, expected) != 0 {
+				t.Fatalf("resulting payload is invalid, is: '%v', should be '%v'", out, expected)
+			}
+		} else {
+			if err == nil {
+				t.Fatalf("reading packet from %v should give an error", vector.Data)
+			}
+		}
+	}
+}
+
+// func TestEncryptedPacketWriteTo(t *testing.T) {
+// TODO: implement this
+// }
+
 func generateRandomTestDataEncryptedPacket() (authTagLen int, packetData []byte) {
 	minLen := int32(8 + 2)
 	packetLen := uint(minLen + rand.Int31n(PACKET_BUFFER_SIZE-minLen))
@@ -290,110 +350,6 @@ func TestEncryptedPacketReadWrite(t *testing.T) {
 	}
 }
 
-// func TestEncryptedPacketMarshal(t *testing.T) {
-// 	testvectors := []struct {
-// 		packet   EncryptedPacket
-// 		valid    bool
-// 		expected []byte
-// 	}{
-// 		{EncryptedPacket{}, false, []byte{}},
-// 		{EncryptedPacket{Payload: []byte{0x0}}, false, []byte{}},
-// 		{EncryptedPacket{Payload: []byte{0x8}}, false, []byte{}},
-// 		{EncryptedPacket{Payload: []byte{0x0, 0x0}}, true, []byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}},
-// 		{EncryptedPacket{Payload: []byte{0x42, 0x23}}, true, []byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x42, 0x23}},
-// 		{EncryptedPacket{Payload: []byte{0x17, 0x4, 0x0}}, true, []byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x17, 0x4, 0x0}},
-// 		{*NewEncryptedPacket(3), false, []byte{}},
-// 		{EncryptedPacket{Payload: []byte{0x00, 0x56, 0xa5}, AuthTag: make([]byte, 3)}, true, []byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x56, 0xa5, 0x0, 0x0, 0x0}},
-// 	}
-
-// 	for _, vector := range testvectors {
-// 		result, err := vector.packet.MarshalBinary()
-// 		if vector.valid {
-// 			if err != nil {
-// 				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)
-// 			}
-// 		} else {
-// 			if err == nil {
-// 				t.Fatalf("marshalling '%+v' should give an error", vector.packet)
-// 			}
-// 		}
-// 	}
-// }
-
-// func TestEncryptedPacketUnmarshal(t *testing.T) {
-// 	testvectors := []struct {
-// 		data       []byte
-// 		valid      bool
-// 		authTagLen uint
-// 		expected   EncryptedPacket
-// 	}{
-// 		{[]byte{}, false, 0, EncryptedPacket{}},
-// 		{[]byte{0x0, 0x0}, false, 0, EncryptedPacket{}},
-// 		{[]byte{0x0, 0x0, 0x0}, false, 0, EncryptedPacket{}},
-// 		{[]byte{0x0, 0x0, 0x0, 0x0}, false, 0, EncryptedPacket{}},
-// 		{[]byte{0x0, 0x0, 0x0, 0x0, 0x0}, false, 0, EncryptedPacket{}},
-// 		{[]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, false, 0, EncryptedPacket{}},
-// 		{[]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, false, 0, EncryptedPacket{}},
-// 		{[]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, false, 0, EncryptedPacket{}},
-// 		{[]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, false, 0, EncryptedPacket{}},
-// 		{[]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, true, 0, EncryptedPacket{Payload: []byte{0x0, 0x0}}},
-// 		{[]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, false, 1, EncryptedPacket{Payload: []byte{0x0, 0x0}}},
-// 		{[]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, true, 1, EncryptedPacket{Payload: []byte{0x0, 0x0}, AuthTag: []byte{0x0}}},
-// 		{[]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, true, 0, EncryptedPacket{Payload: []byte{0x0, 0x0, 0x0}}},
-// 		{[]byte{0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0, 0x0}, true, 3, EncryptedPacket{Payload: []byte{0x0, 0x0}, AuthTag: []byte{0x0, 0x0, 0x0}}},
-// 	}
-
-// 	for _, vector := range testvectors {
-// 		result := *NewEncryptedPacket(vector.authTagLen)
-// 		err := result.UnmarshalBinary(vector.data)
-// 		if vector.valid {
-// 			if err != nil {
-// 				t.Fatal("unexpected error:", err)
-// 			}
-// 			if !reflect.DeepEqual(vector.expected, result) {
-// 				t.Fatalf("unmarshalled packet is wrong: is '%+v', should be '%+v'", result, vector.expected)
-// 			}
-// 		} else {
-// 			if err == nil {
-// 				t.Fatalf("unmarshalling '%+v' should give an error", vector.data)
-// 			}
-// 		}
-// 	}
-// }
-
-// func generateRandomTestDataEncryptedPacket() (ep *EncryptedPacket) {
-// 	authtaglen := uint(rand.Int31n(32))
-// 	payloadlen := uint(2 + rand.Int31n(2000))
-
-// 	ep = NewEncryptedPacket(authtaglen)
-// 	ep.SequenceNumber = rand.Uint32()
-// 	ep.SenderID = uint16(rand.Uint32())
-// 	ep.Mux = uint16(rand.Uint32())
-// 	ep.Payload = make([]byte, payloadlen)
-// 	rand.Read(ep.Payload)
-// 	return
-// }
-
-// func TestEncryptedPacketMarshalUnmarshal(t *testing.T) {
-// 	for i := 0; i < NUM_RANDOM_DATASETS; i++ {
-// 		in := generateRandomTestDataEncryptedPacket()
-// 		marshalled, err := in.MarshalBinary()
-// 		if err != nil {
-// 			t.Fatal("unexpected error:", err)
-// 		}
-// 		out := NewEncryptedPacket(uint(len(in.AuthTag)))
-// 		if err = out.UnmarshalBinary(marshalled); err != nil {
-// 			t.Fatal("unexpected error:", err)
-// 		}
-// 		if !reflect.DeepEqual(in, out) {
-// 			t.Fatalf("unmarshalled packet is wrong: is '%+v', should be '%+v'", out, in)
-// 		}
-// 	}
-// }
-
 //
 // Benchmarking
 //
@@ -438,44 +394,42 @@ func BenchmarkPlainPacketWriteTo(b *testing.B) {
 	}
 }
 
-// func BenchmarkEncryptedPacketMarshal(b *testing.B) {
-// 	ins := []*EncryptedPacket{}
-// 	for i := 0; i < NUM_RANDOM_DATASETS; i++ {
-// 		ins = append(ins, generateRandomTestDataEncryptedPacket())
-// 	}
+func BenchmarkEncryptedPacketReadFrom(b *testing.B) {
+	ins := []*bytes.Buffer{}
+	for i := 0; i < NUM_RANDOM_DATASETS; i++ {
+		_, data := generateRandomTestDataEncryptedPacket()
+		ins = append(ins, bytes.NewBuffer(data))
+	}
+	pkt := NewEncryptedPacket()
 
-// 	b.ResetTimer()
+	b.ResetTimer()
 
-// 	for i := 0; i < b.N; i++ {
-// 		in := ins[i%len(ins)]
-// 		if _, err := in.MarshalBinary(); err != nil {
-// 			b.Fatal("unexpected error:", err)
-// 		}
-// 	}
-// }
+	for i := 0; i < b.N; i++ {
+		in := ins[i%len(ins)]
+		in.Reset()
+		if _, err := pkt.ReadFrom(in); err != nil {
+			b.Fatal("unexpected error:", err)
+		}
+	}
+}
 
-// func BenchmarkEncryptedPacketUnMarshal(b *testing.B) {
-// 	type inType struct {
-// 		authTagLen uint
-// 		data       []byte
-// 	}
-// 	ins := []inType{}
-// 	for i := 0; i < NUM_RANDOM_DATASETS; i++ {
-// 		pkt := generateRandomTestDataEncryptedPacket()
-// 		inData, err := pkt.MarshalBinary()
-// 		if err != nil {
-// 			b.Fatal("unexpected error:", err)
-// 		}
-// 		ins = append(ins, inType{uint(len(pkt.AuthTag)), inData})
-// 	}
-
-// 	b.ResetTimer()
-
-// 	for i := 0; i < b.N; i++ {
-// 		in := ins[i%len(ins)]
-// 		out := NewEncryptedPacket(in.authTagLen)
-// 		if err := out.UnmarshalBinary(in.data); err != nil {
-// 			b.Fatal("unexpected error:", err)
-// 		}
-// 	}
-// }
+func BenchmarkEncryptedPacketWriteTo(b *testing.B) {
+	ins := []*EncryptedPacket{}
+	for i := 0; i < NUM_RANDOM_DATASETS; i++ {
+		_, data := generateRandomTestDataEncryptedPacket()
+		in := NewEncryptedPacket()
+		if _, err := in.ReadFrom(bytes.NewReader(data)); err != nil {
+			b.Fatal("unexpected error:", err)
+		}
+		ins = append(ins, in)
+	}
+
+	b.ResetTimer()
+
+	for i := 0; i < b.N; i++ {
+		in := ins[i%len(ins)]
+		if _, err := in.WriteTo(ioutil.Discard); err != nil {
+			b.Fatal("unexpected error:", err)
+		}
+	}
+}