1092 lines
41 KiB
Go
1092 lines
41 KiB
Go
package packets
|
|
|
|
import (
|
|
"bytes"
|
|
"errors"
|
|
"fmt"
|
|
"testing"
|
|
|
|
"github.com/jinzhu/copier"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestConnectEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Connect)
|
|
for i, wanted := range expectedPackets[Connect] {
|
|
if !encodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(1), Connect, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Connect, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d] %s", i, wanted.desc)
|
|
|
|
buf := new(bytes.Buffer)
|
|
pk.ConnectEncode(buf)
|
|
encoded := buf.Bytes()
|
|
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, byte(Connect<<4), encoded[0], "Mismatched fixed header packets [i:%d] %s", i, wanted.desc)
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d] %s", i, wanted.desc)
|
|
|
|
ok, _ := pk.ConnectValidate()
|
|
require.Equal(t, byte(Accepted), ok, "Connect packet didn't validate - %v", ok)
|
|
|
|
require.Equal(t, wanted.packet.FixedHeader.Type, pk.FixedHeader.Type, "Mismatched packet fixed header type [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.FixedHeader.Dup, pk.FixedHeader.Dup, "Mismatched packet fixed header dup [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.FixedHeader.Qos, pk.FixedHeader.Qos, "Mismatched packet fixed header qos [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.FixedHeader.Retain, pk.FixedHeader.Retain, "Mismatched packet fixed header retain [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.ProtocolVersion, pk.ProtocolVersion, "Mismatched packet protocol version [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.ProtocolName, pk.ProtocolName, "Mismatched packet protocol name [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.CleanSession, pk.CleanSession, "Mismatched packet cleansession [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.ClientIdentifier, pk.ClientIdentifier, "Mismatched packet client id [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.Keepalive, pk.Keepalive, "Mismatched keepalive value [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.UsernameFlag, pk.UsernameFlag, "Mismatched packet username flag [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.Username, pk.Username, "Mismatched packet username [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.PasswordFlag, pk.PasswordFlag, "Mismatched packet password flag [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.Password, pk.Password, "Mismatched packet password [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.WillFlag, pk.WillFlag, "Mismatched packet will flag [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.WillTopic, pk.WillTopic, "Mismatched packet will topic [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.WillMessage, pk.WillMessage, "Mismatched packet will message [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.WillQos, pk.WillQos, "Mismatched packet will qos [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.WillRetain, pk.WillRetain, "Mismatched packet will retain [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkConnectEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Connect][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.ConnectEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestConnectDecode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Connect)
|
|
for i, wanted := range expectedPackets[Connect] {
|
|
if !decodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(1), Connect, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, true, (len(wanted.rawBytes) > 2), "Insufficient bytes in packet [i:%d] %s", i, wanted.desc)
|
|
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Connect}}
|
|
err := pk.ConnectDecode(wanted.rawBytes[2:]) // Unpack skips fixedheader.
|
|
if wanted.failFirst != nil {
|
|
require.Error(t, err, "Expected error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.True(t, errors.Is(err, wanted.failFirst), "Expected fail state; %v [i:%d] %s", err.Error(), i, wanted.desc)
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err, "Error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.FixedHeader.Type, pk.FixedHeader.Type, "Mismatched packet fixed header type [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.FixedHeader.Dup, pk.FixedHeader.Dup, "Mismatched packet fixed header dup [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.FixedHeader.Qos, pk.FixedHeader.Qos, "Mismatched packet fixed header qos [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.FixedHeader.Retain, pk.FixedHeader.Retain, "Mismatched packet fixed header retain [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.ProtocolVersion, pk.ProtocolVersion, "Mismatched packet protocol version [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.ProtocolName, pk.ProtocolName, "Mismatched packet protocol name [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.CleanSession, pk.CleanSession, "Mismatched packet cleansession [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.ClientIdentifier, pk.ClientIdentifier, "Mismatched packet client id [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.Keepalive, pk.Keepalive, "Mismatched keepalive value [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.UsernameFlag, pk.UsernameFlag, "Mismatched packet username flag [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.Username, pk.Username, "Mismatched packet username [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.PasswordFlag, pk.PasswordFlag, "Mismatched packet password flag [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.Password, pk.Password, "Mismatched packet password [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.WillFlag, pk.WillFlag, "Mismatched packet will flag [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.WillTopic, pk.WillTopic, "Mismatched packet will topic [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.WillMessage, pk.WillMessage, "Mismatched packet will message [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.WillQos, pk.WillQos, "Mismatched packet will qos [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.WillRetain, pk.WillRetain, "Mismatched packet will retain [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkConnectDecode(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Connect}}
|
|
pk.FixedHeader.Decode(expectedPackets[Connect][0].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.ConnectDecode(expectedPackets[Connect][0].rawBytes[2:])
|
|
}
|
|
}
|
|
|
|
func TestConnectValidate(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Connect)
|
|
for i, wanted := range expectedPackets[Connect] {
|
|
if wanted.group == "validate" {
|
|
pk := wanted.packet
|
|
ok, _ := pk.ConnectValidate()
|
|
require.Equal(t, wanted.code, ok, "Connect packet didn't validate [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestConnackEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Connack)
|
|
for i, wanted := range expectedPackets[Connack] {
|
|
if !encodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(2), Connack, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Connack, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d] %s", i, wanted.desc)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.ConnackEncode(buf)
|
|
require.NoError(t, err, "Expected no error writing buffer [i:%d] %s", i, wanted.desc)
|
|
encoded := buf.Bytes()
|
|
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, byte(Connack<<4), encoded[0], "Mismatched fixed header packets [i:%d] %s", i, wanted.desc)
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.ReturnCode, pk.ReturnCode, "Mismatched return code [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.SessionPresent, pk.SessionPresent, "Mismatched session present bool [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkConnackEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Connack][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.ConnackEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestConnackDecode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Connack)
|
|
for i, wanted := range expectedPackets[Connack] {
|
|
if !decodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(2), Connack, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Connack}}
|
|
err := pk.ConnackDecode(wanted.rawBytes[2:]) // Unpack skips fixedheader.
|
|
if wanted.failFirst != nil {
|
|
require.Error(t, err, "Expected error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.True(t, errors.Is(err, wanted.failFirst), "Expected fail state; %v [i:%d] %s", err.Error(), i, wanted.desc)
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err, "Error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.ReturnCode, pk.ReturnCode, "Mismatched return code [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.SessionPresent, pk.SessionPresent, "Mismatched session present bool [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkConnackDecode(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Connack}}
|
|
pk.FixedHeader.Decode(expectedPackets[Connack][0].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.ConnackDecode(expectedPackets[Connack][0].rawBytes[2:])
|
|
}
|
|
}
|
|
|
|
func TestDisconnectEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Disconnect)
|
|
for i, wanted := range expectedPackets[Disconnect] {
|
|
require.Equal(t, uint8(14), Disconnect, "Incorrect Packet Type [i:%d]", i)
|
|
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Disconnect, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d]", i)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.DisconnectEncode(buf)
|
|
require.NoError(t, err, "Expected no error writing buffer [i:%d] %s", i, wanted.desc)
|
|
encoded := buf.Bytes()
|
|
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d]", i)
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d]", i)
|
|
}
|
|
}
|
|
|
|
func BenchmarkDisconnectEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Disconnect][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.DisconnectEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestPingreqEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Pingreq)
|
|
for i, wanted := range expectedPackets[Pingreq] {
|
|
require.Equal(t, uint8(12), Pingreq, "Incorrect Packet Type [i:%d]", i)
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Pingreq, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d]", i)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.PingreqEncode(buf)
|
|
require.NoError(t, err, "Expected no error writing buffer [i:%d] %s", i, wanted.desc)
|
|
encoded := buf.Bytes()
|
|
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d]", i)
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d]", i)
|
|
}
|
|
}
|
|
|
|
func BenchmarkPingreqEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Pingreq][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PingreqEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestPingrespEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Pingresp)
|
|
for i, wanted := range expectedPackets[Pingresp] {
|
|
require.Equal(t, uint8(13), Pingresp, "Incorrect Packet Type [i:%d]", i)
|
|
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Pingresp, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d]", i)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.PingrespEncode(buf)
|
|
require.NoError(t, err, "Expected no error writing buffer [i:%d] %s", i, wanted.desc)
|
|
encoded := buf.Bytes()
|
|
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d]", i)
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d]", i)
|
|
}
|
|
}
|
|
|
|
func BenchmarkPingrespEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Pingresp][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PingrespEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestPubackEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Puback)
|
|
for i, wanted := range expectedPackets[Puback] {
|
|
if !encodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(4), Puback, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Puback, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d] %s", i, wanted.desc)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.PubackEncode(buf)
|
|
require.NoError(t, err, "Expected no error writing buffer [i:%d] %s", i, wanted.desc)
|
|
encoded := buf.Bytes()
|
|
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, byte(Puback<<4), encoded[0], "Mismatched fixed header packets [i:%d] %s", i, wanted.desc)
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkPubackEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Puback][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PubackEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestPubackDecode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Puback)
|
|
for i, wanted := range expectedPackets[Puback] {
|
|
if !decodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(4), Puback, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Puback}}
|
|
err := pk.PubackDecode(wanted.rawBytes[2:]) // Unpack skips fixedheader.
|
|
|
|
if wanted.failFirst != nil {
|
|
require.Error(t, err, "Expected error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.True(t, errors.Is(err, wanted.failFirst), "Expected fail state; %v [i:%d] %s", err.Error(), i, wanted.desc)
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err, "Error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkPubackDecode(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Puback}}
|
|
pk.FixedHeader.Decode(expectedPackets[Puback][0].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PubackDecode(expectedPackets[Puback][0].rawBytes[2:])
|
|
}
|
|
}
|
|
|
|
func TestPubcompEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Pubcomp)
|
|
for i, wanted := range expectedPackets[Pubcomp] {
|
|
if !encodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(7), Pubcomp, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Pubcomp, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d] %s", i, wanted.desc)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.PubcompEncode(buf)
|
|
require.NoError(t, err, "Expected no error writing buffer [i:%d] %s", i, wanted.desc)
|
|
encoded := buf.Bytes()
|
|
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, byte(Pubcomp<<4), encoded[0], "Mismatched fixed header packets [i:%d] %s", i, wanted.desc)
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkPubcompEncode(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Pubcomp}}
|
|
copier.Copy(pk, expectedPackets[Pubcomp][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PubcompEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestPubcompDecode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Pubcomp)
|
|
for i, wanted := range expectedPackets[Pubcomp] {
|
|
if !decodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(7), Pubcomp, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Pubcomp}}
|
|
err := pk.PubcompDecode(wanted.rawBytes[2:]) // Unpack skips fixedheader.
|
|
|
|
if wanted.failFirst != nil {
|
|
require.Error(t, err, "Expected error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.True(t, errors.Is(err, wanted.failFirst), "Expected fail state; %v [i:%d] %s", err.Error(), i, wanted.desc)
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err, "Error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkPubcompDecode(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Pubcomp}}
|
|
pk.FixedHeader.Decode(expectedPackets[Pubcomp][0].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PubcompDecode(expectedPackets[Pubcomp][0].rawBytes[2:])
|
|
}
|
|
}
|
|
|
|
func TestPublishEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Publish)
|
|
for i, wanted := range expectedPackets[Publish] {
|
|
if !encodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(3), Publish, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Publish, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d] %s", i, wanted.desc)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.PublishEncode(buf)
|
|
encoded := buf.Bytes()
|
|
|
|
if wanted.expect != nil {
|
|
require.Error(t, err, "Expected error writing buffer [i:%d] %s", i, wanted.desc)
|
|
} else {
|
|
|
|
// If actualBytes is set, compare mutated version of byte string instead (to avoid length mismatches, etc).
|
|
if len(wanted.actualBytes) > 0 {
|
|
wanted.rawBytes = wanted.actualBytes
|
|
}
|
|
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d] %s", i, wanted.desc)
|
|
if wanted.meta != nil {
|
|
require.Equal(t, byte(Publish<<4)|wanted.meta.(byte), encoded[0], "Mismatched fixed header bytes [i:%d] %s", i, wanted.desc)
|
|
} else {
|
|
require.Equal(t, byte(Publish<<4), encoded[0], "Mismatched fixed header bytes [i:%d] %s", i, wanted.desc)
|
|
}
|
|
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.FixedHeader.Qos, pk.FixedHeader.Qos, "Mismatched QOS [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.FixedHeader.Dup, pk.FixedHeader.Dup, "Mismatched Dup [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.FixedHeader.Retain, pk.FixedHeader.Retain, "Mismatched Retain [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
require.NoError(t, err, "Expected no error writing buffer [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkPublishEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Publish][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PublishEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestPublishDecode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Publish)
|
|
for i, wanted := range expectedPackets[Publish] {
|
|
if !decodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(3), Publish, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Publish}}
|
|
pk.FixedHeader.Decode(wanted.rawBytes[0])
|
|
|
|
err := pk.PublishDecode(wanted.rawBytes[2:]) // Unpack skips fixedheader.
|
|
if wanted.failFirst != nil {
|
|
require.Error(t, err, "Expected fh error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.True(t, errors.Is(err, wanted.failFirst), "Expected fail state; %v [i:%d] %s", err.Error(), i, wanted.desc)
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err, "Error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.FixedHeader.Qos, pk.FixedHeader.Qos, "Mismatched QOS [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.FixedHeader.Dup, pk.FixedHeader.Dup, "Mismatched Dup [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.FixedHeader.Retain, pk.FixedHeader.Retain, "Mismatched Retain [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
|
|
}
|
|
}
|
|
|
|
func BenchmarkPublishDecode(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Publish}}
|
|
pk.FixedHeader.Decode(expectedPackets[Publish][1].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PublishDecode(expectedPackets[Publish][1].rawBytes[2:])
|
|
}
|
|
}
|
|
|
|
func TestPublishCopy(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Publish)
|
|
for i, wanted := range expectedPackets[Publish] {
|
|
if wanted.group == "copy" {
|
|
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Publish}}
|
|
err := pk.PublishDecode(wanted.rawBytes[2:]) // Unpack skips fixedheader.
|
|
require.NoError(t, err, "Error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
|
|
copied := pk.PublishCopy()
|
|
|
|
require.Equal(t, byte(0), copied.FixedHeader.Qos, "Mismatched QOS [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, false, copied.FixedHeader.Dup, "Mismatched Dup [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, false, copied.FixedHeader.Retain, "Mismatched Retain [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, pk.Payload, copied.Payload, "Mismatched Payload [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, pk.TopicName, copied.TopicName, "Mismatched Topic Name [i:%d] %s", i, wanted.desc)
|
|
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkPublishCopy(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Publish}}
|
|
pk.FixedHeader.Decode(expectedPackets[Publish][1].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PublishCopy()
|
|
}
|
|
}
|
|
|
|
func TestPublishValidate(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Publish)
|
|
for i, wanted := range expectedPackets[Publish] {
|
|
if wanted.group == "validate" || i == 0 {
|
|
pk := wanted.packet
|
|
ok, err := pk.PublishValidate()
|
|
|
|
if i == 0 {
|
|
require.NoError(t, err, "Publish should have validated - error incorrect [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, Accepted, ok, "Publish should have validated - code incorrect [i:%d] %s", i, wanted.desc)
|
|
} else {
|
|
require.Equal(t, Failed, ok, "Publish packet didn't validate - code incorrect [i:%d] %s", i, wanted.desc)
|
|
if err != nil {
|
|
require.Equal(t, wanted.expect, err, "Publish packet didn't validate - error incorrect [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkPublishValidate(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Publish}}
|
|
pk.FixedHeader.Decode(expectedPackets[Publish][1].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
_, err := pk.PublishValidate()
|
|
if err != nil {
|
|
panic(err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestPubrecEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Pubrec)
|
|
for i, wanted := range expectedPackets[Pubrec] {
|
|
if !encodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(5), Pubrec, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Pubrec, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d] %s", i, wanted.desc)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.PubrecEncode(buf)
|
|
require.NoError(t, err, "Expected no error writing buffer [i:%d] %s", i, wanted.desc)
|
|
encoded := buf.Bytes()
|
|
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, byte(Pubrec<<4), encoded[0], "Mismatched fixed header packets [i:%d] %s", i, wanted.desc)
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
|
|
}
|
|
}
|
|
|
|
func BenchmarkPubrecEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Pubrec][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PubrecEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestPubrecDecode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Pubrec)
|
|
for i, wanted := range expectedPackets[Pubrec] {
|
|
if !decodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(5), Pubrec, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Pubrec}}
|
|
err := pk.PubrecDecode(wanted.rawBytes[2:]) // Unpack skips fixedheader.
|
|
|
|
if wanted.failFirst != nil {
|
|
require.Error(t, err, "Expected error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.True(t, errors.Is(err, wanted.failFirst), "Expected fail state; %v [i:%d] %s", err.Error(), i, wanted.desc)
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err, "Error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkPubrecDecode(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Pubrec}}
|
|
pk.FixedHeader.Decode(expectedPackets[Pubrec][0].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PubrecDecode(expectedPackets[Pubrec][0].rawBytes[2:])
|
|
}
|
|
}
|
|
|
|
func TestPubrelEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Pubrel)
|
|
for i, wanted := range expectedPackets[Pubrel] {
|
|
if !encodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(6), Pubrel, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Pubrel, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d] %s", i, wanted.desc)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.PubrelEncode(buf)
|
|
require.NoError(t, err, "Expected no error writing buffer [i:%d] %s", i, wanted.desc)
|
|
encoded := buf.Bytes()
|
|
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d] %s", i, wanted.desc)
|
|
if wanted.meta != nil {
|
|
require.Equal(t, byte(Pubrel<<4)|wanted.meta.(byte), encoded[0], "Mismatched fixed header bytes [i:%d] %s", i, wanted.desc)
|
|
} else {
|
|
require.Equal(t, byte(Pubrel<<4), encoded[0], "Mismatched fixed header bytes [i:%d] %s", i, wanted.desc)
|
|
}
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkPubrelEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Pubrel][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PubrelEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestPubrelDecode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Pubrel)
|
|
for i, wanted := range expectedPackets[Pubrel] {
|
|
if !decodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(6), Pubrel, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Pubrel, Qos: 1}}
|
|
err := pk.PubrelDecode(wanted.rawBytes[2:]) // Unpack skips fixedheader.
|
|
|
|
if wanted.failFirst != nil {
|
|
require.Error(t, err, "Expected error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.True(t, errors.Is(err, wanted.failFirst), "Expected fail state; %v [i:%d] %s", err.Error(), i, wanted.desc)
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err, "Error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkPubrelDecode(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Pubrel, Qos: 1}}
|
|
pk.FixedHeader.Decode(expectedPackets[Pubrel][0].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.PubrelDecode(expectedPackets[Pubrel][0].rawBytes[2:])
|
|
}
|
|
}
|
|
|
|
func TestSubackEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Suback)
|
|
for i, wanted := range expectedPackets[Suback] {
|
|
if !encodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(9), Suback, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Suback, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d] %s", i, wanted.desc)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.SubackEncode(buf)
|
|
require.NoError(t, err, "Expected no error writing buffer [i:%d] %s", i, wanted.desc)
|
|
encoded := buf.Bytes()
|
|
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d] %s", i, wanted.desc)
|
|
if wanted.meta != nil {
|
|
require.Equal(t, byte(Suback<<4)|wanted.meta.(byte), encoded[0], "Mismatched mod fixed header packets [i:%d] %s", i, wanted.desc)
|
|
} else {
|
|
require.Equal(t, byte(Suback<<4), encoded[0], "Mismatched fixed header packets [i:%d] %s", i, wanted.desc)
|
|
}
|
|
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.ReturnCodes, pk.ReturnCodes, "Mismatched Return Codes [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSubackEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Suback][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.SubackEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestSubackDecode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Suback)
|
|
for i, wanted := range expectedPackets[Suback] {
|
|
if !decodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(9), Suback, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Suback}}
|
|
err := pk.SubackDecode(wanted.rawBytes[2:]) // Unpack skips fixedheader.
|
|
if wanted.failFirst != nil {
|
|
require.Error(t, err, "Expected error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.True(t, errors.Is(err, wanted.failFirst), "Expected fail state; %v [i:%d] %s", err.Error(), i, wanted.desc)
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err, "Error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.ReturnCodes, pk.ReturnCodes, "Mismatched Return Codes [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSubackDecode(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Suback}}
|
|
pk.FixedHeader.Decode(expectedPackets[Suback][0].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.SubackDecode(expectedPackets[Suback][0].rawBytes[2:])
|
|
}
|
|
}
|
|
|
|
func TestSubscribeEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Subscribe)
|
|
for i, wanted := range expectedPackets[Subscribe] {
|
|
if !encodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(8), Subscribe, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Subscribe, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d] %s", i, wanted.desc)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.SubscribeEncode(buf)
|
|
encoded := buf.Bytes()
|
|
|
|
if wanted.expect != nil {
|
|
require.Error(t, err, "Expected error writing buffer [i:%d] %s", i, wanted.desc)
|
|
} else {
|
|
require.NoError(t, err, "Error writing buffer [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d] %s", i, wanted.desc)
|
|
if wanted.meta != nil {
|
|
require.Equal(t, byte(Subscribe<<4)|wanted.meta.(byte), encoded[0], "Mismatched fixed header bytes [i:%d] %s", i, wanted.desc)
|
|
} else {
|
|
require.Equal(t, byte(Subscribe<<4), encoded[0], "Mismatched fixed header bytes [i:%d] %s", i, wanted.desc)
|
|
}
|
|
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.Topics, pk.Topics, "Mismatched Topics slice [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.Qoss, pk.Qoss, "Mismatched Qoss slice [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkSubscribeEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Subscribe][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.SubscribeEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestSubscribeDecode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Subscribe)
|
|
for i, wanted := range expectedPackets[Subscribe] {
|
|
if !decodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(8), Subscribe, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Subscribe, Qos: 1}}
|
|
err := pk.SubscribeDecode(wanted.rawBytes[2:]) // Unpack skips fixedheader.
|
|
if wanted.failFirst != nil {
|
|
require.Error(t, err, "Expected error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.True(t, errors.Is(err, wanted.failFirst), "Expected fail state; %v [i:%d] %s", err.Error(), i, wanted.desc)
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err, "Error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.Topics, pk.Topics, "Mismatched Topics slice [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.Qoss, pk.Qoss, "Mismatched Qoss slice [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkSubscribeDecode(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Subscribe, Qos: 1}}
|
|
pk.FixedHeader.Decode(expectedPackets[Subscribe][0].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.SubscribeDecode(expectedPackets[Subscribe][0].rawBytes[2:])
|
|
}
|
|
}
|
|
|
|
func TestSubscribeValidate(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Subscribe)
|
|
for i, wanted := range expectedPackets[Subscribe] {
|
|
if wanted.group == "validate" || i == 0 {
|
|
pk := wanted.packet
|
|
ok, err := pk.SubscribeValidate()
|
|
|
|
if i == 0 {
|
|
require.NoError(t, err, "Subscribe should have validated - error incorrect [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, Accepted, ok, "Subscribe should have validated - code incorrect [i:%d] %s", i, wanted.desc)
|
|
} else {
|
|
require.Equal(t, Failed, ok, "Subscribe packet didn't validate - code incorrect [i:%d] %s", i, wanted.desc)
|
|
if err != nil {
|
|
require.Equal(t, wanted.expect, err, "Subscribe packet didn't validate - error incorrect [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkSubscribeValidate(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Subscribe, Qos: 1}}
|
|
pk.FixedHeader.Decode(expectedPackets[Subscribe][0].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.SubscribeValidate()
|
|
}
|
|
}
|
|
|
|
func TestUnsubackEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Unsuback)
|
|
for i, wanted := range expectedPackets[Unsuback] {
|
|
if !encodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(11), Unsuback, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Unsuback, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d] %s", i, wanted.desc)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.UnsubackEncode(buf)
|
|
require.NoError(t, err, "Expected no error writing buffer [i:%d] %s", i, wanted.desc)
|
|
encoded := buf.Bytes()
|
|
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d] %s", i, wanted.desc)
|
|
if wanted.meta != nil {
|
|
require.Equal(t, byte(Unsuback<<4)|wanted.meta.(byte), encoded[0], "Mismatched mod fixed header packets [i:%d] %s", i, wanted.desc)
|
|
} else {
|
|
require.Equal(t, byte(Unsuback<<4), encoded[0], "Mismatched fixed header packets [i:%d] %s", i, wanted.desc)
|
|
}
|
|
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkUnsubackEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Unsuback][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.UnsubackEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestUnsubackDecode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Unsuback)
|
|
for i, wanted := range expectedPackets[Unsuback] {
|
|
if !decodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(11), Unsuback, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Unsuback}}
|
|
err := pk.UnsubackDecode(wanted.rawBytes[2:]) // Unpack skips fixedheader.
|
|
if wanted.failFirst != nil {
|
|
require.Error(t, err, "Expected error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.True(t, errors.Is(err, wanted.failFirst), "Expected fail state; %v [i:%d] %s", err.Error(), i, wanted.desc)
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err, "Error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkUnsubackDecode(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Unsuback}}
|
|
pk.FixedHeader.Decode(expectedPackets[Unsuback][0].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.UnsubackDecode(expectedPackets[Unsuback][0].rawBytes[2:])
|
|
}
|
|
}
|
|
|
|
func TestUnsubscribeEncode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Unsubscribe)
|
|
for i, wanted := range expectedPackets[Unsubscribe] {
|
|
if !encodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(10), Unsubscribe, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
pk := new(Packet)
|
|
copier.Copy(pk, wanted.packet)
|
|
|
|
require.Equal(t, Unsubscribe, pk.FixedHeader.Type, "Mismatched FixedHeader Type [i:%d] %s", i, wanted.desc)
|
|
|
|
buf := new(bytes.Buffer)
|
|
err := pk.UnsubscribeEncode(buf)
|
|
encoded := buf.Bytes()
|
|
if wanted.expect != nil {
|
|
require.Error(t, err, "Expected error writing buffer [i:%d] %s", i, wanted.desc)
|
|
} else {
|
|
require.NoError(t, err, "Error writing buffer [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, len(wanted.rawBytes), len(encoded), "Mismatched packet length [i:%d] %s", i, wanted.desc)
|
|
if wanted.meta != nil {
|
|
require.Equal(t, byte(Unsubscribe<<4)|wanted.meta.(byte), encoded[0], "Mismatched fixed header bytes [i:%d] %s", i, wanted.desc)
|
|
} else {
|
|
require.Equal(t, byte(Unsubscribe<<4), encoded[0], "Mismatched fixed header bytes [i:%d] %s", i, wanted.desc)
|
|
}
|
|
|
|
require.NoError(t, err, "Error writing buffer [i:%d] %s", i, wanted.desc)
|
|
require.EqualValues(t, wanted.rawBytes, encoded, "Mismatched byte values [i:%d] %s", i, wanted.desc)
|
|
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.Topics, pk.Topics, "Mismatched Topics slice [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkUnsubscribeEncode(b *testing.B) {
|
|
pk := new(Packet)
|
|
copier.Copy(pk, expectedPackets[Unsubscribe][0].packet)
|
|
|
|
buf := new(bytes.Buffer)
|
|
for n := 0; n < b.N; n++ {
|
|
pk.UnsubscribeEncode(buf)
|
|
}
|
|
}
|
|
|
|
func TestUnsubscribeDecode(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Unsubscribe)
|
|
for i, wanted := range expectedPackets[Unsubscribe] {
|
|
if !decodeTestOK(wanted) {
|
|
continue
|
|
}
|
|
|
|
require.Equal(t, uint8(10), Unsubscribe, "Incorrect Packet Type [i:%d] %s", i, wanted.desc)
|
|
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Unsubscribe, Qos: 1}}
|
|
err := pk.UnsubscribeDecode(wanted.rawBytes[2:]) // Unpack skips fixedheader.
|
|
if wanted.failFirst != nil {
|
|
require.Error(t, err, "Expected error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.True(t, errors.Is(err, wanted.failFirst), "Expected fail state; %v [i:%d] %s", err.Error(), i, wanted.desc)
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err, "Error unpacking buffer [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.PacketID, pk.PacketID, "Mismatched Packet ID [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, wanted.packet.Topics, pk.Topics, "Mismatched Topics slice [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
|
|
func BenchmarkUnsubscribeDecode(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Unsubscribe, Qos: 1}}
|
|
pk.FixedHeader.Decode(expectedPackets[Unsubscribe][0].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.UnsubscribeDecode(expectedPackets[Unsubscribe][0].rawBytes[2:])
|
|
}
|
|
}
|
|
|
|
func TestUnsubscribeValidate(t *testing.T) {
|
|
require.Contains(t, expectedPackets, Unsubscribe)
|
|
for i, wanted := range expectedPackets[Unsubscribe] {
|
|
if wanted.group == "validate" || i == 0 {
|
|
pk := wanted.packet
|
|
ok, err := pk.UnsubscribeValidate()
|
|
if i == 0 {
|
|
require.NoError(t, err, "Unsubscribe should have validated - error incorrect [i:%d] %s", i, wanted.desc)
|
|
require.Equal(t, Accepted, ok, "Unsubscribe should have validated - code incorrect [i:%d] %s", i, wanted.desc)
|
|
} else {
|
|
require.Equal(t, Failed, ok, "Unsubscribe packet didn't validate - code incorrect [i:%d] %s", i, wanted.desc)
|
|
if err != nil {
|
|
require.Equal(t, wanted.expect, err, "Unsubscribe packet didn't validate - error incorrect [i:%d] %s", i, wanted.desc)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
func BenchmarkUnsubscribeValidate(b *testing.B) {
|
|
pk := &Packet{FixedHeader: FixedHeader{Type: Unsubscribe, Qos: 1}}
|
|
pk.FixedHeader.Decode(expectedPackets[Unsubscribe][0].rawBytes[0])
|
|
|
|
for n := 0; n < b.N; n++ {
|
|
pk.UnsubscribeValidate()
|
|
}
|
|
}
|
|
|
|
func TestFormatPacketID(t *testing.T) {
|
|
for _, id := range []uint16{0, 7, 0x100, 0xffff} {
|
|
packet := &Packet{PacketID: id}
|
|
require.Equal(t, fmt.Sprint(id), packet.FormatID())
|
|
}
|
|
}
|