summaryrefslogtreecommitdiff
path: root/satp/packet_test.go
diff options
context:
space:
mode:
Diffstat (limited to 'satp/packet_test.go')
-rw-r--r--satp/packet_test.go451
1 files changed, 227 insertions, 224 deletions
diff --git a/satp/packet_test.go b/satp/packet_test.go
index 0aa3df4..a69bb10 100644
--- a/satp/packet_test.go
+++ b/satp/packet_test.go
@@ -33,7 +33,8 @@ package satp
import (
"bytes"
"math/rand"
- "reflect"
+ // "reflect"
+ "io/ioutil"
"testing"
)
@@ -42,8 +43,10 @@ const (
)
var (
- IPv4 = uint16(0x0800)
- IPv4Ping = []byte{
+ 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,
0x00, 0x00, 0x00, 0x00, 0xA4, 0xEA, 0x0B, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x11, 0x12, 0x13,
@@ -51,8 +54,10 @@ var (
0x24, 0x25, 0x26, 0x27, 0x28, 0x29, 0x2A, 0x2B, 0x2C, 0x2D, 0x2E, 0x2F, 0x30, 0x31, 0x32, 0x33,
0x34, 0x35, 0x36, 0x37}
- IPv6 = uint16(0x86DD)
- IPv6Ping = []byte{
+ 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,
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x42, 0x80, 0x00, 0xE6, 0x21, 0x46, 0x22, 0x00, 0x01,
@@ -61,235 +66,234 @@ 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}
- Ethernet = uint16(0x6558)
- ARPRequest = []byte{
+ 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 TestPlainPacketMarshal(t *testing.T) {
- testvectors := []struct {
- packet PlainPacket
- valid bool
- expected []byte
- }{
- {PlainPacket{}, true, []byte{0x0, 0x0}},
- {*NewPlainPacket(IPv4), true, []byte{0x8, 0x0}},
- {*NewPlainPacket(IPv6), true, []byte{0x86, 0xDD}},
- {PlainPacket{Type: Ethernet, Payload: []byte{0x0, 0x0, 0x0}}, true, []byte{0x65, 0x58, 0x0, 0x0, 0x0}},
- {PlainPacket{Type: 0x0800, Payload: IPv4Ping}, true, append([]byte{0x8, 0x0}, IPv4Ping...)},
- {PlainPacket{Type: 0x86DD, Payload: IPv6Ping}, true, append([]byte{0x86, 0xDD}, IPv6Ping...)},
- {PlainPacket{Type: 0x6558, Payload: ARPRequest}, true, append([]byte{0x65, 0x58}, ARPRequest...)},
- }
+func init() {
+ IPv4Packet = NewPlainPacket()
+ IPv4Packet.SetPayloadType(IPv4Type)
- 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)
- }
- }
- }
-}
+ IPv4Ping = NewPlainPacket()
+ IPv4Ping.SetPayloadType(IPv4Type)
-func TestPlainPacketUnmarshal(t *testing.T) {
- testvectors := []struct {
- data []byte
- valid bool
- expected PlainPacket
- }{
- {[]byte{}, false, PlainPacket{}},
- {[]byte{0x0}, false, PlainPacket{}},
- {[]byte{0x0, 0x0}, true, PlainPacket{}},
- {[]byte{0x8, 0x0}, true, *NewPlainPacket(IPv4)},
- {[]byte{0x86, 0xDD}, true, *NewPlainPacket(IPv6)},
- {[]byte{0x65, 0x58, 0x0, 0x0, 0x0}, true, PlainPacket{Type: Ethernet, Payload: []byte{0x0, 0x0, 0x0}}},
- {append([]byte{0x8, 0x0}, IPv4Ping...), true, PlainPacket{Type: 0x0800, Payload: IPv4Ping}},
- {append([]byte{0x86, 0xDD}, IPv6Ping...), true, PlainPacket{Type: 0x86DD, Payload: IPv6Ping}},
- {append([]byte{0x65, 0x58}, ARPRequest...), true, PlainPacket{Type: 0x6558, Payload: ARPRequest}},
- }
+ IPv6Packet = NewPlainPacket()
+ IPv6Packet.SetPayloadType(IPv6Type)
- for _, vector := range testvectors {
- var result PlainPacket
- 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)
- }
- }
- }
-}
+ IPv6Ping = NewPlainPacket()
+ IPv6Ping.SetPayloadType(IPv6Type)
-func generateRandomTestDataPlainPacket() (pp *PlainPacket) {
- payloadlen := uint(rand.Int31n(2000))
+ EthernetFrame = NewPlainPacket()
+ EthernetFrame.SetPayloadType(EthernetType)
- pp = NewPlainPacket(uint16(rand.Uint32()))
- pp.Payload = make([]byte, payloadlen)
- rand.Read(pp.Payload)
- return
+ ARPRequest = NewPlainPacket()
+ ARPRequest.SetPayloadType(EthernetType)
}
-func TestPlainPacketMarshalUnmarshal(t *testing.T) {
- for i := 0; i < NUM_RANDOM_DATASETS; i++ {
- in := generateRandomTestDataPlainPacket()
- marshalled, err := in.MarshalBinary()
- if err != nil {
- t.Fatal("unexpected error:", err)
- }
- out := &PlainPacket{}
- if err = out.UnmarshalBinary(marshalled); err != nil {
- t.Fatal("unexpected error:", err)
+func TestPlainPacketPayloadType(t *testing.T) {
+ testvectors := []uint16{0, IPv4Type, IPv6Type, EthernetType, 0xAA55, 0xF00F}
+
+ for _, vector := range testvectors {
+ pkt := NewPlainPacket()
+ if vector > 0 {
+ pkt.SetPayloadType(vector)
}
- if !reflect.DeepEqual(in, out) {
- t.Fatalf("unmarshalled packet is wrong: is '%+v', should be '%+v'", out, in)
+ 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)
}
- }
-}
-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)
- }
+ payloadType := pkt.GetPayloadType()
+ if vector != payloadType {
+ t.Fatalf("resulting payload type is invalid is: '%v', should be '%v'", payloadType, vector)
}
}
}
-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}}},
- }
+func TestPlainPacketReadFrom(t *testing.T) {
+ // TODO: implement this
+}
- 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 TestPlainPacketWriteTo(t *testing.T) {
+ // TODO: implement this
}
-func generateRandomTestDataEncryptedPacket() (ep *EncryptedPacket) {
- authtaglen := uint(rand.Int31n(32))
- payloadlen := uint(2 + rand.Int31n(2000))
+func generateRandomTestDataPlainPacket() (payloadType uint16, payload []byte) {
+ payloadType = uint16(rand.Uint32())
- 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)
+ packetlen := uint(2 + rand.Int31n(PACKET_BUFFER_SIZE-2))
+ payload = make([]byte, packetlen)
+ rand.Read(payload)
return
}
-func TestEncryptedPacketMarshalUnmarshal(t *testing.T) {
+func TestPlainPacketReadWrite(t *testing.T) {
for i := 0; i < NUM_RANDOM_DATASETS; i++ {
- in := generateRandomTestDataEncryptedPacket()
- marshalled, err := in.MarshalBinary()
+ pkt := NewPlainPacket()
+ inType, in := generateRandomTestDataPlainPacket()
+
+ pkt.SetPayloadType(inType)
+ n, err := pkt.ReadFrom(bytes.NewReader(in))
if err != nil {
t.Fatal("unexpected error:", err)
}
- out := NewEncryptedPacket(uint(len(in.AuthTag)))
- if err = out.UnmarshalBinary(marshalled); err != nil {
+ if n != int64(len(in)) {
+ t.Fatalf("returned length is invalid is: %d, should be %d", n, len(in))
+ }
+
+ out := &bytes.Buffer{}
+ if n, err = pkt.WriteTo(out); 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)
+ if n != int64(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)
}
}
}
+// 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
//
-func BenchmarkPlainPacketMarshal(b *testing.B) {
- ins := []*PlainPacket{}
+func BenchmarkPlainPacketReadFrom(b *testing.B) {
+ ins := []*bytes.Buffer{}
for i := 0; i < NUM_RANDOM_DATASETS; i++ {
- ins = append(ins, generateRandomTestDataPlainPacket())
+ _, payload := generateRandomTestDataPlainPacket()
+ ins = append(ins, bytes.NewBuffer(payload))
}
+ pkt := NewPlainPacket()
b.ResetTimer()
for i := 0; i < b.N; i++ {
in := ins[i%len(ins)]
- if _, err := in.MarshalBinary(); err != nil {
+ in.Reset()
+ if _, err := pkt.ReadFrom(in); err != nil {
b.Fatal("unexpected error:", err)
}
}
}
-func BenchmarkPlainPacketUnMarshal(b *testing.B) {
- ins := [][]byte{}
+func BenchmarkPlainPacketWriteTo(b *testing.B) {
+ ins := []*PlainPacket{}
for i := 0; i < NUM_RANDOM_DATASETS; i++ {
- in, err := generateRandomTestDataPlainPacket().MarshalBinary()
- if err != nil {
+ _, payload := generateRandomTestDataPlainPacket()
+ in := NewPlainPacket()
+ if _, err := in.ReadFrom(bytes.NewReader(payload)); err != nil {
b.Fatal("unexpected error:", err)
}
ins = append(ins, in)
@@ -299,51 +303,50 @@ func BenchmarkPlainPacketUnMarshal(b *testing.B) {
for i := 0; i < b.N; i++ {
in := ins[i%len(ins)]
- out := &PlainPacket{}
- if err := out.UnmarshalBinary(in); err != nil {
- b.Fatal("unexpected error:", err)
- }
- }
-}
-
-func BenchmarkEncryptedPacketMarshal(b *testing.B) {
- ins := []*EncryptedPacket{}
- for i := 0; i < NUM_RANDOM_DATASETS; i++ {
- ins = append(ins, generateRandomTestDataEncryptedPacket())
- }
-
- b.ResetTimer()
-
- for i := 0; i < b.N; i++ {
- in := ins[i%len(ins)]
- if _, err := in.MarshalBinary(); err != nil {
+ if _, err := in.WriteTo(ioutil.Discard); 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 BenchmarkEncryptedPacketMarshal(b *testing.B) {
+// ins := []*EncryptedPacket{}
+// for i := 0; i < NUM_RANDOM_DATASETS; i++ {
+// ins = append(ins, generateRandomTestDataEncryptedPacket())
+// }
+
+// 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)
+// }
+// }
+// }
+
+// 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)
+// }
+// }
+// }
generated by cgit v1.2.3 (git 2.39.1) at 2024-06-01 06:18:14 +0000