Mirror/Erupe
1
0
Fork 0
mirror of https://github.com/Mezeporta/Erupe.git synced 2026-03-26 17:43:21 +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

380
network/binpacket/msg_bin_chat_test.go Normal file
View File

@@ -0,0 +1,380 @@
package binpacket
import (
"bytes"
"erupe-ce/common/byteframe"
"erupe-ce/network"
"testing"
)
func TestMsgBinChat_Opcode(t *testing.T) {
msg := &MsgBinChat{}
if msg.Opcode() != network.MSG_SYS_CAST_BINARY {
t.Errorf("Opcode() = %v, want %v", msg.Opcode(), network.MSG_SYS_CAST_BINARY)
}
}
func TestMsgBinChat_Build(t *testing.T) {
tests := []struct {
name string
msg *MsgBinChat
wantErr bool
validate func(*testing.T, []byte)
}{
{
name: "basic message",
msg: &MsgBinChat{
Unk0: 0x01,
Type: ChatTypeWorld,
Flags: 0x0000,
Message: "Hello",
SenderName: "Player1",
},
wantErr: false,
validate: func(t *testing.T, data []byte) {
if len(data) == 0 {
t.Error("Build() returned empty data")
}
// Verify the structure starts with Unk0, Type, Flags
if data[0] != 0x01 {
t.Errorf("Unk0 = 0x%X, want 0x01", data[0])
}
if data[1] != byte(ChatTypeWorld) {
t.Errorf("Type = 0x%X, want 0x%X", data[1], byte(ChatTypeWorld))
}
},
},
{
name: "all chat types",
msg: &MsgBinChat{
Unk0: 0x00,
Type: ChatTypeStage,
Flags: 0x1234,
Message: "Test",
SenderName: "Sender",
},
wantErr: false,
},
{
name: "empty message",
msg: &MsgBinChat{
Unk0: 0x00,
Type: ChatTypeGuild,
Flags: 0x0000,
Message: "",
SenderName: "Player",
},
wantErr: false,
},
{
name: "empty sender",
msg: &MsgBinChat{
Unk0: 0x00,
Type: ChatTypeParty,
Flags: 0x0000,
Message: "Hello",
SenderName: "",
},
wantErr: false,
},
{
name: "long message",
msg: &MsgBinChat{
Unk0: 0x00,
Type: ChatTypeWhisper,
Flags: 0x0000,
Message: "This is a very long message that contains a lot of text to test the handling of longer strings in the binary packet format.",
SenderName: "LongNamePlayer",
},
wantErr: false,
},
{
name: "special characters",
msg: &MsgBinChat{
Unk0: 0x00,
Type: ChatTypeAlliance,
Flags: 0x0000,
Message: "Hello!@#$%^&*()",
SenderName: "Player_123",
},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
bf := byteframe.NewByteFrame()
err := tt.msg.Build(bf)
if (err != nil) != tt.wantErr {
t.Errorf("Build() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !tt.wantErr {
data := bf.Data()
if tt.validate != nil {
tt.validate(t, data)
}
}
})
}
}
func TestMsgBinChat_Parse(t *testing.T) {
tests := []struct {
name string
data []byte
want *MsgBinChat
wantErr bool
}{
{
name: "basic message",
data: []byte{
0x01, // Unk0
0x00, // Type (ChatTypeWorld)
0x00, 0x00, // Flags
0x00, 0x08, // lenSenderName (8)
0x00, 0x06, // lenMessage (6)
// Message: "Hello" + null terminator (SJIS compatible ASCII)
0x48, 0x65, 0x6C, 0x6C, 0x6F, 0x00,
// SenderName: "Player1" + null terminator
0x50, 0x6C, 0x61, 0x79, 0x65, 0x72, 0x31, 0x00,
},
want: &MsgBinChat{
Unk0: 0x01,
Type: ChatTypeWorld,
Flags: 0x0000,
Message: "Hello",
SenderName: "Player1",
},
wantErr: false,
},
{
name: "different chat type",
data: []byte{
0x00, // Unk0
0x02, // Type (ChatTypeGuild)
0x12, 0x34, // Flags
0x00, 0x05, // lenSenderName
0x00, 0x03, // lenMessage
// Message: "Hi" + null
0x48, 0x69, 0x00,
// SenderName: "Bob" + null + padding
0x42, 0x6F, 0x62, 0x00, 0x00,
},
want: &MsgBinChat{
Unk0: 0x00,
Type: ChatTypeGuild,
Flags: 0x1234,
Message: "Hi",
SenderName: "Bob",
},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
bf := byteframe.NewByteFrameFromBytes(tt.data)
msg := &MsgBinChat{}
err := msg.Parse(bf)
if (err != nil) != tt.wantErr {
t.Errorf("Parse() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !tt.wantErr {
if msg.Unk0 != tt.want.Unk0 {
t.Errorf("Unk0 = 0x%X, want 0x%X", msg.Unk0, tt.want.Unk0)
}
if msg.Type != tt.want.Type {
t.Errorf("Type = %v, want %v", msg.Type, tt.want.Type)
}
if msg.Flags != tt.want.Flags {
t.Errorf("Flags = 0x%X, want 0x%X", msg.Flags, tt.want.Flags)
}
if msg.Message != tt.want.Message {
t.Errorf("Message = %q, want %q", msg.Message, tt.want.Message)
}
if msg.SenderName != tt.want.SenderName {
t.Errorf("SenderName = %q, want %q", msg.SenderName, tt.want.SenderName)
}
}
})
}
}
func TestMsgBinChat_RoundTrip(t *testing.T) {
tests := []struct {
name string
msg *MsgBinChat
}{
{
name: "world chat",
msg: &MsgBinChat{
Unk0: 0x01,
Type: ChatTypeWorld,
Flags: 0x0000,
Message: "Hello World",
SenderName: "TestPlayer",
},
},
{
name: "stage chat",
msg: &MsgBinChat{
Unk0: 0x00,
Type: ChatTypeStage,
Flags: 0x1234,
Message: "Stage message",
SenderName: "Player2",
},
},
{
name: "guild chat",
msg: &MsgBinChat{
Unk0: 0x02,
Type: ChatTypeGuild,
Flags: 0xFFFF,
Message: "Guild announcement",
SenderName: "GuildMaster",
},
},
{
name: "alliance chat",
msg: &MsgBinChat{
Unk0: 0x00,
Type: ChatTypeAlliance,
Flags: 0x0001,
Message: "Alliance msg",
SenderName: "AllyLeader",
},
},
{
name: "party chat",
msg: &MsgBinChat{
Unk0: 0x01,
Type: ChatTypeParty,
Flags: 0x0000,
Message: "Party up!",
SenderName: "PartyLeader",
},
},
{
name: "whisper",
msg: &MsgBinChat{
Unk0: 0x00,
Type: ChatTypeWhisper,
Flags: 0x0002,
Message: "Secret message",
SenderName: "Whisperer",
},
},
{
name: "empty strings",
msg: &MsgBinChat{
Unk0: 0x00,
Type: ChatTypeWorld,
Flags: 0x0000,
Message: "",
SenderName: "",
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Build
bf := byteframe.NewByteFrame()
err := tt.msg.Build(bf)
if err != nil {
t.Fatalf("Build() error = %v", err)
}
// Parse
parsedMsg := &MsgBinChat{}
parsedBf := byteframe.NewByteFrameFromBytes(bf.Data())
err = parsedMsg.Parse(parsedBf)
if err != nil {
t.Fatalf("Parse() error = %v", err)
}
// Compare
if parsedMsg.Unk0 != tt.msg.Unk0 {
t.Errorf("Unk0 = 0x%X, want 0x%X", parsedMsg.Unk0, tt.msg.Unk0)
}
if parsedMsg.Type != tt.msg.Type {
t.Errorf("Type = %v, want %v", parsedMsg.Type, tt.msg.Type)
}
if parsedMsg.Flags != tt.msg.Flags {
t.Errorf("Flags = 0x%X, want 0x%X", parsedMsg.Flags, tt.msg.Flags)
}
if parsedMsg.Message != tt.msg.Message {
t.Errorf("Message = %q, want %q", parsedMsg.Message, tt.msg.Message)
}
if parsedMsg.SenderName != tt.msg.SenderName {
t.Errorf("SenderName = %q, want %q", parsedMsg.SenderName, tt.msg.SenderName)
}
})
}
}
func TestChatType_Values(t *testing.T) {
tests := []struct {
chatType ChatType
expected uint8
}{
{ChatTypeWorld, 0},
{ChatTypeStage, 1},
{ChatTypeGuild, 2},
{ChatTypeAlliance, 3},
{ChatTypeParty, 4},
{ChatTypeWhisper, 5},
}
for _, tt := range tests {
if uint8(tt.chatType) != tt.expected {
t.Errorf("ChatType value = %d, want %d", uint8(tt.chatType), tt.expected)
}
}
}
func TestMsgBinChat_BuildParseConsistency(t *testing.T) {
// Test that Build and Parse are consistent with each other
// by building, parsing, building again, and comparing
original := &MsgBinChat{
Unk0: 0x01,
Type: ChatTypeWorld,
Flags: 0x1234,
Message: "Test message",
SenderName: "TestSender",
}
// First build
bf1 := byteframe.NewByteFrame()
err := original.Build(bf1)
if err != nil {
t.Fatalf("First Build() error = %v", err)
}
// Parse
parsed := &MsgBinChat{}
parsedBf := byteframe.NewByteFrameFromBytes(bf1.Data())
err = parsed.Parse(parsedBf)
if err != nil {
t.Fatalf("Parse() error = %v", err)
}
// Second build
bf2 := byteframe.NewByteFrame()
err = parsed.Build(bf2)
if err != nil {
t.Fatalf("Second Build() error = %v", err)
}
// Compare the two builds
if !bytes.Equal(bf1.Data(), bf2.Data()) {
t.Errorf("Build-Parse-Build inconsistency:\nFirst: %v\nSecond: %v", bf1.Data(), bf2.Data())
}
}

219
network/binpacket/msg_bin_mail_notify_test.go Normal file
View File

@@ -0,0 +1,219 @@
package binpacket
import (
"erupe-ce/common/byteframe"
"erupe-ce/network"
"testing"
)
func TestMsgBinMailNotify_Opcode(t *testing.T) {
msg := MsgBinMailNotify{}
if msg.Opcode() != network.MSG_SYS_CASTED_BINARY {
t.Errorf("Opcode() = %v, want %v", msg.Opcode(), network.MSG_SYS_CASTED_BINARY)
}
}
func TestMsgBinMailNotify_Build(t *testing.T) {
tests := []struct {
name string
senderName string
wantErr bool
validate func(*testing.T, []byte)
}{
{
name: "basic sender name",
senderName: "Player1",
wantErr: false,
validate: func(t *testing.T, data []byte) {
if len(data) == 0 {
t.Error("Build() returned empty data")
}
// First byte should be 0x01 (Unk)
if data[0] != 0x01 {
t.Errorf("First byte = 0x%X, want 0x01", data[0])
}
// Total length should be 1 (Unk) + 21 (padded string)
expectedLen := 1 + 21
if len(data) != expectedLen {
t.Errorf("data length = %d, want %d", len(data), expectedLen)
}
},
},
{
name: "empty sender name",
senderName: "",
wantErr: false,
validate: func(t *testing.T, data []byte) {
if len(data) != 22 { // 1 + 21
t.Errorf("data length = %d, want 22", len(data))
}
},
},
{
name: "long sender name",
senderName: "VeryLongPlayerNameThatExceeds21Characters",
wantErr: false,
validate: func(t *testing.T, data []byte) {
if len(data) != 22 { // 1 + 21 (truncated/padded)
t.Errorf("data length = %d, want 22", len(data))
}
},
},
{
name: "exactly 21 characters",
senderName: "ExactlyTwentyOneChar1",
wantErr: false,
validate: func(t *testing.T, data []byte) {
if len(data) != 22 {
t.Errorf("data length = %d, want 22", len(data))
}
},
},
{
name: "special characters",
senderName: "Player_123",
wantErr: false,
validate: func(t *testing.T, data []byte) {
if len(data) != 22 {
t.Errorf("data length = %d, want 22", len(data))
}
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
msg := MsgBinMailNotify{
SenderName: tt.senderName,
}
bf := byteframe.NewByteFrame()
err := msg.Build(bf)
if (err != nil) != tt.wantErr {
t.Errorf("Build() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !tt.wantErr && tt.validate != nil {
tt.validate(t, bf.Data())
}
})
}
}
func TestMsgBinMailNotify_Parse_Panics(t *testing.T) {
// Document that Parse() is not implemented and panics
msg := MsgBinMailNotify{}
bf := byteframe.NewByteFrame()
defer func() {
if r := recover(); r == nil {
t.Error("Parse() did not panic, but should panic with 'implement me'")
}
}()
// This should panic
_ = msg.Parse(bf)
}
func TestMsgBinMailNotify_BuildMultiple(t *testing.T) {
// Test building multiple messages to ensure no state pollution
names := []string{"Player1", "Player2", "Player3"}
for _, name := range names {
msg := MsgBinMailNotify{SenderName: name}
bf := byteframe.NewByteFrame()
err := msg.Build(bf)
if err != nil {
t.Errorf("Build(%s) error = %v", name, err)
}
data := bf.Data()
if len(data) != 22 {
t.Errorf("Build(%s) length = %d, want 22", name, len(data))
}
}
}
func TestMsgBinMailNotify_PaddingBehavior(t *testing.T) {
// Test that the padded string is always 21 bytes
tests := []struct {
name string
senderName string
}{
{"short", "A"},
{"medium", "PlayerName"},
{"long", "VeryVeryLongPlayerName"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
msg := MsgBinMailNotify{SenderName: tt.senderName}
bf := byteframe.NewByteFrame()
err := msg.Build(bf)
if err != nil {
t.Fatalf("Build() error = %v", err)
}
data := bf.Data()
// Skip first byte (Unk), check remaining 21 bytes
if len(data) < 22 {
t.Fatalf("data too short: %d bytes", len(data))
}
paddedString := data[1:22]
if len(paddedString) != 21 {
t.Errorf("padded string length = %d, want 21", len(paddedString))
}
})
}
}
func TestMsgBinMailNotify_BuildStructure(t *testing.T) {
// Test the structure of the built data
msg := MsgBinMailNotify{SenderName: "Test"}
bf := byteframe.NewByteFrame()
err := msg.Build(bf)
if err != nil {
t.Fatalf("Build() error = %v", err)
}
data := bf.Data()
// Check structure: 1 byte Unk + 21 bytes padded string = 22 bytes total
if len(data) != 22 {
t.Errorf("data length = %d, want 22", len(data))
}
// First byte should be 0x01
if data[0] != 0x01 {
t.Errorf("Unk byte = 0x%X, want 0x01", data[0])
}
// The rest (21 bytes) should contain the sender name (SJIS encoded) and padding
// We can't verify exact content without knowing SJIS encoding details,
// but we can verify length
paddedPortion := data[1:]
if len(paddedPortion) != 21 {
t.Errorf("padded portion length = %d, want 21", len(paddedPortion))
}
}
func TestMsgBinMailNotify_ValueSemantics(t *testing.T) {
// Test that MsgBinMailNotify uses value semantics (not pointer receiver for Opcode)
msg := MsgBinMailNotify{SenderName: "Test"}
// Should work with value
opcode := msg.Opcode()
if opcode != network.MSG_SYS_CASTED_BINARY {
t.Errorf("Opcode() = %v, want %v", opcode, network.MSG_SYS_CASTED_BINARY)
}
// Should also work with pointer (Go allows this)
msgPtr := &MsgBinMailNotify{SenderName: "Test"}
opcode2 := msgPtr.Opcode()
if opcode2 != network.MSG_SYS_CASTED_BINARY {
t.Errorf("Opcode() on pointer = %v, want %v", opcode2, network.MSG_SYS_CASTED_BINARY)
}
}

404
network/binpacket/msg_bin_targeted_test.go Normal file
View File

@@ -0,0 +1,404 @@
package binpacket
import (
"bytes"
"erupe-ce/common/byteframe"
"erupe-ce/network"
"testing"
)
func TestMsgBinTargeted_Opcode(t *testing.T) {
msg := &MsgBinTargeted{}
if msg.Opcode() != network.MSG_SYS_CAST_BINARY {
t.Errorf("Opcode() = %v, want %v", msg.Opcode(), network.MSG_SYS_CAST_BINARY)
}
}
func TestMsgBinTargeted_Build(t *testing.T) {
tests := []struct {
name string
msg *MsgBinTargeted
wantErr bool
validate func(*testing.T, []byte)
}{
{
name: "single target with payload",
msg: &MsgBinTargeted{
TargetCount: 1,
TargetCharIDs: []uint32{12345},
RawDataPayload: []byte{0x01, 0x02, 0x03, 0x04},
},
wantErr: false,
validate: func(t *testing.T, data []byte) {
if len(data) < 2+4+4 { // 2 bytes count + 4 bytes ID + 4 bytes payload
t.Errorf("data length = %d, want at least %d", len(data), 2+4+4)
}
},
},
{
name: "multiple targets",
msg: &MsgBinTargeted{
TargetCount: 3,
TargetCharIDs: []uint32{100, 200, 300},
RawDataPayload: []byte{0xAA, 0xBB},
},
wantErr: false,
validate: func(t *testing.T, data []byte) {
expectedLen := 2 + (3 * 4) + 2 // count + 3 IDs + payload
if len(data) != expectedLen {
t.Errorf("data length = %d, want %d", len(data), expectedLen)
}
},
},
{
name: "zero targets",
msg: &MsgBinTargeted{
TargetCount: 0,
TargetCharIDs: []uint32{},
RawDataPayload: []byte{0xFF},
},
wantErr: false,
validate: func(t *testing.T, data []byte) {
if len(data) < 2+1 { // count + payload
t.Errorf("data length = %d, want at least %d", len(data), 2+1)
}
},
},
{
name: "empty payload",
msg: &MsgBinTargeted{
TargetCount: 1,
TargetCharIDs: []uint32{999},
RawDataPayload: []byte{},
},
wantErr: false,
validate: func(t *testing.T, data []byte) {
expectedLen := 2 + 4 // count + 1 ID
if len(data) != expectedLen {
t.Errorf("data length = %d, want %d", len(data), expectedLen)
}
},
},
{
name: "large payload",
msg: &MsgBinTargeted{
TargetCount: 2,
TargetCharIDs: []uint32{1000, 2000},
RawDataPayload: bytes.Repeat([]byte{0xCC}, 256),
},
wantErr: false,
},
{
name: "max uint32 target IDs",
msg: &MsgBinTargeted{
TargetCount: 2,
TargetCharIDs: []uint32{0xFFFFFFFF, 0x12345678},
RawDataPayload: []byte{0x01},
},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
bf := byteframe.NewByteFrame()
err := tt.msg.Build(bf)
if (err != nil) != tt.wantErr {
t.Errorf("Build() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !tt.wantErr {
data := bf.Data()
if tt.validate != nil {
tt.validate(t, data)
}
}
})
}
}
func TestMsgBinTargeted_Parse(t *testing.T) {
tests := []struct {
name string
data []byte
want *MsgBinTargeted
wantErr bool
}{
{
name: "single target",
data: []byte{
0x00, 0x01, // TargetCount = 1
0x00, 0x00, 0x30, 0x39, // TargetCharID = 12345
0xAA, 0xBB, 0xCC, // RawDataPayload
},
want: &MsgBinTargeted{
TargetCount: 1,
TargetCharIDs: []uint32{12345},
RawDataPayload: []byte{0xAA, 0xBB, 0xCC},
},
wantErr: false,
},
{
name: "multiple targets",
data: []byte{
0x00, 0x03, // TargetCount = 3
0x00, 0x00, 0x00, 0x64, // Target 1 = 100
0x00, 0x00, 0x00, 0xC8, // Target 2 = 200
0x00, 0x00, 0x01, 0x2C, // Target 3 = 300
0x01, 0x02, // RawDataPayload
},
want: &MsgBinTargeted{
TargetCount: 3,
TargetCharIDs: []uint32{100, 200, 300},
RawDataPayload: []byte{0x01, 0x02},
},
wantErr: false,
},
{
name: "zero targets",
data: []byte{
0x00, 0x00, // TargetCount = 0
0xFF, 0xFF, // RawDataPayload
},
want: &MsgBinTargeted{
TargetCount: 0,
TargetCharIDs: []uint32{},
RawDataPayload: []byte{0xFF, 0xFF},
},
wantErr: false,
},
{
name: "no payload",
data: []byte{
0x00, 0x01, // TargetCount = 1
0x00, 0x00, 0x03, 0xE7, // Target = 999
},
want: &MsgBinTargeted{
TargetCount: 1,
TargetCharIDs: []uint32{999},
RawDataPayload: []byte{},
},
wantErr: false,
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
bf := byteframe.NewByteFrameFromBytes(tt.data)
msg := &MsgBinTargeted{}
err := msg.Parse(bf)
if (err != nil) != tt.wantErr {
t.Errorf("Parse() error = %v, wantErr %v", err, tt.wantErr)
return
}
if !tt.wantErr {
if msg.TargetCount != tt.want.TargetCount {
t.Errorf("TargetCount = %d, want %d", msg.TargetCount, tt.want.TargetCount)
}
if len(msg.TargetCharIDs) != len(tt.want.TargetCharIDs) {
t.Errorf("len(TargetCharIDs) = %d, want %d", len(msg.TargetCharIDs), len(tt.want.TargetCharIDs))
} else {
for i, id := range msg.TargetCharIDs {
if id != tt.want.TargetCharIDs[i] {
t.Errorf("TargetCharIDs[%d] = %d, want %d", i, id, tt.want.TargetCharIDs[i])
}
}
}
if !bytes.Equal(msg.RawDataPayload, tt.want.RawDataPayload) {
t.Errorf("RawDataPayload = %v, want %v", msg.RawDataPayload, tt.want.RawDataPayload)
}
}
})
}
}
func TestMsgBinTargeted_RoundTrip(t *testing.T) {
tests := []struct {
name string
msg *MsgBinTargeted
}{
{
name: "single target",
msg: &MsgBinTargeted{
TargetCount: 1,
TargetCharIDs: []uint32{12345},
RawDataPayload: []byte{0x01, 0x02, 0x03},
},
},
{
name: "multiple targets",
msg: &MsgBinTargeted{
TargetCount: 5,
TargetCharIDs: []uint32{100, 200, 300, 400, 500},
RawDataPayload: []byte{0xAA, 0xBB, 0xCC, 0xDD},
},
},
{
name: "zero targets",
msg: &MsgBinTargeted{
TargetCount: 0,
TargetCharIDs: []uint32{},
RawDataPayload: []byte{0xFF},
},
},
{
name: "empty payload",
msg: &MsgBinTargeted{
TargetCount: 2,
TargetCharIDs: []uint32{1000, 2000},
RawDataPayload: []byte{},
},
},
{
name: "large IDs and payload",
msg: &MsgBinTargeted{
TargetCount: 3,
TargetCharIDs: []uint32{0xFFFFFFFF, 0x12345678, 0xABCDEF00},
RawDataPayload: bytes.Repeat([]byte{0xDD}, 128),
},
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
// Build
bf := byteframe.NewByteFrame()
err := tt.msg.Build(bf)
if err != nil {
t.Fatalf("Build() error = %v", err)
}
// Parse
parsedMsg := &MsgBinTargeted{}
parsedBf := byteframe.NewByteFrameFromBytes(bf.Data())
err = parsedMsg.Parse(parsedBf)
if err != nil {
t.Fatalf("Parse() error = %v", err)
}
// Compare
if parsedMsg.TargetCount != tt.msg.TargetCount {
t.Errorf("TargetCount = %d, want %d", parsedMsg.TargetCount, tt.msg.TargetCount)
}
if len(parsedMsg.TargetCharIDs) != len(tt.msg.TargetCharIDs) {
t.Errorf("len(TargetCharIDs) = %d, want %d", len(parsedMsg.TargetCharIDs), len(tt.msg.TargetCharIDs))
} else {
for i, id := range parsedMsg.TargetCharIDs {
if id != tt.msg.TargetCharIDs[i] {
t.Errorf("TargetCharIDs[%d] = %d, want %d", i, id, tt.msg.TargetCharIDs[i])
}
}
}
if !bytes.Equal(parsedMsg.RawDataPayload, tt.msg.RawDataPayload) {
t.Errorf("RawDataPayload length mismatch: got %d, want %d", len(parsedMsg.RawDataPayload), len(tt.msg.RawDataPayload))
}
})
}
}
func TestMsgBinTargeted_TargetCountMismatch(t *testing.T) {
// Test that TargetCount and actual array length don't have to match
// The Build function uses the TargetCount field
msg := &MsgBinTargeted{
TargetCount: 2, // Says 2
TargetCharIDs: []uint32{100, 200, 300}, // But has 3
RawDataPayload: []byte{0x01},
}
bf := byteframe.NewByteFrame()
err := msg.Build(bf)
if err != nil {
t.Fatalf("Build() error = %v", err)
}
// Parse should read exactly 2 IDs as specified by TargetCount
parsedMsg := &MsgBinTargeted{}
parsedBf := byteframe.NewByteFrameFromBytes(bf.Data())
err = parsedMsg.Parse(parsedBf)
if err != nil {
t.Fatalf("Parse() error = %v", err)
}
if parsedMsg.TargetCount != 2 {
t.Errorf("TargetCount = %d, want 2", parsedMsg.TargetCount)
}
if len(parsedMsg.TargetCharIDs) != 2 {
t.Errorf("len(TargetCharIDs) = %d, want 2", len(parsedMsg.TargetCharIDs))
}
}
func TestMsgBinTargeted_BuildParseConsistency(t *testing.T) {
original := &MsgBinTargeted{
TargetCount: 3,
TargetCharIDs: []uint32{111, 222, 333},
RawDataPayload: []byte{0x11, 0x22, 0x33, 0x44},
}
// First build
bf1 := byteframe.NewByteFrame()
err := original.Build(bf1)
if err != nil {
t.Fatalf("First Build() error = %v", err)
}
// Parse
parsed := &MsgBinTargeted{}
parsedBf := byteframe.NewByteFrameFromBytes(bf1.Data())
err = parsed.Parse(parsedBf)
if err != nil {
t.Fatalf("Parse() error = %v", err)
}
// Second build
bf2 := byteframe.NewByteFrame()
err = parsed.Build(bf2)
if err != nil {
t.Fatalf("Second Build() error = %v", err)
}
// Compare the two builds
if !bytes.Equal(bf1.Data(), bf2.Data()) {
t.Errorf("Build-Parse-Build inconsistency:\nFirst: %v\nSecond: %v", bf1.Data(), bf2.Data())
}
}
func TestMsgBinTargeted_PayloadForwarding(t *testing.T) {
// Test that RawDataPayload is correctly preserved
// This is important as it forwards another binpacket
originalPayload := []byte{
0x10, 0x20, 0x30, 0x40, 0x50, 0x60, 0x70, 0x80,
0x90, 0xA0, 0xB0, 0xC0, 0xD0, 0xE0, 0xF0, 0xFF,
}
msg := &MsgBinTargeted{
TargetCount: 1,
TargetCharIDs: []uint32{999},
RawDataPayload: originalPayload,
}
bf := byteframe.NewByteFrame()
err := msg.Build(bf)
if err != nil {
t.Fatalf("Build() error = %v", err)
}
parsed := &MsgBinTargeted{}
parsedBf := byteframe.NewByteFrameFromBytes(bf.Data())
err = parsed.Parse(parsedBf)
if err != nil {
t.Fatalf("Parse() error = %v", err)
}
if !bytes.Equal(parsed.RawDataPayload, originalPayload) {
t.Errorf("Payload not preserved:\ngot: %v\nwant: %v", parsed.RawDataPayload, originalPayload)
}
}

31
network/clientctx/clientcontext_test.go Normal file
View File

@@ -0,0 +1,31 @@
package clientctx
import (
"testing"
)
// TestClientContext_Exists verifies that the ClientContext type exists
// and can be instantiated, even though it's currently unused.
func TestClientContext_Exists(t *testing.T) {
// This test documents that ClientContext is currently an empty struct
// and is marked as unused in the codebase.
var ctx ClientContext
// Verify it's a zero-size struct
_ = ctx
// Just verify we can create it
ctx2 := ClientContext{}
_ = ctx2
}
// TestClientContext_IsEmpty verifies that ClientContext has no fields
func TestClientContext_IsEmpty(t *testing.T) {
// The struct should be empty as marked by the comment "// Unused"
// This test documents the current state of the struct
ctx := ClientContext{}
_ = ctx
// If fields are added in the future, this test will need to be updated
// Currently it's just a placeholder/documentation test
}

482
network/crypt_conn_test.go Normal file
View File

@@ -0,0 +1,482 @@
package network
import (
"bytes"
_config "erupe-ce/config"
"erupe-ce/network/crypto"
"errors"
"io"
"net"
"testing"
"time"
)
// mockConn implements net.Conn for testing
type mockConn struct {
readData *bytes.Buffer
writeData *bytes.Buffer
closed bool
readErr error
writeErr error
}
func newMockConn(readData []byte) *mockConn {
return &mockConn{
readData: bytes.NewBuffer(readData),
writeData: bytes.NewBuffer(nil),
}
}
func (m *mockConn) Read(b []byte) (n int, err error) {
if m.readErr != nil {
return 0, m.readErr
}
return m.readData.Read(b)
}
func (m *mockConn) Write(b []byte) (n int, err error) {
if m.writeErr != nil {
return 0, m.writeErr
}
return m.writeData.Write(b)
}
func (m *mockConn) Close() error {
m.closed = true
return nil
}
func (m *mockConn) LocalAddr() net.Addr { return nil }
func (m *mockConn) RemoteAddr() net.Addr { return nil }
func (m *mockConn) SetDeadline(t time.Time) error { return nil }
func (m *mockConn) SetReadDeadline(t time.Time) error { return nil }
func (m *mockConn) SetWriteDeadline(t time.Time) error { return nil }
func TestNewCryptConn(t *testing.T) {
mockConn := newMockConn(nil)
cc := NewCryptConn(mockConn)
if cc == nil {
t.Fatal("NewCryptConn() returned nil")
}
if cc.conn != mockConn {
t.Error("conn not set correctly")
}
if cc.readKeyRot != 995117 {
t.Errorf("readKeyRot = %d, want 995117", cc.readKeyRot)
}
if cc.sendKeyRot != 995117 {
t.Errorf("sendKeyRot = %d, want 995117", cc.sendKeyRot)
}
if cc.sentPackets != 0 {
t.Errorf("sentPackets = %d, want 0", cc.sentPackets)
}
if cc.prevRecvPacketCombinedCheck != 0 {
t.Errorf("prevRecvPacketCombinedCheck = %d, want 0", cc.prevRecvPacketCombinedCheck)
}
if cc.prevSendPacketCombinedCheck != 0 {
t.Errorf("prevSendPacketCombinedCheck = %d, want 0", cc.prevSendPacketCombinedCheck)
}
}
func TestCryptConn_SendPacket(t *testing.T) {
// Save original config and restore after test
originalMode := _config.ErupeConfig.RealClientMode
defer func() {
_config.ErupeConfig.RealClientMode = originalMode
}()
tests := []struct {
name string
data []byte
}{
{
name: "small packet",
data: []byte{0x01, 0x02, 0x03, 0x04},
},
{
name: "empty packet",
data: []byte{},
},
{
name: "larger packet",
data: bytes.Repeat([]byte{0xAA}, 256),
},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
mockConn := newMockConn(nil)
cc := NewCryptConn(mockConn)
err := cc.SendPacket(tt.data)
if err != nil {
t.Fatalf("SendPacket() error = %v, want nil", err)
}
written := mockConn.writeData.Bytes()
if len(written) < CryptPacketHeaderLength {
t.Fatalf("written data length = %d, want at least %d", len(written), CryptPacketHeaderLength)
}
// Verify header was written
headerData := written[:CryptPacketHeaderLength]
header, err := NewCryptPacketHeader(headerData)
if err != nil {
t.Fatalf("Failed to parse header: %v", err)
}
// Verify packet counter incremented
if cc.sentPackets != 1 {
t.Errorf("sentPackets = %d, want 1", cc.sentPackets)
}
// Verify header fields
if header.KeyRotDelta != 3 {
t.Errorf("header.KeyRotDelta = %d, want 3", header.KeyRotDelta)
}
if header.PacketNum != 0 {
t.Errorf("header.PacketNum = %d, want 0", header.PacketNum)
}
// Verify encrypted data was written
encryptedData := written[CryptPacketHeaderLength:]
if len(encryptedData) != int(header.DataSize) {
t.Errorf("encrypted data length = %d, want %d", len(encryptedData), header.DataSize)
}
})
}
}
func TestCryptConn_SendPacket_MultiplePackets(t *testing.T) {
mockConn := newMockConn(nil)
cc := NewCryptConn(mockConn)
// Send first packet
err := cc.SendPacket([]byte{0x01, 0x02})
if err != nil {
t.Fatalf("SendPacket(1) error = %v", err)
}
if cc.sentPackets != 1 {
t.Errorf("After 1 packet: sentPackets = %d, want 1", cc.sentPackets)
}
// Send second packet
err = cc.SendPacket([]byte{0x03, 0x04})
if err != nil {
t.Fatalf("SendPacket(2) error = %v", err)
}
if cc.sentPackets != 2 {
t.Errorf("After 2 packets: sentPackets = %d, want 2", cc.sentPackets)
}
// Send third packet
err = cc.SendPacket([]byte{0x05, 0x06})
if err != nil {
t.Fatalf("SendPacket(3) error = %v", err)
}
if cc.sentPackets != 3 {
t.Errorf("After 3 packets: sentPackets = %d, want 3", cc.sentPackets)
}
}
func TestCryptConn_SendPacket_KeyRotation(t *testing.T) {
mockConn := newMockConn(nil)
cc := NewCryptConn(mockConn)
initialKey := cc.sendKeyRot
err := cc.SendPacket([]byte{0x01, 0x02, 0x03})
if err != nil {
t.Fatalf("SendPacket() error = %v", err)
}
// Key should have been rotated (keyRotDelta=3, so new key = 3 * (oldKey + 1))
expectedKey := 3 * (initialKey + 1)
if cc.sendKeyRot != expectedKey {
t.Errorf("sendKeyRot = %d, want %d", cc.sendKeyRot, expectedKey)
}
}
func TestCryptConn_SendPacket_WriteError(t *testing.T) {
mockConn := newMockConn(nil)
mockConn.writeErr = errors.New("write error")
cc := NewCryptConn(mockConn)
err := cc.SendPacket([]byte{0x01, 0x02, 0x03})
// Note: Current implementation doesn't return write error
// This test documents the behavior
if err != nil {
t.Logf("SendPacket() returned error: %v", err)
}
}
func TestCryptConn_ReadPacket_Success(t *testing.T) {
// Save original config and restore after test
originalMode := _config.ErupeConfig.RealClientMode
_config.ErupeConfig.RealClientMode = _config.Z1 // Use older mode for simpler test
defer func() {
_config.ErupeConfig.RealClientMode = originalMode
}()
testData := []byte{0x74, 0x65, 0x73, 0x74} // "test"
key := uint32(0)
// Encrypt the data
encryptedData, combinedCheck, check0, check1, check2 := crypto.Crypto(testData, key, true, nil)
// Build header
header := &CryptPacketHeader{
Pf0: 0x03,
KeyRotDelta: 0,
PacketNum: 0,
DataSize: uint16(len(encryptedData)),
PrevPacketCombinedCheck: 0,
Check0: check0,
Check1: check1,
Check2: check2,
}
headerBytes, _ := header.Encode()
// Combine header and encrypted data
packet := append(headerBytes, encryptedData...)
mockConn := newMockConn(packet)
cc := NewCryptConn(mockConn)
// Set the key to match what we used for encryption
cc.readKeyRot = key
result, err := cc.ReadPacket()
if err != nil {
t.Fatalf("ReadPacket() error = %v, want nil", err)
}
if !bytes.Equal(result, testData) {
t.Errorf("ReadPacket() = %v, want %v", result, testData)
}
if cc.prevRecvPacketCombinedCheck != combinedCheck {
t.Errorf("prevRecvPacketCombinedCheck = %d, want %d", cc.prevRecvPacketCombinedCheck, combinedCheck)
}
}
func TestCryptConn_ReadPacket_KeyRotation(t *testing.T) {
// Save original config and restore after test
originalMode := _config.ErupeConfig.RealClientMode
_config.ErupeConfig.RealClientMode = _config.Z1
defer func() {
_config.ErupeConfig.RealClientMode = originalMode
}()
testData := []byte{0x01, 0x02, 0x03, 0x04}
key := uint32(995117)
keyRotDelta := byte(3)
// Calculate expected rotated key
rotatedKey := uint32(keyRotDelta) * (key + 1)
// Encrypt with the rotated key
encryptedData, _, check0, check1, check2 := crypto.Crypto(testData, rotatedKey, true, nil)
// Build header with key rotation
header := &CryptPacketHeader{
Pf0: 0x03,
KeyRotDelta: keyRotDelta,
PacketNum: 0,
DataSize: uint16(len(encryptedData)),
PrevPacketCombinedCheck: 0,
Check0: check0,
Check1: check1,
Check2: check2,
}
headerBytes, _ := header.Encode()
packet := append(headerBytes, encryptedData...)
mockConn := newMockConn(packet)
cc := NewCryptConn(mockConn)
cc.readKeyRot = key
result, err := cc.ReadPacket()
if err != nil {
t.Fatalf("ReadPacket() error = %v, want nil", err)
}
if !bytes.Equal(result, testData) {
t.Errorf("ReadPacket() = %v, want %v", result, testData)
}
// Verify key was rotated
if cc.readKeyRot != rotatedKey {
t.Errorf("readKeyRot = %d, want %d", cc.readKeyRot, rotatedKey)
}
}
func TestCryptConn_ReadPacket_NoKeyRotation(t *testing.T) {
// Save original config and restore after test
originalMode := _config.ErupeConfig.RealClientMode
_config.ErupeConfig.RealClientMode = _config.Z1
defer func() {
_config.ErupeConfig.RealClientMode = originalMode
}()
testData := []byte{0x01, 0x02}
key := uint32(12345)
// Encrypt without key rotation
encryptedData, _, check0, check1, check2 := crypto.Crypto(testData, key, true, nil)
header := &CryptPacketHeader{
Pf0: 0x03,
KeyRotDelta: 0, // No rotation
PacketNum: 0,
DataSize: uint16(len(encryptedData)),
PrevPacketCombinedCheck: 0,
Check0: check0,
Check1: check1,
Check2: check2,
}
headerBytes, _ := header.Encode()
packet := append(headerBytes, encryptedData...)
mockConn := newMockConn(packet)
cc := NewCryptConn(mockConn)
cc.readKeyRot = key
originalKeyRot := cc.readKeyRot
result, err := cc.ReadPacket()
if err != nil {
t.Fatalf("ReadPacket() error = %v, want nil", err)
}
if !bytes.Equal(result, testData) {
t.Errorf("ReadPacket() = %v, want %v", result, testData)
}
// Verify key was NOT rotated
if cc.readKeyRot != originalKeyRot {
t.Errorf("readKeyRot = %d, want %d (should not have changed)", cc.readKeyRot, originalKeyRot)
}
}
func TestCryptConn_ReadPacket_HeaderReadError(t *testing.T) {
mockConn := newMockConn([]byte{0x01, 0x02}) // Only 2 bytes, header needs 14
cc := NewCryptConn(mockConn)
_, err := cc.ReadPacket()
if err == nil {
t.Fatal("ReadPacket() error = nil, want error")
}
if err != io.EOF && err != io.ErrUnexpectedEOF {
t.Errorf("ReadPacket() error = %v, want io.EOF or io.ErrUnexpectedEOF", err)
}
}
func TestCryptConn_ReadPacket_InvalidHeader(t *testing.T) {
// Create invalid header data (wrong endianness or malformed)
invalidHeader := []byte{0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF}
mockConn := newMockConn(invalidHeader)
cc := NewCryptConn(mockConn)
_, err := cc.ReadPacket()
if err == nil {
t.Fatal("ReadPacket() error = nil, want error")
}
}
func TestCryptConn_ReadPacket_BodyReadError(t *testing.T) {
// Save original config and restore after test
originalMode := _config.ErupeConfig.RealClientMode
_config.ErupeConfig.RealClientMode = _config.Z1
defer func() {
_config.ErupeConfig.RealClientMode = originalMode
}()
// Create valid header but incomplete body
header := &CryptPacketHeader{
Pf0: 0x03,
KeyRotDelta: 0,
PacketNum: 0,
DataSize: 100, // Claim 100 bytes
PrevPacketCombinedCheck: 0,
Check0: 0x1234,
Check1: 0x5678,
Check2: 0x9ABC,
}
headerBytes, _ := header.Encode()
incompleteBody := []byte{0x01, 0x02, 0x03} // Only 3 bytes, not 100
packet := append(headerBytes, incompleteBody...)
mockConn := newMockConn(packet)
cc := NewCryptConn(mockConn)
_, err := cc.ReadPacket()
if err == nil {
t.Fatal("ReadPacket() error = nil, want error")
}
}
func TestCryptConn_ReadPacket_ChecksumMismatch(t *testing.T) {
// Save original config and restore after test
originalMode := _config.ErupeConfig.RealClientMode
_config.ErupeConfig.RealClientMode = _config.Z1
defer func() {
_config.ErupeConfig.RealClientMode = originalMode
}()
testData := []byte{0x01, 0x02, 0x03, 0x04}
key := uint32(0)
encryptedData, _, _, _, _ := crypto.Crypto(testData, key, true, nil)
// Build header with WRONG checksums
header := &CryptPacketHeader{
Pf0: 0x03,
KeyRotDelta: 0,
PacketNum: 0,
DataSize: uint16(len(encryptedData)),
PrevPacketCombinedCheck: 0,
Check0: 0xFFFF, // Wrong checksum
Check1: 0xFFFF, // Wrong checksum
Check2: 0xFFFF, // Wrong checksum
}
headerBytes, _ := header.Encode()
packet := append(headerBytes, encryptedData...)
mockConn := newMockConn(packet)
cc := NewCryptConn(mockConn)
cc.readKeyRot = key
_, err := cc.ReadPacket()
if err == nil {
t.Fatal("ReadPacket() error = nil, want error for checksum mismatch")
}
expectedErr := "decrypted data checksum doesn't match header"
if err.Error() != expectedErr {
t.Errorf("ReadPacket() error = %q, want %q", err.Error(), expectedErr)
}
}
func TestCryptConn_Interface(t *testing.T) {
// Test that CryptConn implements Conn interface
var _ Conn = (*CryptConn)(nil)
}

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)
}
}