119 lines
2.8 KiB
Go
119 lines
2.8 KiB
Go
package parser
|
|
|
|
import (
|
|
"testing"
|
|
)
|
|
|
|
// Hilfsfunktion zum Berechnen der Checksumme
|
|
func calcChecksum(msgType byte, length byte, payload []byte) byte {
|
|
cs := msgType ^ length
|
|
for _, b := range payload {
|
|
cs ^= b
|
|
}
|
|
return cs
|
|
}
|
|
|
|
func TestParser_ParseBytes(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
input []byte
|
|
expectErr bool
|
|
expectMessages []ParsedMessage
|
|
}{
|
|
{
|
|
name: "valid single message",
|
|
input: func() []byte {
|
|
msgType := byte(0x01)
|
|
payload := []byte{0x10, 0x20}
|
|
length := byte(len(payload))
|
|
cs := calcChecksum(msgType, length, payload)
|
|
return []byte{0xAA, msgType, length, payload[0], payload[1], cs}
|
|
}(),
|
|
expectErr: false,
|
|
expectMessages: []ParsedMessage{
|
|
{typeByte: 0x01, payloadBytes: []byte{0x10, 0x20}},
|
|
},
|
|
},
|
|
{
|
|
name: "invalid checksum",
|
|
input: []byte{
|
|
0xAA, 0x02, 0x01, 0x33, 0x00, // falsche Checksumme (letztes Byte)
|
|
},
|
|
expectErr: true,
|
|
expectMessages: nil,
|
|
},
|
|
{
|
|
name: "no start byte",
|
|
input: []byte{
|
|
0x01, 0x02, 0x03,
|
|
},
|
|
expectErr: false,
|
|
expectMessages: nil,
|
|
},
|
|
{
|
|
name: "multiple valid messages",
|
|
input: func() []byte {
|
|
payload1 := []byte{0x11}
|
|
payload2 := []byte{0x22, 0x23}
|
|
cs1 := calcChecksum(0x01, 1, payload1)
|
|
cs2 := calcChecksum(0x02, 2, payload2)
|
|
return append(
|
|
[]byte{0xAA, 0x01, 0x01, payload1[0], cs1,
|
|
0xAA, 0x02, 0x02, payload2[0], payload2[1], cs2},
|
|
)
|
|
}(),
|
|
expectErr: false,
|
|
expectMessages: []ParsedMessage{
|
|
{typeByte: 0x01, payloadBytes: []byte{0x11}},
|
|
{typeByte: 0x02, payloadBytes: []byte{0x22, 0x23}},
|
|
},
|
|
},
|
|
}
|
|
|
|
for _, tt := range tests {
|
|
t.Run(tt.name, func(t *testing.T) {
|
|
parser := NewParser(ParserConfig{StartByte: 0xAA})
|
|
n, err := parser.ParseBytes(tt.input)
|
|
|
|
if tt.expectErr && err == nil {
|
|
t.Errorf("expected error, got none")
|
|
}
|
|
if !tt.expectErr && err != nil {
|
|
t.Errorf("unexpected error: %v", err)
|
|
}
|
|
if !tt.expectErr && n != len(tt.input) {
|
|
t.Errorf("expected to read %d bytes, read %d", len(tt.input), n)
|
|
}
|
|
|
|
for i, expected := range tt.expectMessages {
|
|
if !parser.IsMessageAvailable() {
|
|
t.Errorf("expected message %d to be available", i)
|
|
break
|
|
}
|
|
msgtype, msgpayload, err := parser.GetNextMessage()
|
|
if err != nil {
|
|
t.Errorf("unexpected error when getting message: %v", err)
|
|
}
|
|
if msgtype != expected.typeByte {
|
|
t.Errorf("message %d: expected type 0x%02X, got 0x%02X", i, expected.typeByte, msgtype)
|
|
}
|
|
if !equalBytes(msgpayload, expected.payloadBytes) {
|
|
t.Errorf("message %d: expected payload %v, got %v", i, expected.payloadBytes, msgpayload)
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func equalBytes(a, b []byte) bool {
|
|
if len(a) != len(b) {
|
|
return false
|
|
}
|
|
for i := range a {
|
|
if a[i] != b[i] {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|