Mirror/Erupe
1
0
Fork 0
mirror of https://github.com/Mezeporta/Erupe.git synced 2026-03-21 23:22:34 +01:00
Code Issues Packages Projects Releases Wiki Activity

tests(network): adds tests for network features (except mhfpacket).

Browse Source
This commit is contained in:
Houmgaor
2025-10-27 12:18:41 +01:00
parent 25d218fbcd
commit 127d3af167
6 changed files with 1901 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

385
network/crypt_packet_test.go Normal file
View File

@@ -0,0 +1,385 @@
package network
import (
"bytes"
"testing"
)
func TestNewCryptPacketHeader_ValidData(t *testing.T) {
tests := []struct {
name string
data []byte
expected *CryptPacketHeader
}{
{
name: "basic header",
data: []byte{
0x03, // Pf0
0x03, // KeyRotDelta
0x00, 0x01, // PacketNum (1)
0x00, 0x0A, // DataSize (10)
0x00, 0x00, // PrevPacketCombinedCheck (0)
0x12, 0x34, // Check0 (0x1234)
0x56, 0x78, // Check1 (0x5678)
0x9A, 0xBC, // Check2 (0x9ABC)
},
expected: &CryptPacketHeader{
Pf0: 0x03,
KeyRotDelta: 0x03,
PacketNum: 1,
DataSize: 10,
PrevPacketCombinedCheck: 0,
Check0: 0x1234,
Check1: 0x5678,
Check2: 0x9ABC,
},
},
{
name: "all zero values",
data: []byte{
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
},
expected: &CryptPacketHeader{
Pf0: 0x00,
KeyRotDelta: 0x00,
PacketNum: 0,
DataSize: 0,
PrevPacketCombinedCheck: 0,
Check0: 0,
Check1: 0,
Check2: 0,
},
},
{
name: "max values",
data: []byte{
0xFF, 0xFF,
0xFF, 0xFF,
0xFF, 0xFF,
0xFF, 0xFF,
0xFF, 0xFF,
0xFF, 0xFF,
0xFF, 0xFF,
},
expected: &CryptPacketHeader{
Pf0: 0xFF,
KeyRotDelta: 0xFF,
PacketNum: 0xFFFF,
DataSize: 0xFFFF,
PrevPacketCombinedCheck: 0xFFFF,
Check0: 0xFFFF,
Check1: 0xFFFF,
Check2: 0xFFFF,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := NewCryptPacketHeader(tt.data)
if err != nil {
t.Fatalf("NewCryptPacketHeader() error = %v, want nil", err)
}
if result.Pf0 != tt.expected.Pf0 {
t.Errorf("Pf0 = 0x%X, want 0x%X", result.Pf0, tt.expected.Pf0)
}
if result.KeyRotDelta != tt.expected.KeyRotDelta {
t.Errorf("KeyRotDelta = 0x%X, want 0x%X", result.KeyRotDelta, tt.expected.KeyRotDelta)
}
if result.PacketNum != tt.expected.PacketNum {
t.Errorf("PacketNum = 0x%X, want 0x%X", result.PacketNum, tt.expected.PacketNum)
}
if result.DataSize != tt.expected.DataSize {
t.Errorf("DataSize = 0x%X, want 0x%X", result.DataSize, tt.expected.DataSize)
}
if result.PrevPacketCombinedCheck != tt.expected.PrevPacketCombinedCheck {
t.Errorf("PrevPacketCombinedCheck = 0x%X, want 0x%X", result.PrevPacketCombinedCheck, tt.expected.PrevPacketCombinedCheck)
}
if result.Check0 != tt.expected.Check0 {
t.Errorf("Check0 = 0x%X, want 0x%X", result.Check0, tt.expected.Check0)
}
if result.Check1 != tt.expected.Check1 {
t.Errorf("Check1 = 0x%X, want 0x%X", result.Check1, tt.expected.Check1)
}
if result.Check2 != tt.expected.Check2 {
t.Errorf("Check2 = 0x%X, want 0x%X", result.Check2, tt.expected.Check2)
}
})
}
}
func TestNewCryptPacketHeader_InvalidData(t *testing.T) {
tests := []struct {
name string
data []byte
}{
{
name: "empty data",
data: []byte{},
},
{
name: "too short - 1 byte",
data: []byte{0x03},
},
{
name: "too short - 13 bytes",
data: []byte{0x03, 0x03, 0x00, 0x01, 0x00, 0x0A, 0x00, 0x00, 0x12, 0x34, 0x56, 0x78, 0x9A},
},
{
name: "too short - 7 bytes",
data: []byte{0x03, 0x03, 0x00, 0x01, 0x00, 0x0A, 0x00},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
_, err := NewCryptPacketHeader(tt.data)
if err == nil {
t.Fatal("NewCryptPacketHeader() error = nil, want error")
}
})
}
}
func TestNewCryptPacketHeader_ExtraDataIgnored(t *testing.T) {
// Test that extra data beyond 14 bytes is ignored
data := []byte{
0x03, 0x03,
0x00, 0x01,
0x00, 0x0A,
0x00, 0x00,
0x12, 0x34,
0x56, 0x78,
0x9A, 0xBC,
0xFF, 0xFF, 0xFF, // Extra bytes
}
result, err := NewCryptPacketHeader(data)
if err != nil {
t.Fatalf("NewCryptPacketHeader() error = %v, want nil", err)
}
expected := &CryptPacketHeader{
Pf0: 0x03,
KeyRotDelta: 0x03,
PacketNum: 1,
DataSize: 10,
PrevPacketCombinedCheck: 0,
Check0: 0x1234,
Check1: 0x5678,
Check2: 0x9ABC,
}
if result.Pf0 != expected.Pf0 || result.KeyRotDelta != expected.KeyRotDelta ||
result.PacketNum != expected.PacketNum || result.DataSize != expected.DataSize {
t.Errorf("Extra data affected parsing")
}
}
func TestCryptPacketHeader_Encode(t *testing.T) {
tests := []struct {
name string
header *CryptPacketHeader
expected []byte
}{
{
name: "basic header",
header: &CryptPacketHeader{
Pf0: 0x03,
KeyRotDelta: 0x03,
PacketNum: 1,
DataSize: 10,
PrevPacketCombinedCheck: 0,
Check0: 0x1234,
Check1: 0x5678,
Check2: 0x9ABC,
},
expected: []byte{
0x03, 0x03,
0x00, 0x01,
0x00, 0x0A,
0x00, 0x00,
0x12, 0x34,
0x56, 0x78,
0x9A, 0xBC,
},
},
{
name: "all zeros",
header: &CryptPacketHeader{
Pf0: 0x00,
KeyRotDelta: 0x00,
PacketNum: 0,
DataSize: 0,
PrevPacketCombinedCheck: 0,
Check0: 0,
Check1: 0,
Check2: 0,
},
expected: []byte{
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
0x00, 0x00,
},
},
{
name: "max values",
header: &CryptPacketHeader{
Pf0: 0xFF,
KeyRotDelta: 0xFF,
PacketNum: 0xFFFF,
DataSize: 0xFFFF,
PrevPacketCombinedCheck: 0xFFFF,
Check0: 0xFFFF,
Check1: 0xFFFF,
Check2: 0xFFFF,
},
expected: []byte{
0xFF, 0xFF,
0xFF, 0xFF,
0xFF, 0xFF,
0xFF, 0xFF,
0xFF, 0xFF,
0xFF, 0xFF,
0xFF, 0xFF,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
result, err := tt.header.Encode()
if err != nil {
t.Fatalf("Encode() error = %v, want nil", err)
}
if !bytes.Equal(result, tt.expected) {
t.Errorf("Encode() = %v, want %v", result, tt.expected)
}
// Check that the length is always 14
if len(result) != CryptPacketHeaderLength {
t.Errorf("Encode() length = %d, want %d", len(result), CryptPacketHeaderLength)
}
})
}
}
func TestCryptPacketHeader_RoundTrip(t *testing.T) {
tests := []struct {
name string
header *CryptPacketHeader
}{
{
name: "basic header",
header: &CryptPacketHeader{
Pf0: 0x03,
KeyRotDelta: 0x03,
PacketNum: 100,
DataSize: 1024,
PrevPacketCombinedCheck: 0x1234,
Check0: 0xABCD,
Check1: 0xEF01,
Check2: 0x2345,
},
},
{
name: "zero values",
header: &CryptPacketHeader{
Pf0: 0x00,
KeyRotDelta: 0x00,
PacketNum: 0,
DataSize: 0,
PrevPacketCombinedCheck: 0,
Check0: 0,
Check1: 0,
Check2: 0,
},
},
{
name: "max values",
header: &CryptPacketHeader{
Pf0: 0xFF,
KeyRotDelta: 0xFF,
PacketNum: 0xFFFF,
DataSize: 0xFFFF,
PrevPacketCombinedCheck: 0xFFFF,
Check0: 0xFFFF,
Check1: 0xFFFF,
Check2: 0xFFFF,
},
},
{
name: "realistic values",
header: &CryptPacketHeader{
Pf0: 0x07,
KeyRotDelta: 0x03,
PacketNum: 523,
DataSize: 2048,
PrevPacketCombinedCheck: 0x2A56,
Check0: 0x06EA,
Check1: 0x0215,
Check2: 0x8FB3,
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Encode
encoded, err := tt.header.Encode()
if err != nil {
t.Fatalf("Encode() error = %v, want nil", err)
}
// Decode
decoded, err := NewCryptPacketHeader(encoded)
if err != nil {
t.Fatalf("NewCryptPacketHeader() error = %v, want nil", err)
}
// Compare
if decoded.Pf0 != tt.header.Pf0 {
t.Errorf("Pf0 = 0x%X, want 0x%X", decoded.Pf0, tt.header.Pf0)
}
if decoded.KeyRotDelta != tt.header.KeyRotDelta {
t.Errorf("KeyRotDelta = 0x%X, want 0x%X", decoded.KeyRotDelta, tt.header.KeyRotDelta)
}
if decoded.PacketNum != tt.header.PacketNum {
t.Errorf("PacketNum = 0x%X, want 0x%X", decoded.PacketNum, tt.header.PacketNum)
}
if decoded.DataSize != tt.header.DataSize {
t.Errorf("DataSize = 0x%X, want 0x%X", decoded.DataSize, tt.header.DataSize)
}
if decoded.PrevPacketCombinedCheck != tt.header.PrevPacketCombinedCheck {
t.Errorf("PrevPacketCombinedCheck = 0x%X, want 0x%X", decoded.PrevPacketCombinedCheck, tt.header.PrevPacketCombinedCheck)
}
if decoded.Check0 != tt.header.Check0 {
t.Errorf("Check0 = 0x%X, want 0x%X", decoded.Check0, tt.header.Check0)
}
if decoded.Check1 != tt.header.Check1 {
t.Errorf("Check1 = 0x%X, want 0x%X", decoded.Check1, tt.header.Check1)
}
if decoded.Check2 != tt.header.Check2 {
t.Errorf("Check2 = 0x%X, want 0x%X", decoded.Check2, tt.header.Check2)
}
})
}
}
func TestCryptPacketHeaderLength_Constant(t *testing.T) {
if CryptPacketHeaderLength != 14 {
t.Errorf("CryptPacketHeaderLength = %d, want 14", CryptPacketHeaderLength)
}
}