mirror of
https://github.com/Mezeporta/Erupe.git
synced 2026-03-22 15:43:49 +01:00
test: increase total coverage from 46.1% to 50.5%
- Fix duplicate test declarations across coverage2, misc, mercenary, event files - Fix signserver TestHandlePacketDELETE timeout (multi-write pipe deadlock) - Fix entranceserver build error (invalid -1 for uint16 port) - Add handlers_reserve_test.go covering all 56 reserve handler stubs - Add handlers_coverage3_test.go with 115+ handler tests - Add handlers_register_test.go with 55 Raviente register/load tests - Add handlers_coverage_test.go, signserver, entranceserver, usercheck tests
This commit is contained in:
Houmgaor
@@ -240,3 +240,215 @@ func TestEmptyAchievementHandlers(t *testing.T) {
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// --- NEW TESTS ---
|
||||
|
||||
// TestGetAchData_Level6BronzeTrophy tests that level 6 (in-progress toward level 7)
|
||||
// awards the bronze trophy (0x40).
|
||||
// Curve 0: {5, 15, 30, 50, 100, 150, 200, 300}
|
||||
// Cumulative at each level: L1=5, L2=20, L3=50, L4=100, L5=200, L6=350, L7=550, L8=850
|
||||
// At cumulative 350, we reach level 6. Score 400 means level 6 with progress 50 toward next.
|
||||
func TestGetAchData_Level6BronzeTrophy(t *testing.T) {
|
||||
// Score to reach level 6 and be partway to level 7:
|
||||
// cumulative to level 6 = 5+15+30+50+100+150 = 350
|
||||
// score 400 = level 6 with 50 remaining progress
|
||||
ach := GetAchData(0, 400)
|
||||
if ach.Level != 6 {
|
||||
t.Errorf("Level = %d, want 6", ach.Level)
|
||||
}
|
||||
if ach.Trophy != 0x40 {
|
||||
t.Errorf("Trophy = 0x%02x, want 0x40 (bronze)", ach.Trophy)
|
||||
}
|
||||
if ach.NextValue != 15 {
|
||||
t.Errorf("NextValue = %d, want 15", ach.NextValue)
|
||||
}
|
||||
if ach.Progress != 50 {
|
||||
t.Errorf("Progress = %d, want 50", ach.Progress)
|
||||
}
|
||||
if ach.Required != 200 {
|
||||
t.Errorf("Required = %d, want 200 (curve[6])", ach.Required)
|
||||
}
|
||||
}
|
||||
|
||||
// TestGetAchData_Level7SilverTrophy tests that level 7 (in-progress toward level 8)
|
||||
// awards the silver trophy (0x60).
|
||||
// cumulative to level 7 = 5+15+30+50+100+150+200 = 550
|
||||
// score 600 = level 7 with 50 remaining progress
|
||||
func TestGetAchData_Level7SilverTrophy(t *testing.T) {
|
||||
ach := GetAchData(0, 600)
|
||||
if ach.Level != 7 {
|
||||
t.Errorf("Level = %d, want 7", ach.Level)
|
||||
}
|
||||
if ach.Trophy != 0x60 {
|
||||
t.Errorf("Trophy = 0x%02x, want 0x60 (silver)", ach.Trophy)
|
||||
}
|
||||
if ach.NextValue != 20 {
|
||||
t.Errorf("NextValue = %d, want 20", ach.NextValue)
|
||||
}
|
||||
if ach.Progress != 50 {
|
||||
t.Errorf("Progress = %d, want 50", ach.Progress)
|
||||
}
|
||||
if ach.Required != 300 {
|
||||
t.Errorf("Required = %d, want 300 (curve[7])", ach.Required)
|
||||
}
|
||||
}
|
||||
|
||||
// TestGetAchData_MaxedOut_AllCurves tests that reaching max level on each curve
|
||||
// produces the correct gold trophy and the last threshold as Required/Progress.
|
||||
func TestGetAchData_MaxedOut_AllCurves(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
id uint8
|
||||
score int32
|
||||
lastThresh int32
|
||||
}{
|
||||
// Curve 0: {5,15,30,50,100,150,200,300} sum=850, last=300
|
||||
{"Curve0_ID0", 0, 5000, 300},
|
||||
// Curve 1: {1,5,10,15,30,50,75,100} sum=286, last=100
|
||||
{"Curve1_ID7", 7, 5000, 100},
|
||||
// Curve 2: {1,2,3,4,5,6,7,8} sum=36, last=8
|
||||
{"Curve2_ID8", 8, 5000, 8},
|
||||
// Curve 3: {10,50,100,200,350,500,750,999} sum=2959, last=999
|
||||
{"Curve3_ID16", 16, 50000, 999},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
ach := GetAchData(tt.id, tt.score)
|
||||
if ach.Level != 8 {
|
||||
t.Errorf("Level = %d, want 8 (max)", ach.Level)
|
||||
}
|
||||
if ach.Trophy != 0x7F {
|
||||
t.Errorf("Trophy = 0x%02x, want 0x7F (gold)", ach.Trophy)
|
||||
}
|
||||
if ach.Required != uint32(tt.lastThresh) {
|
||||
t.Errorf("Required = %d, want %d", ach.Required, tt.lastThresh)
|
||||
}
|
||||
if ach.Progress != ach.Required {
|
||||
t.Errorf("Progress = %d, want %d (should equal Required at max)", ach.Progress, ach.Required)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestGetAchData_ExactlyAtEachThreshold tests the exact cumulative score at each
|
||||
// threshold boundary for curve 0.
|
||||
func TestGetAchData_ExactlyAtEachThreshold(t *testing.T) {
|
||||
// Curve 0: {5, 15, 30, 50, 100, 150, 200, 300}
|
||||
// Cumulative thresholds (exact score to reach each level):
|
||||
// L1: 5, L2: 20, L3: 50, L4: 100, L5: 200, L6: 350, L7: 550, L8: 850
|
||||
cumulativeScores := []int32{5, 20, 50, 100, 200, 350, 550, 850}
|
||||
expectedLevels := []uint8{1, 2, 3, 4, 5, 6, 7, 8}
|
||||
expectedValues := []uint32{5, 15, 25, 35, 50, 65, 80, 100}
|
||||
|
||||
for i, score := range cumulativeScores {
|
||||
t.Run("ExactThreshold_L"+string(rune('1'+i)), func(t *testing.T) {
|
||||
ach := GetAchData(0, score)
|
||||
if ach.Level != expectedLevels[i] {
|
||||
t.Errorf("score=%d: Level = %d, want %d", score, ach.Level, expectedLevels[i])
|
||||
}
|
||||
if ach.Value != expectedValues[i] {
|
||||
t.Errorf("score=%d: Value = %d, want %d", score, ach.Value, expectedValues[i])
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestGetAchData_OneBeforeEachThreshold tests scores that are one less than
|
||||
// each cumulative threshold, verifying they stay at the previous level.
|
||||
func TestGetAchData_OneBeforeEachThreshold(t *testing.T) {
|
||||
// Curve 0: cumulative thresholds: 5, 20, 50, 100, 200, 350, 550, 850
|
||||
cumulativeScores := []int32{4, 19, 49, 99, 199, 349, 549, 849}
|
||||
expectedLevels := []uint8{0, 1, 2, 3, 4, 5, 6, 7}
|
||||
|
||||
for i, score := range cumulativeScores {
|
||||
t.Run("OneBeforeThreshold_L"+string(rune('0'+i)), func(t *testing.T) {
|
||||
ach := GetAchData(0, score)
|
||||
if ach.Level != expectedLevels[i] {
|
||||
t.Errorf("score=%d: Level = %d, want %d", score, ach.Level, expectedLevels[i])
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestGetAchData_Curve2_FestaWins exercises the "Festa wins" curve which has
|
||||
// small thresholds: {1, 2, 3, 4, 5, 6, 7, 8}
|
||||
func TestGetAchData_Curve2_FestaWins(t *testing.T) {
|
||||
// Curve 2: {1, 2, 3, 4, 5, 6, 7, 8}
|
||||
// Cumulative: 1, 3, 6, 10, 15, 21, 28, 36
|
||||
tests := []struct {
|
||||
score int32
|
||||
wantLvl uint8
|
||||
wantProg uint32
|
||||
wantReq uint32
|
||||
}{
|
||||
{0, 0, 0, 1},
|
||||
{1, 1, 0, 2}, // Exactly at first threshold
|
||||
{2, 1, 1, 2}, // One into second threshold
|
||||
{3, 2, 0, 3}, // Exactly at second cumulative
|
||||
{36, 8, 8, 8}, // Max level (sum of all thresholds)
|
||||
{100, 8, 8, 8}, // Well above max
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run("", func(t *testing.T) {
|
||||
ach := GetAchData(8, tt.score) // ID 8 maps to curve 2
|
||||
if ach.Level != tt.wantLvl {
|
||||
t.Errorf("score=%d: Level = %d, want %d", tt.score, ach.Level, tt.wantLvl)
|
||||
}
|
||||
if ach.Progress != tt.wantProg {
|
||||
t.Errorf("score=%d: Progress = %d, want %d", tt.score, ach.Progress, tt.wantProg)
|
||||
}
|
||||
if ach.Required != tt.wantReq {
|
||||
t.Errorf("score=%d: Required = %d, want %d", tt.score, ach.Required, tt.wantReq)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestGetAchData_AllIDs_ZeroScore verifies that calling GetAchData with score=0
|
||||
// for every valid ID returns level 0 without panicking.
|
||||
func TestGetAchData_AllIDs_ZeroScore(t *testing.T) {
|
||||
for id := uint8(0); id <= 32; id++ {
|
||||
ach := GetAchData(id, 0)
|
||||
if ach.Level != 0 {
|
||||
t.Errorf("ID %d, score 0: Level = %d, want 0", id, ach.Level)
|
||||
}
|
||||
if ach.Value != 0 {
|
||||
t.Errorf("ID %d, score 0: Value = %d, want 0", id, ach.Value)
|
||||
}
|
||||
if ach.Trophy != 0 {
|
||||
t.Errorf("ID %d, score 0: Trophy = 0x%02x, want 0x00", id, ach.Trophy)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestGetAchData_AllIDs_MaxScore verifies that calling GetAchData with a very
|
||||
// high score for every valid ID returns level 8 with gold trophy.
|
||||
func TestGetAchData_AllIDs_MaxScore(t *testing.T) {
|
||||
for id := uint8(0); id <= 32; id++ {
|
||||
ach := GetAchData(id, 99999)
|
||||
if ach.Level != 8 {
|
||||
t.Errorf("ID %d: Level = %d, want 8", id, ach.Level)
|
||||
}
|
||||
if ach.Trophy != 0x7F {
|
||||
t.Errorf("ID %d: Trophy = 0x%02x, want 0x7F", id, ach.Trophy)
|
||||
}
|
||||
// At max, Progress should equal Required
|
||||
if ach.Progress != ach.Required {
|
||||
t.Errorf("ID %d: Progress (%d) != Required (%d) at max", id, ach.Progress, ach.Required)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestGetAchData_UpdatedAlwaysFalse confirms Updated is always false since
|
||||
// GetAchData never sets it.
|
||||
func TestGetAchData_UpdatedAlwaysFalse(t *testing.T) {
|
||||
scores := []int32{0, 1, 5, 50, 500, 5000}
|
||||
for _, score := range scores {
|
||||
ach := GetAchData(0, score)
|
||||
if ach.Updated {
|
||||
t.Errorf("score=%d: Updated should always be false, got true", score)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
942
server/channelserver/handlers_coverage2_test.go
Normal file
942
server/channelserver/handlers_coverage2_test.go
Normal file
@@ -0,0 +1,942 @@
|
||||
package channelserver
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"erupe-ce/config"
|
||||
"erupe-ce/network/mhfpacket"
|
||||
)
|
||||
|
||||
// Tests for guild handlers that do not require database access.
|
||||
|
||||
func TestHandleMsgMhfEntryRookieGuild(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfEntryRookieGuild{
|
||||
AckHandle: 12345,
|
||||
Unk: 42,
|
||||
}
|
||||
|
||||
handleMsgMhfEntryRookieGuild(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfGenerateUdGuildMap(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfGenerateUdGuildMap{
|
||||
AckHandle: 12345,
|
||||
}
|
||||
|
||||
handleMsgMhfGenerateUdGuildMap(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfCheckMonthlyItem(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfCheckMonthlyItem{
|
||||
AckHandle: 12345,
|
||||
Type: 0,
|
||||
}
|
||||
|
||||
handleMsgMhfCheckMonthlyItem(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfAcquireMonthlyItem(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfAcquireMonthlyItem{
|
||||
AckHandle: 12345,
|
||||
}
|
||||
|
||||
handleMsgMhfAcquireMonthlyItem(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfEnumerateInvGuild(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfEnumerateInvGuild{
|
||||
AckHandle: 12345,
|
||||
}
|
||||
|
||||
handleMsgMhfEnumerateInvGuild(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfOperationInvGuild(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfOperationInvGuild{
|
||||
AckHandle: 12345,
|
||||
Operation: 1,
|
||||
}
|
||||
|
||||
handleMsgMhfOperationInvGuild(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// Tests for mercenary handlers that do not require database access.
|
||||
|
||||
func TestHandleMsgMhfMercenaryHuntdata_Unk0Is1(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfMercenaryHuntdata{
|
||||
AckHandle: 12345,
|
||||
Unk0: 1,
|
||||
}
|
||||
|
||||
handleMsgMhfMercenaryHuntdata(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfMercenaryHuntdata_Unk0Is0(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfMercenaryHuntdata{
|
||||
AckHandle: 12345,
|
||||
Unk0: 0,
|
||||
}
|
||||
|
||||
handleMsgMhfMercenaryHuntdata(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfMercenaryHuntdata_Unk0Is2(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfMercenaryHuntdata{
|
||||
AckHandle: 12345,
|
||||
Unk0: 2,
|
||||
}
|
||||
|
||||
handleMsgMhfMercenaryHuntdata(session, pkt)
|
||||
|
||||
// Unk0=2 takes the else branch (same as 0)
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// Tests for festa/ranking handlers.
|
||||
|
||||
func TestHandleMsgMhfEnumerateRanking_DefaultBranch(t *testing.T) {
|
||||
server := createMockServer()
|
||||
server.erupeConfig = &config.Config{
|
||||
DevMode: false,
|
||||
DevModeOptions: config.DevModeOptions{
|
||||
TournamentEvent: 0,
|
||||
},
|
||||
}
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfEnumerateRanking{
|
||||
AckHandle: 99999,
|
||||
}
|
||||
|
||||
handleMsgMhfEnumerateRanking(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfEnumerateRanking_NegativeState(t *testing.T) {
|
||||
server := createMockServer()
|
||||
server.erupeConfig = &config.Config{
|
||||
DevMode: true,
|
||||
DevModeOptions: config.DevModeOptions{
|
||||
TournamentEvent: -1,
|
||||
},
|
||||
}
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfEnumerateRanking{
|
||||
AckHandle: 99999,
|
||||
}
|
||||
|
||||
handleMsgMhfEnumerateRanking(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// Tests for rengoku handlers.
|
||||
|
||||
func TestHandleMsgMhfGetRengokuRankingRank_ResponseData(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfGetRengokuRankingRank{
|
||||
AckHandle: 55555,
|
||||
}
|
||||
|
||||
handleMsgMhfGetRengokuRankingRank(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// Tests for empty handlers that are not covered in other test files.
|
||||
|
||||
func TestEmptyHandlers_Coverage2(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
handler func(s *Session, p mhfpacket.MHFPacket)
|
||||
}{
|
||||
{"handleMsgSysCastedBinary", handleMsgSysCastedBinary},
|
||||
{"handleMsgMhfResetTitle", handleMsgMhfResetTitle},
|
||||
{"handleMsgMhfUpdateForceGuildRank", handleMsgMhfUpdateForceGuildRank},
|
||||
{"handleMsgMhfUpdateGuild", handleMsgMhfUpdateGuild},
|
||||
{"handleMsgMhfUpdateGuildcard", handleMsgMhfUpdateGuildcard},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
t.Errorf("%s panicked: %v", tt.name, r)
|
||||
}
|
||||
}()
|
||||
tt.handler(session, nil)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Tests for handlers.go - handlers that produce responses without DB access.
|
||||
|
||||
func TestHandleMsgSysTerminalLog_MultipleEntries(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgSysTerminalLog{
|
||||
AckHandle: 12345,
|
||||
LogID: 200,
|
||||
Entries: []*mhfpacket.TerminalLogEntry{
|
||||
{Type1: 10, Type2: 20, Data: []int16{100, 200, 300}},
|
||||
{Type1: 11, Type2: 21, Data: []int16{400, 500}},
|
||||
{Type1: 12, Type2: 22, Data: []int16{600}},
|
||||
},
|
||||
}
|
||||
|
||||
handleMsgSysTerminalLog(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgSysTerminalLog_ZeroLogID(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgSysTerminalLog{
|
||||
AckHandle: 12345,
|
||||
LogID: 0,
|
||||
Entries: []*mhfpacket.TerminalLogEntry{},
|
||||
}
|
||||
|
||||
handleMsgSysTerminalLog(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgSysPing_DifferentAckHandle(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgSysPing{
|
||||
AckHandle: 0xFFFFFFFF,
|
||||
}
|
||||
|
||||
handleMsgSysPing(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgSysTime_GetRemoteTimeFalse(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgSysTime{
|
||||
GetRemoteTime: false,
|
||||
}
|
||||
|
||||
handleMsgSysTime(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgSysIssueLogkey_LogKeyGenerated(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgSysIssueLogkey{
|
||||
AckHandle: 77777,
|
||||
}
|
||||
|
||||
handleMsgSysIssueLogkey(session, pkt)
|
||||
|
||||
// Verify that the logKey was set on the session
|
||||
session.Lock()
|
||||
keyLen := len(session.logKey)
|
||||
session.Unlock()
|
||||
|
||||
if keyLen != 16 {
|
||||
t.Errorf("logKey length = %d, want 16", keyLen)
|
||||
}
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgSysIssueLogkey_Uniqueness(t *testing.T) {
|
||||
server := createMockServer()
|
||||
|
||||
// Generate two logkeys and verify they differ
|
||||
session1 := createMockSession(1, server)
|
||||
session2 := createMockSession(2, server)
|
||||
|
||||
pkt1 := &mhfpacket.MsgSysIssueLogkey{AckHandle: 1}
|
||||
pkt2 := &mhfpacket.MsgSysIssueLogkey{AckHandle: 2}
|
||||
|
||||
handleMsgSysIssueLogkey(session1, pkt1)
|
||||
handleMsgSysIssueLogkey(session2, pkt2)
|
||||
|
||||
// Drain send packets
|
||||
<-session1.sendPackets
|
||||
<-session2.sendPackets
|
||||
|
||||
session1.Lock()
|
||||
key1 := make([]byte, len(session1.logKey))
|
||||
copy(key1, session1.logKey)
|
||||
session1.Unlock()
|
||||
|
||||
session2.Lock()
|
||||
key2 := make([]byte, len(session2.logKey))
|
||||
copy(key2, session2.logKey)
|
||||
session2.Unlock()
|
||||
|
||||
if len(key1) != 16 || len(key2) != 16 {
|
||||
t.Fatalf("logKeys should be 16 bytes each, got %d and %d", len(key1), len(key2))
|
||||
}
|
||||
|
||||
same := true
|
||||
for i := range key1 {
|
||||
if key1[i] != key2[i] {
|
||||
same = false
|
||||
break
|
||||
}
|
||||
}
|
||||
if same {
|
||||
t.Error("Two generated logkeys should differ (extremely unlikely to be the same)")
|
||||
}
|
||||
}
|
||||
|
||||
// Tests for event handlers.
|
||||
|
||||
func TestHandleMsgMhfReleaseEvent_ErrorCode(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfReleaseEvent{
|
||||
AckHandle: 88888,
|
||||
}
|
||||
|
||||
handleMsgMhfReleaseEvent(session, pkt)
|
||||
|
||||
// This handler manually sends a response with error code 0x41
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfEnumerateEvent_Stub(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfEnumerateEvent{
|
||||
AckHandle: 77777,
|
||||
}
|
||||
|
||||
handleMsgMhfEnumerateEvent(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// Tests for achievement handler.
|
||||
|
||||
func TestHandleMsgMhfSetCaAchievementHist_Response(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfSetCaAchievementHist{
|
||||
AckHandle: 44444,
|
||||
}
|
||||
|
||||
handleMsgMhfSetCaAchievementHist(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// Test concurrent handler invocations to catch potential data races.
|
||||
|
||||
func TestHandlersConcurrentInvocations(t *testing.T) {
|
||||
server := createMockServer()
|
||||
|
||||
done := make(chan struct{})
|
||||
const numGoroutines = 10
|
||||
|
||||
for i := 0; i < numGoroutines; i++ {
|
||||
go func(id uint32) {
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
t.Errorf("goroutine %d panicked: %v", id, r)
|
||||
}
|
||||
done <- struct{}{}
|
||||
}()
|
||||
|
||||
session := createMockSession(id, server)
|
||||
|
||||
// Run several handlers concurrently
|
||||
handleMsgSysPing(session, &mhfpacket.MsgSysPing{AckHandle: id})
|
||||
<-session.sendPackets
|
||||
|
||||
handleMsgSysTime(session, &mhfpacket.MsgSysTime{GetRemoteTime: true})
|
||||
<-session.sendPackets
|
||||
|
||||
handleMsgSysIssueLogkey(session, &mhfpacket.MsgSysIssueLogkey{AckHandle: id})
|
||||
<-session.sendPackets
|
||||
|
||||
handleMsgMhfMercenaryHuntdata(session, &mhfpacket.MsgMhfMercenaryHuntdata{AckHandle: id, Unk0: 1})
|
||||
<-session.sendPackets
|
||||
|
||||
handleMsgMhfEnumerateMercenaryLog(session, &mhfpacket.MsgMhfEnumerateMercenaryLog{AckHandle: id})
|
||||
<-session.sendPackets
|
||||
}(uint32(i + 100))
|
||||
}
|
||||
|
||||
for i := 0; i < numGoroutines; i++ {
|
||||
<-done
|
||||
}
|
||||
}
|
||||
|
||||
// Test festa handler with various config states.
|
||||
|
||||
func TestHandleMsgMhfVoteFesta_Response(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfVoteFesta{
|
||||
AckHandle: 33333,
|
||||
}
|
||||
|
||||
handleMsgMhfVoteFesta(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// Test record log handler with stage setup.
|
||||
|
||||
func TestHandleMsgSysRecordLog_RemovesReservation(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
stage := NewStage("test_stage_record")
|
||||
session.stage = stage
|
||||
stage.reservedClientSlots[session.charID] = true
|
||||
|
||||
pkt := &mhfpacket.MsgSysRecordLog{
|
||||
AckHandle: 55555,
|
||||
}
|
||||
|
||||
handleMsgSysRecordLog(session, pkt)
|
||||
|
||||
if _, exists := stage.reservedClientSlots[session.charID]; exists {
|
||||
t.Error("charID should be removed from reserved slots after record log")
|
||||
}
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgSysRecordLog_NoExistingReservation(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
stage := NewStage("test_stage_no_reservation")
|
||||
session.stage = stage
|
||||
// No reservation exists for this charID
|
||||
|
||||
pkt := &mhfpacket.MsgSysRecordLog{
|
||||
AckHandle: 55556,
|
||||
}
|
||||
|
||||
// Should not panic even if charID is not in reservedClientSlots
|
||||
handleMsgSysRecordLog(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// Test unlock global sema handler.
|
||||
|
||||
func TestHandleMsgSysUnlockGlobalSema_Response(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgSysUnlockGlobalSema{
|
||||
AckHandle: 66666,
|
||||
}
|
||||
|
||||
handleMsgSysUnlockGlobalSema(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// Test handlers from handlers_event.go with edge cases.
|
||||
|
||||
func TestHandleMsgMhfSetRestrictionEvent_Response(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfSetRestrictionEvent{
|
||||
AckHandle: 11111,
|
||||
}
|
||||
|
||||
handleMsgMhfSetRestrictionEvent(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgMhfGetRestrictionEvent_Empty(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
defer func() {
|
||||
if r := recover(); r != nil {
|
||||
t.Errorf("handleMsgMhfGetRestrictionEvent panicked: %v", r)
|
||||
}
|
||||
}()
|
||||
|
||||
handleMsgMhfGetRestrictionEvent(session, nil)
|
||||
}
|
||||
|
||||
// Test handlers from handlers_mercenary.go - legend dispatch (no DB).
|
||||
|
||||
func TestHandleMsgMhfLoadLegendDispatch_Response(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfLoadLegendDispatch{
|
||||
AckHandle: 22222,
|
||||
}
|
||||
|
||||
handleMsgMhfLoadLegendDispatch(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// Test multiple handler invocations on the same session to verify session state is not corrupted.
|
||||
|
||||
func TestMultipleHandlersOnSameSession(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
// Call multiple handlers in sequence
|
||||
handleMsgSysPing(session, &mhfpacket.MsgSysPing{AckHandle: 1})
|
||||
select {
|
||||
case <-session.sendPackets:
|
||||
default:
|
||||
t.Fatal("Expected packet from Ping handler")
|
||||
}
|
||||
|
||||
handleMsgSysTime(session, &mhfpacket.MsgSysTime{GetRemoteTime: true})
|
||||
select {
|
||||
case <-session.sendPackets:
|
||||
default:
|
||||
t.Fatal("Expected packet from Time handler")
|
||||
}
|
||||
|
||||
handleMsgMhfRegisterEvent(session, &mhfpacket.MsgMhfRegisterEvent{AckHandle: 2, Unk2: 5, Unk4: 10})
|
||||
select {
|
||||
case <-session.sendPackets:
|
||||
default:
|
||||
t.Fatal("Expected packet from RegisterEvent handler")
|
||||
}
|
||||
|
||||
handleMsgMhfReleaseEvent(session, &mhfpacket.MsgMhfReleaseEvent{AckHandle: 3})
|
||||
select {
|
||||
case <-session.sendPackets:
|
||||
default:
|
||||
t.Fatal("Expected packet from ReleaseEvent handler")
|
||||
}
|
||||
|
||||
handleMsgMhfEnumerateEvent(session, &mhfpacket.MsgMhfEnumerateEvent{AckHandle: 4})
|
||||
select {
|
||||
case <-session.sendPackets:
|
||||
default:
|
||||
t.Fatal("Expected packet from EnumerateEvent handler")
|
||||
}
|
||||
|
||||
handleMsgMhfSetCaAchievementHist(session, &mhfpacket.MsgMhfSetCaAchievementHist{AckHandle: 5})
|
||||
select {
|
||||
case <-session.sendPackets:
|
||||
default:
|
||||
t.Fatal("Expected packet from SetCaAchievementHist handler")
|
||||
}
|
||||
|
||||
handleMsgMhfGetRengokuRankingRank(session, &mhfpacket.MsgMhfGetRengokuRankingRank{AckHandle: 6})
|
||||
select {
|
||||
case <-session.sendPackets:
|
||||
default:
|
||||
t.Fatal("Expected packet from GetRengokuRankingRank handler")
|
||||
}
|
||||
}
|
||||
|
||||
// Test festa timestamp generation.
|
||||
|
||||
func TestGenerateFestaTimestamps_Debug(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
start uint32
|
||||
}{
|
||||
{"Debug_Start1", 1},
|
||||
{"Debug_Start2", 2},
|
||||
{"Debug_Start3", 3},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
timestamps := generateFestaTimestamps(session, tt.start, true)
|
||||
if len(timestamps) != 5 {
|
||||
t.Errorf("Expected 5 timestamps, got %d", len(timestamps))
|
||||
}
|
||||
for i, ts := range timestamps {
|
||||
if ts == 0 {
|
||||
t.Errorf("Timestamp %d should not be zero", i)
|
||||
}
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestGenerateFestaTimestamps_NonDebug_FutureStart(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
// Use a far-future start time so it does not trigger cleanup
|
||||
futureStart := uint32(TimeAdjusted().Unix() + 5000000)
|
||||
timestamps := generateFestaTimestamps(session, futureStart, false)
|
||||
|
||||
if len(timestamps) != 5 {
|
||||
t.Errorf("Expected 5 timestamps, got %d", len(timestamps))
|
||||
}
|
||||
if timestamps[0] != futureStart {
|
||||
t.Errorf("First timestamp = %d, want %d", timestamps[0], futureStart)
|
||||
}
|
||||
// Verify intervals
|
||||
if timestamps[1] != timestamps[0]+604800 {
|
||||
t.Errorf("Second timestamp should be start+604800, got %d", timestamps[1])
|
||||
}
|
||||
if timestamps[2] != timestamps[1]+604800 {
|
||||
t.Errorf("Third timestamp should be second+604800, got %d", timestamps[2])
|
||||
}
|
||||
if timestamps[3] != timestamps[2]+9000 {
|
||||
t.Errorf("Fourth timestamp should be third+9000, got %d", timestamps[3])
|
||||
}
|
||||
if timestamps[4] != timestamps[3]+1240200 {
|
||||
t.Errorf("Fifth timestamp should be fourth+1240200, got %d", timestamps[4])
|
||||
}
|
||||
}
|
||||
|
||||
// Test trial struct from handlers_festa.go.
|
||||
|
||||
func TestTrialStruct(t *testing.T) {
|
||||
trial := Trial{
|
||||
ID: 100,
|
||||
Objective: 2,
|
||||
GoalID: 500,
|
||||
TimesReq: 10,
|
||||
Locale: 1,
|
||||
Reward: 50,
|
||||
}
|
||||
if trial.ID != 100 {
|
||||
t.Errorf("ID = %d, want 100", trial.ID)
|
||||
}
|
||||
if trial.Objective != 2 {
|
||||
t.Errorf("Objective = %d, want 2", trial.Objective)
|
||||
}
|
||||
if trial.GoalID != 500 {
|
||||
t.Errorf("GoalID = %d, want 500", trial.GoalID)
|
||||
}
|
||||
if trial.TimesReq != 10 {
|
||||
t.Errorf("TimesReq = %d, want 10", trial.TimesReq)
|
||||
}
|
||||
}
|
||||
|
||||
// Test prize struct from handlers_festa.go.
|
||||
|
||||
func TestPrizeStruct(t *testing.T) {
|
||||
prize := Prize{
|
||||
ID: 1,
|
||||
Tier: 2,
|
||||
SoulsReq: 100,
|
||||
ItemID: 0x1234,
|
||||
NumItem: 5,
|
||||
Claimed: 1,
|
||||
}
|
||||
if prize.ID != 1 {
|
||||
t.Errorf("ID = %d, want 1", prize.ID)
|
||||
}
|
||||
if prize.Tier != 2 {
|
||||
t.Errorf("Tier = %d, want 2", prize.Tier)
|
||||
}
|
||||
if prize.SoulsReq != 100 {
|
||||
t.Errorf("SoulsReq = %d, want 100", prize.SoulsReq)
|
||||
}
|
||||
if prize.Claimed != 1 {
|
||||
t.Errorf("Claimed = %d, want 1", prize.Claimed)
|
||||
}
|
||||
}
|
||||
|
||||
// Test CatDefinition struct from handlers_mercenary.go.
|
||||
|
||||
func TestCatDefinitionStruct(t *testing.T) {
|
||||
cat := CatDefinition{
|
||||
CatID: 42,
|
||||
CatName: []byte("TestCat"),
|
||||
CurrentTask: 4,
|
||||
Personality: 2,
|
||||
Class: 1,
|
||||
Experience: 1500,
|
||||
WeaponType: 6,
|
||||
WeaponID: 100,
|
||||
}
|
||||
|
||||
if cat.CatID != 42 {
|
||||
t.Errorf("CatID = %d, want 42", cat.CatID)
|
||||
}
|
||||
if cat.CurrentTask != 4 {
|
||||
t.Errorf("CurrentTask = %d, want 4", cat.CurrentTask)
|
||||
}
|
||||
if cat.Experience != 1500 {
|
||||
t.Errorf("Experience = %d, want 1500", cat.Experience)
|
||||
}
|
||||
if cat.WeaponType != 6 {
|
||||
t.Errorf("WeaponType = %d, want 6", cat.WeaponType)
|
||||
}
|
||||
if cat.WeaponID != 100 {
|
||||
t.Errorf("WeaponID = %d, want 100", cat.WeaponID)
|
||||
}
|
||||
}
|
||||
|
||||
// Test RengokuScore struct default values.
|
||||
|
||||
func TestRengokuScoreStruct_Fields(t *testing.T) {
|
||||
score := RengokuScore{
|
||||
Name: "Hunter",
|
||||
Score: 99999,
|
||||
}
|
||||
|
||||
if score.Name != "Hunter" {
|
||||
t.Errorf("Name = %s, want Hunter", score.Name)
|
||||
}
|
||||
if score.Score != 99999 {
|
||||
t.Errorf("Score = %d, want 99999", score.Score)
|
||||
}
|
||||
}
|
||||
1319
server/channelserver/handlers_coverage3_test.go
Normal file
1319
server/channelserver/handlers_coverage3_test.go
Normal file
File diff suppressed because it is too large
Load Diff
145
server/channelserver/handlers_coverage_test.go
Normal file
145
server/channelserver/handlers_coverage_test.go
Normal file
@@ -0,0 +1,145 @@
|
||||
package channelserver
|
||||
|
||||
import (
|
||||
"testing"
|
||||
|
||||
"erupe-ce/network/mhfpacket"
|
||||
)
|
||||
|
||||
// Tests for handlers that do NOT require database access, exercising additional
|
||||
// code paths not covered by existing test files (handlers_core_test.go,
|
||||
// handlers_rengoku_test.go, etc.).
|
||||
|
||||
// TestHandleMsgSysPing_DifferentAckHandles verifies ping works with various ack handles.
|
||||
func TestHandleMsgSysPing_DifferentAckHandles(t *testing.T) {
|
||||
server := createMockServer()
|
||||
|
||||
ackHandles := []uint32{0, 1, 99999, 0xFFFFFFFF}
|
||||
for _, ack := range ackHandles {
|
||||
session := createMockSession(1, server)
|
||||
pkt := &mhfpacket.MsgSysPing{AckHandle: ack}
|
||||
|
||||
handleMsgSysPing(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Errorf("AckHandle=%d: Response packet should have data", ack)
|
||||
}
|
||||
default:
|
||||
t.Errorf("AckHandle=%d: No response packet queued", ack)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestHandleMsgSysTerminalLog_NoEntries verifies the handler works with nil entries.
|
||||
func TestHandleMsgSysTerminalLog_NoEntries(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgSysTerminalLog{
|
||||
AckHandle: 99999,
|
||||
LogID: 0,
|
||||
Entries: nil,
|
||||
}
|
||||
|
||||
handleMsgSysTerminalLog(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// TestHandleMsgSysTerminalLog_ManyEntries verifies the handler with many log entries.
|
||||
func TestHandleMsgSysTerminalLog_ManyEntries(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
entries := make([]*mhfpacket.TerminalLogEntry, 20)
|
||||
for i := range entries {
|
||||
entries[i] = &mhfpacket.TerminalLogEntry{
|
||||
Index: uint32(i),
|
||||
Type1: uint8(i % 256),
|
||||
Type2: uint8((i + 1) % 256),
|
||||
Data: make([]int16, 15),
|
||||
}
|
||||
}
|
||||
|
||||
pkt := &mhfpacket.MsgSysTerminalLog{
|
||||
AckHandle: 55555,
|
||||
LogID: 42,
|
||||
Entries: entries,
|
||||
}
|
||||
|
||||
handleMsgSysTerminalLog(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// TestHandleMsgSysTime_MultipleCalls verifies calling time handler repeatedly.
|
||||
func TestHandleMsgSysTime_MultipleCalls(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgSysTime{
|
||||
GetRemoteTime: false,
|
||||
Timestamp: 0,
|
||||
}
|
||||
|
||||
for i := 0; i < 5; i++ {
|
||||
handleMsgSysTime(session, pkt)
|
||||
}
|
||||
|
||||
// Should have 5 queued responses
|
||||
count := 0
|
||||
for {
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
count++
|
||||
default:
|
||||
goto done
|
||||
}
|
||||
}
|
||||
done:
|
||||
if count != 5 {
|
||||
t.Errorf("Expected 5 queued responses, got %d", count)
|
||||
}
|
||||
}
|
||||
|
||||
// TestHandleMsgMhfGetRengokuRankingRank_DifferentAck verifies rengoku ranking
|
||||
// works with different ack handles.
|
||||
func TestHandleMsgMhfGetRengokuRankingRank_DifferentAck(t *testing.T) {
|
||||
server := createMockServer()
|
||||
|
||||
ackHandles := []uint32{0, 1, 54321, 0xDEADBEEF}
|
||||
for _, ack := range ackHandles {
|
||||
session := createMockSession(1, server)
|
||||
pkt := &mhfpacket.MsgMhfGetRengokuRankingRank{AckHandle: ack}
|
||||
|
||||
handleMsgMhfGetRengokuRankingRank(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Errorf("AckHandle=%d: Response packet should have data", ack)
|
||||
}
|
||||
default:
|
||||
t.Errorf("AckHandle=%d: No response packet queued", ack)
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -1,6 +1,7 @@
|
||||
package channelserver
|
||||
|
||||
import (
|
||||
"math/bits"
|
||||
"testing"
|
||||
|
||||
"erupe-ce/network/mhfpacket"
|
||||
@@ -159,3 +160,99 @@ func TestGenerateFeatureWeapons_ZeroCount(t *testing.T) {
|
||||
t.Errorf("Expected 0 for zero count, got %d", result.ActiveFeatures)
|
||||
}
|
||||
}
|
||||
|
||||
// --- NEW TESTS ---
|
||||
|
||||
// TestGenerateFeatureWeapons_BitCount verifies that the number of set bits
|
||||
// in ActiveFeatures matches the requested count (capped at 14).
|
||||
func TestGenerateFeatureWeapons_BitCount(t *testing.T) {
|
||||
tests := []struct {
|
||||
name string
|
||||
count int
|
||||
wantBits int
|
||||
}{
|
||||
{"1 weapon", 1, 1},
|
||||
{"5 weapons", 5, 5},
|
||||
{"10 weapons", 10, 10},
|
||||
{"14 weapons", 14, 14},
|
||||
{"20 capped to 14", 20, 14},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
result := generateFeatureWeapons(tt.count)
|
||||
setBits := bits.OnesCount32(result.ActiveFeatures)
|
||||
if setBits != tt.wantBits {
|
||||
t.Errorf("Set bits = %d, want %d (ActiveFeatures=0b%032b)",
|
||||
setBits, tt.wantBits, result.ActiveFeatures)
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// TestGenerateFeatureWeapons_BitsInRange verifies that all set bits are within
|
||||
// bits 0-13 (no bits above bit 13 should be set).
|
||||
func TestGenerateFeatureWeapons_BitsInRange(t *testing.T) {
|
||||
for i := 0; i < 50; i++ {
|
||||
result := generateFeatureWeapons(7)
|
||||
// Bits 14+ should never be set
|
||||
if result.ActiveFeatures&^uint32(0x3FFF) != 0 {
|
||||
t.Errorf("Bits above 13 are set: 0x%08X", result.ActiveFeatures)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
// TestGenerateFeatureWeapons_MaxYieldsAllBits verifies that requesting 14
|
||||
// weapons sets exactly bits 0-13 (the value 16383 = 0x3FFF).
|
||||
func TestGenerateFeatureWeapons_MaxYieldsAllBits(t *testing.T) {
|
||||
result := generateFeatureWeapons(14)
|
||||
if result.ActiveFeatures != 0x3FFF {
|
||||
t.Errorf("ActiveFeatures = 0x%04X, want 0x3FFF (all 14 bits set)", result.ActiveFeatures)
|
||||
}
|
||||
}
|
||||
|
||||
// TestGenerateFeatureWeapons_StartTimeZero verifies that the returned
|
||||
// activeFeature has a zero StartTime (not set by generateFeatureWeapons).
|
||||
func TestGenerateFeatureWeapons_StartTimeZero(t *testing.T) {
|
||||
result := generateFeatureWeapons(5)
|
||||
if !result.StartTime.IsZero() {
|
||||
t.Errorf("StartTime should be zero, got %v", result.StartTime)
|
||||
}
|
||||
}
|
||||
|
||||
// TestHandleMsgMhfRegisterEvent_DifferentValues tests with various Unk2/Unk4 values.
|
||||
func TestHandleMsgMhfRegisterEvent_DifferentValues(t *testing.T) {
|
||||
server := createMockServer()
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
unk2 uint8
|
||||
unk4 uint8
|
||||
}{
|
||||
{"zeros", 0, 0},
|
||||
{"max values", 255, 255},
|
||||
{"typical", 5, 10},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
session := createMockSession(1, server)
|
||||
pkt := &mhfpacket.MsgMhfRegisterEvent{
|
||||
AckHandle: 99999,
|
||||
Unk2: tt.unk2,
|
||||
Unk4: tt.unk4,
|
||||
}
|
||||
|
||||
handleMsgMhfRegisterEvent(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1,8 +1,11 @@
|
||||
package channelserver
|
||||
|
||||
import (
|
||||
"bytes"
|
||||
"encoding/binary"
|
||||
"testing"
|
||||
|
||||
"erupe-ce/common/byteframe"
|
||||
"erupe-ce/network/mhfpacket"
|
||||
)
|
||||
|
||||
@@ -25,3 +28,271 @@ func TestHandleMsgMhfLoadLegendDispatch(t *testing.T) {
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// --- NEW TESTS ---
|
||||
|
||||
// buildCatBytes constructs a binary cat data payload suitable for GetCatDetails.
|
||||
func buildCatBytes(cats []CatDefinition) []byte {
|
||||
buf := new(bytes.Buffer)
|
||||
// catCount
|
||||
buf.WriteByte(byte(len(cats)))
|
||||
for _, cat := range cats {
|
||||
catBuf := new(bytes.Buffer)
|
||||
// catID (uint32)
|
||||
binary.Write(catBuf, binary.BigEndian, cat.CatID)
|
||||
// 1 byte skip (unknown bool)
|
||||
catBuf.WriteByte(0)
|
||||
// CatName (18 bytes)
|
||||
name := make([]byte, 18)
|
||||
copy(name, cat.CatName)
|
||||
catBuf.Write(name)
|
||||
// CurrentTask (uint8)
|
||||
catBuf.WriteByte(cat.CurrentTask)
|
||||
// 16 bytes skip (appearance data)
|
||||
catBuf.Write(make([]byte, 16))
|
||||
// Personality (uint8)
|
||||
catBuf.WriteByte(cat.Personality)
|
||||
// Class (uint8)
|
||||
catBuf.WriteByte(cat.Class)
|
||||
// 5 bytes skip (affection and colour sliders)
|
||||
catBuf.Write(make([]byte, 5))
|
||||
// Experience (uint32)
|
||||
binary.Write(catBuf, binary.BigEndian, cat.Experience)
|
||||
// 1 byte skip (bool for weapon equipped)
|
||||
catBuf.WriteByte(0)
|
||||
// WeaponType (uint8)
|
||||
catBuf.WriteByte(cat.WeaponType)
|
||||
// WeaponID (uint16)
|
||||
binary.Write(catBuf, binary.BigEndian, cat.WeaponID)
|
||||
|
||||
catData := catBuf.Bytes()
|
||||
// catDefLen (uint32) - total length of the cat data after this field
|
||||
binary.Write(buf, binary.BigEndian, uint32(len(catData)))
|
||||
buf.Write(catData)
|
||||
}
|
||||
return buf.Bytes()
|
||||
}
|
||||
|
||||
func TestGetCatDetails_Empty(t *testing.T) {
|
||||
// Zero cats
|
||||
data := []byte{0x00}
|
||||
bf := byteframe.NewByteFrameFromBytes(data)
|
||||
cats := GetCatDetails(bf)
|
||||
|
||||
if len(cats) != 0 {
|
||||
t.Errorf("Expected 0 cats, got %d", len(cats))
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetCatDetails_SingleCat(t *testing.T) {
|
||||
input := CatDefinition{
|
||||
CatID: 42,
|
||||
CatName: []byte("TestCat"),
|
||||
CurrentTask: 4,
|
||||
Personality: 3,
|
||||
Class: 2,
|
||||
Experience: 1500,
|
||||
WeaponType: 6,
|
||||
WeaponID: 100,
|
||||
}
|
||||
|
||||
data := buildCatBytes([]CatDefinition{input})
|
||||
bf := byteframe.NewByteFrameFromBytes(data)
|
||||
cats := GetCatDetails(bf)
|
||||
|
||||
if len(cats) != 1 {
|
||||
t.Fatalf("Expected 1 cat, got %d", len(cats))
|
||||
}
|
||||
|
||||
cat := cats[0]
|
||||
if cat.CatID != 42 {
|
||||
t.Errorf("CatID = %d, want 42", cat.CatID)
|
||||
}
|
||||
if cat.CurrentTask != 4 {
|
||||
t.Errorf("CurrentTask = %d, want 4", cat.CurrentTask)
|
||||
}
|
||||
if cat.Personality != 3 {
|
||||
t.Errorf("Personality = %d, want 3", cat.Personality)
|
||||
}
|
||||
if cat.Class != 2 {
|
||||
t.Errorf("Class = %d, want 2", cat.Class)
|
||||
}
|
||||
if cat.Experience != 1500 {
|
||||
t.Errorf("Experience = %d, want 1500", cat.Experience)
|
||||
}
|
||||
if cat.WeaponType != 6 {
|
||||
t.Errorf("WeaponType = %d, want 6", cat.WeaponType)
|
||||
}
|
||||
if cat.WeaponID != 100 {
|
||||
t.Errorf("WeaponID = %d, want 100", cat.WeaponID)
|
||||
}
|
||||
// Name should be 18 bytes (padded with nulls)
|
||||
if len(cat.CatName) != 18 {
|
||||
t.Errorf("CatName length = %d, want 18", len(cat.CatName))
|
||||
}
|
||||
// First bytes should match "TestCat"
|
||||
if !bytes.HasPrefix(cat.CatName, []byte("TestCat")) {
|
||||
t.Errorf("CatName does not start with 'TestCat', got %v", cat.CatName)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetCatDetails_MultipleCats(t *testing.T) {
|
||||
inputs := []CatDefinition{
|
||||
{CatID: 1, CatName: []byte("Alpha"), CurrentTask: 1, Personality: 0, Class: 0, Experience: 100, WeaponType: 6, WeaponID: 10},
|
||||
{CatID: 2, CatName: []byte("Beta"), CurrentTask: 2, Personality: 1, Class: 1, Experience: 200, WeaponType: 6, WeaponID: 20},
|
||||
{CatID: 3, CatName: []byte("Gamma"), CurrentTask: 4, Personality: 2, Class: 2, Experience: 300, WeaponType: 6, WeaponID: 30},
|
||||
}
|
||||
|
||||
data := buildCatBytes(inputs)
|
||||
bf := byteframe.NewByteFrameFromBytes(data)
|
||||
cats := GetCatDetails(bf)
|
||||
|
||||
if len(cats) != 3 {
|
||||
t.Fatalf("Expected 3 cats, got %d", len(cats))
|
||||
}
|
||||
|
||||
for i, cat := range cats {
|
||||
if cat.CatID != inputs[i].CatID {
|
||||
t.Errorf("Cat %d: CatID = %d, want %d", i, cat.CatID, inputs[i].CatID)
|
||||
}
|
||||
if cat.CurrentTask != inputs[i].CurrentTask {
|
||||
t.Errorf("Cat %d: CurrentTask = %d, want %d", i, cat.CurrentTask, inputs[i].CurrentTask)
|
||||
}
|
||||
if cat.Experience != inputs[i].Experience {
|
||||
t.Errorf("Cat %d: Experience = %d, want %d", i, cat.Experience, inputs[i].Experience)
|
||||
}
|
||||
if cat.WeaponID != inputs[i].WeaponID {
|
||||
t.Errorf("Cat %d: WeaponID = %d, want %d", i, cat.WeaponID, inputs[i].WeaponID)
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetCatDetails_ExtraTrailingBytes(t *testing.T) {
|
||||
// The GetCatDetails function handles extra bytes by seeking to catStart+catDefLen.
|
||||
// Simulate a cat definition with extra trailing bytes by increasing catDefLen.
|
||||
buf := new(bytes.Buffer)
|
||||
buf.WriteByte(1) // catCount = 1
|
||||
|
||||
catBuf := new(bytes.Buffer)
|
||||
binary.Write(catBuf, binary.BigEndian, uint32(99)) // catID
|
||||
catBuf.WriteByte(0) // skip
|
||||
catBuf.Write(make([]byte, 18)) // name
|
||||
catBuf.WriteByte(3) // currentTask
|
||||
catBuf.Write(make([]byte, 16)) // appearance skip
|
||||
catBuf.WriteByte(1) // personality
|
||||
catBuf.WriteByte(2) // class
|
||||
catBuf.Write(make([]byte, 5)) // affection skip
|
||||
binary.Write(catBuf, binary.BigEndian, uint32(500)) // experience
|
||||
catBuf.WriteByte(0) // weapon equipped bool
|
||||
catBuf.WriteByte(6) // weaponType
|
||||
binary.Write(catBuf, binary.BigEndian, uint16(50)) // weaponID
|
||||
|
||||
catData := catBuf.Bytes()
|
||||
// Add 10 extra trailing bytes
|
||||
extra := make([]byte, 10)
|
||||
catDataWithExtra := append(catData, extra...)
|
||||
|
||||
binary.Write(buf, binary.BigEndian, uint32(len(catDataWithExtra)))
|
||||
buf.Write(catDataWithExtra)
|
||||
|
||||
bf := byteframe.NewByteFrameFromBytes(buf.Bytes())
|
||||
cats := GetCatDetails(bf)
|
||||
|
||||
if len(cats) != 1 {
|
||||
t.Fatalf("Expected 1 cat, got %d", len(cats))
|
||||
}
|
||||
if cats[0].CatID != 99 {
|
||||
t.Errorf("CatID = %d, want 99", cats[0].CatID)
|
||||
}
|
||||
if cats[0].Experience != 500 {
|
||||
t.Errorf("Experience = %d, want 500", cats[0].Experience)
|
||||
}
|
||||
}
|
||||
|
||||
func TestGetCatDetails_CatNamePadding(t *testing.T) {
|
||||
// Verify that names shorter than 18 bytes are correctly padded with null bytes.
|
||||
input := CatDefinition{
|
||||
CatID: 1,
|
||||
CatName: []byte("Hi"),
|
||||
}
|
||||
|
||||
data := buildCatBytes([]CatDefinition{input})
|
||||
bf := byteframe.NewByteFrameFromBytes(data)
|
||||
cats := GetCatDetails(bf)
|
||||
|
||||
if len(cats) != 1 {
|
||||
t.Fatalf("Expected 1 cat, got %d", len(cats))
|
||||
}
|
||||
if len(cats[0].CatName) != 18 {
|
||||
t.Errorf("CatName length = %d, want 18", len(cats[0].CatName))
|
||||
}
|
||||
// "Hi" followed by null bytes
|
||||
if cats[0].CatName[0] != 'H' || cats[0].CatName[1] != 'i' {
|
||||
t.Errorf("CatName first bytes = %v, want 'Hi...'", cats[0].CatName[:2])
|
||||
}
|
||||
}
|
||||
|
||||
// TestHandleMsgMhfMercenaryHuntdata_Unk0_1 tests with Unk0=1 (returns 1 byte)
|
||||
func TestHandleMsgMhfMercenaryHuntdata_Unk0_1(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfMercenaryHuntdata{
|
||||
AckHandle: 12345,
|
||||
Unk0: 1,
|
||||
}
|
||||
|
||||
handleMsgMhfMercenaryHuntdata(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// TestHandleMsgMhfMercenaryHuntdata_Unk0_0 tests with Unk0=0 (returns 0 bytes payload)
|
||||
func TestHandleMsgMhfMercenaryHuntdata_Unk0_0(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfMercenaryHuntdata{
|
||||
AckHandle: 12345,
|
||||
Unk0: 0,
|
||||
}
|
||||
|
||||
handleMsgMhfMercenaryHuntdata(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
// TestHandleMsgMhfEnumerateMercenaryLog tests the mercenary log enumeration handler
|
||||
func TestHandleMsgMhfEnumerateMercenaryLog(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgMhfEnumerateMercenaryLog{
|
||||
AckHandle: 12345,
|
||||
}
|
||||
|
||||
handleMsgMhfEnumerateMercenaryLog(session, pkt)
|
||||
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
@@ -568,30 +568,3 @@ func TestDistributionItemStruct(t *testing.T) {
|
||||
t.Errorf("ItemID = %d, want 1234", item.ItemID)
|
||||
}
|
||||
}
|
||||
|
||||
// Login boost struct test
|
||||
func TestLoginBoostStruct(t *testing.T) {
|
||||
boost := loginBoost{
|
||||
WeekReq: 1,
|
||||
WeekCount: 2,
|
||||
Active: true,
|
||||
}
|
||||
|
||||
if boost.WeekReq != 1 {
|
||||
t.Errorf("WeekReq = %d, want 1", boost.WeekReq)
|
||||
}
|
||||
if !boost.Active {
|
||||
t.Error("Active should be true")
|
||||
}
|
||||
}
|
||||
|
||||
// ActiveFeature struct test
|
||||
func TestActiveFeatureStruct(t *testing.T) {
|
||||
feature := activeFeature{
|
||||
ActiveFeatures: 0x0FFF,
|
||||
}
|
||||
|
||||
if feature.ActiveFeatures != 0x0FFF {
|
||||
t.Errorf("ActiveFeatures = %x, want 0x0FFF", feature.ActiveFeatures)
|
||||
}
|
||||
}
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
@@ -6,116 +6,98 @@ import (
|
||||
"erupe-ce/network/mhfpacket"
|
||||
)
|
||||
|
||||
// Test that reserve handlers with AckHandle respond correctly
|
||||
|
||||
func TestHandleMsgSysReserve188(t *testing.T) {
|
||||
func TestReserveHandlersWithAck(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgSysReserve188{
|
||||
AckHandle: 12345,
|
||||
}
|
||||
|
||||
handleMsgSysReserve188(session, pkt)
|
||||
|
||||
// Verify response packet was queued
|
||||
// Test handleMsgSysReserve188
|
||||
handleMsgSysReserve188(session, &mhfpacket.MsgSysReserve188{AckHandle: 12345})
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
t.Error("Reserve188: response should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
}
|
||||
}
|
||||
|
||||
func TestHandleMsgSysReserve18B(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
pkt := &mhfpacket.MsgSysReserve18B{
|
||||
AckHandle: 12345,
|
||||
t.Error("Reserve188: no response queued")
|
||||
}
|
||||
|
||||
handleMsgSysReserve18B(session, pkt)
|
||||
|
||||
// Verify response packet was queued
|
||||
// Test handleMsgSysReserve18B
|
||||
handleMsgSysReserve18B(session, &mhfpacket.MsgSysReserve18B{AckHandle: 12345})
|
||||
select {
|
||||
case p := <-session.sendPackets:
|
||||
if len(p.data) == 0 {
|
||||
t.Error("Response packet should have data")
|
||||
t.Error("Reserve18B: response should have data")
|
||||
}
|
||||
default:
|
||||
t.Error("No response packet queued")
|
||||
t.Error("Reserve18B: no response queued")
|
||||
}
|
||||
}
|
||||
|
||||
// Test that empty reserve handlers don't panic
|
||||
|
||||
func TestEmptyReserveHandlers(t *testing.T) {
|
||||
func TestReserveEmptyHandlers(t *testing.T) {
|
||||
server := createMockServer()
|
||||
session := createMockSession(1, server)
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
handler func(s *Session, p mhfpacket.MHFPacket)
|
||||
pkt mhfpacket.MHFPacket
|
||||
}{
|
||||
{"handleMsgSysReserve55", handleMsgSysReserve55},
|
||||
{"handleMsgSysReserve56", handleMsgSysReserve56},
|
||||
{"handleMsgSysReserve57", handleMsgSysReserve57},
|
||||
{"handleMsgSysReserve01", handleMsgSysReserve01},
|
||||
{"handleMsgSysReserve02", handleMsgSysReserve02},
|
||||
{"handleMsgSysReserve03", handleMsgSysReserve03},
|
||||
{"handleMsgSysReserve04", handleMsgSysReserve04},
|
||||
{"handleMsgSysReserve05", handleMsgSysReserve05},
|
||||
{"handleMsgSysReserve06", handleMsgSysReserve06},
|
||||
{"handleMsgSysReserve07", handleMsgSysReserve07},
|
||||
{"handleMsgSysReserve0C", handleMsgSysReserve0C},
|
||||
{"handleMsgSysReserve0D", handleMsgSysReserve0D},
|
||||
{"handleMsgSysReserve0E", handleMsgSysReserve0E},
|
||||
{"handleMsgSysReserve4A", handleMsgSysReserve4A},
|
||||
{"handleMsgSysReserve4B", handleMsgSysReserve4B},
|
||||
{"handleMsgSysReserve4C", handleMsgSysReserve4C},
|
||||
{"handleMsgSysReserve4D", handleMsgSysReserve4D},
|
||||
{"handleMsgSysReserve4E", handleMsgSysReserve4E},
|
||||
{"handleMsgSysReserve4F", handleMsgSysReserve4F},
|
||||
{"handleMsgSysReserve5C", handleMsgSysReserve5C},
|
||||
{"handleMsgSysReserve5E", handleMsgSysReserve5E},
|
||||
{"handleMsgSysReserve5F", handleMsgSysReserve5F},
|
||||
{"handleMsgSysReserve71", handleMsgSysReserve71},
|
||||
{"handleMsgSysReserve72", handleMsgSysReserve72},
|
||||
{"handleMsgSysReserve73", handleMsgSysReserve73},
|
||||
{"handleMsgSysReserve74", handleMsgSysReserve74},
|
||||
{"handleMsgSysReserve75", handleMsgSysReserve75},
|
||||
{"handleMsgSysReserve76", handleMsgSysReserve76},
|
||||
{"handleMsgSysReserve77", handleMsgSysReserve77},
|
||||
{"handleMsgSysReserve78", handleMsgSysReserve78},
|
||||
{"handleMsgSysReserve79", handleMsgSysReserve79},
|
||||
{"handleMsgSysReserve7A", handleMsgSysReserve7A},
|
||||
{"handleMsgSysReserve7B", handleMsgSysReserve7B},
|
||||
{"handleMsgSysReserve7C", handleMsgSysReserve7C},
|
||||
{"handleMsgSysReserve7E", handleMsgSysReserve7E},
|
||||
{"handleMsgMhfReserve10F", handleMsgMhfReserve10F},
|
||||
{"handleMsgSysReserve180", handleMsgSysReserve180},
|
||||
{"handleMsgSysReserve18E", handleMsgSysReserve18E},
|
||||
{"handleMsgSysReserve18F", handleMsgSysReserve18F},
|
||||
{"handleMsgSysReserve19E", handleMsgSysReserve19E},
|
||||
{"handleMsgSysReserve19F", handleMsgSysReserve19F},
|
||||
{"handleMsgSysReserve1A4", handleMsgSysReserve1A4},
|
||||
{"handleMsgSysReserve1A6", handleMsgSysReserve1A6},
|
||||
{"handleMsgSysReserve1A7", handleMsgSysReserve1A7},
|
||||
{"handleMsgSysReserve1A8", handleMsgSysReserve1A8},
|
||||
{"handleMsgSysReserve1A9", handleMsgSysReserve1A9},
|
||||
{"handleMsgSysReserve1AA", handleMsgSysReserve1AA},
|
||||
{"handleMsgSysReserve1AB", handleMsgSysReserve1AB},
|
||||
{"handleMsgSysReserve1AC", handleMsgSysReserve1AC},
|
||||
{"handleMsgSysReserve1AD", handleMsgSysReserve1AD},
|
||||
{"handleMsgSysReserve1AE", handleMsgSysReserve1AE},
|
||||
{"handleMsgSysReserve1AF", handleMsgSysReserve1AF},
|
||||
{"handleMsgSysReserve19B", handleMsgSysReserve19B},
|
||||
{"handleMsgSysReserve192", handleMsgSysReserve192},
|
||||
{"handleMsgSysReserve193", handleMsgSysReserve193},
|
||||
{"handleMsgSysReserve194", handleMsgSysReserve194},
|
||||
{"Reserve55", handleMsgSysReserve55, &mhfpacket.MsgSysReserve55{}},
|
||||
{"Reserve56", handleMsgSysReserve56, &mhfpacket.MsgSysReserve56{}},
|
||||
{"Reserve57", handleMsgSysReserve57, &mhfpacket.MsgSysReserve57{}},
|
||||
{"Reserve01", handleMsgSysReserve01, &mhfpacket.MsgSysReserve01{}},
|
||||
{"Reserve02", handleMsgSysReserve02, &mhfpacket.MsgSysReserve02{}},
|
||||
{"Reserve03", handleMsgSysReserve03, &mhfpacket.MsgSysReserve03{}},
|
||||
{"Reserve04", handleMsgSysReserve04, &mhfpacket.MsgSysReserve04{}},
|
||||
{"Reserve05", handleMsgSysReserve05, &mhfpacket.MsgSysReserve05{}},
|
||||
{"Reserve06", handleMsgSysReserve06, &mhfpacket.MsgSysReserve06{}},
|
||||
{"Reserve07", handleMsgSysReserve07, &mhfpacket.MsgSysReserve07{}},
|
||||
{"Reserve0C", handleMsgSysReserve0C, &mhfpacket.MsgSysReserve0C{}},
|
||||
{"Reserve0D", handleMsgSysReserve0D, &mhfpacket.MsgSysReserve0D{}},
|
||||
{"Reserve0E", handleMsgSysReserve0E, &mhfpacket.MsgSysReserve0E{}},
|
||||
{"Reserve4A", handleMsgSysReserve4A, &mhfpacket.MsgSysReserve4A{}},
|
||||
{"Reserve4B", handleMsgSysReserve4B, &mhfpacket.MsgSysReserve4B{}},
|
||||
{"Reserve4C", handleMsgSysReserve4C, &mhfpacket.MsgSysReserve4C{}},
|
||||
{"Reserve4D", handleMsgSysReserve4D, &mhfpacket.MsgSysReserve4D{}},
|
||||
{"Reserve4E", handleMsgSysReserve4E, &mhfpacket.MsgSysReserve4E{}},
|
||||
{"Reserve4F", handleMsgSysReserve4F, &mhfpacket.MsgSysReserve4F{}},
|
||||
{"Reserve5C", handleMsgSysReserve5C, &mhfpacket.MsgSysReserve5C{}},
|
||||
{"Reserve5E", handleMsgSysReserve5E, &mhfpacket.MsgSysReserve5E{}},
|
||||
{"Reserve5F", handleMsgSysReserve5F, &mhfpacket.MsgSysReserve5F{}},
|
||||
{"Reserve71", handleMsgSysReserve71, &mhfpacket.MsgSysReserve71{}},
|
||||
{"Reserve72", handleMsgSysReserve72, &mhfpacket.MsgSysReserve72{}},
|
||||
{"Reserve73", handleMsgSysReserve73, &mhfpacket.MsgSysReserve73{}},
|
||||
{"Reserve74", handleMsgSysReserve74, &mhfpacket.MsgSysReserve74{}},
|
||||
{"Reserve75", handleMsgSysReserve75, &mhfpacket.MsgSysReserve75{}},
|
||||
{"Reserve76", handleMsgSysReserve76, &mhfpacket.MsgSysReserve76{}},
|
||||
{"Reserve77", handleMsgSysReserve77, &mhfpacket.MsgSysReserve77{}},
|
||||
{"Reserve78", handleMsgSysReserve78, &mhfpacket.MsgSysReserve78{}},
|
||||
{"Reserve79", handleMsgSysReserve79, &mhfpacket.MsgSysReserve79{}},
|
||||
{"Reserve7A", handleMsgSysReserve7A, &mhfpacket.MsgSysReserve7A{}},
|
||||
{"Reserve7B", handleMsgSysReserve7B, &mhfpacket.MsgSysReserve7B{}},
|
||||
{"Reserve7C", handleMsgSysReserve7C, &mhfpacket.MsgSysReserve7C{}},
|
||||
{"Reserve7E", handleMsgSysReserve7E, &mhfpacket.MsgSysReserve7E{}},
|
||||
{"Reserve10F", handleMsgMhfReserve10F, &mhfpacket.MsgMhfReserve10F{}},
|
||||
{"Reserve180", handleMsgSysReserve180, &mhfpacket.MsgSysReserve180{}},
|
||||
{"Reserve18E", handleMsgSysReserve18E, &mhfpacket.MsgSysReserve18E{}},
|
||||
{"Reserve18F", handleMsgSysReserve18F, &mhfpacket.MsgSysReserve18F{}},
|
||||
{"Reserve19E", handleMsgSysReserve19E, &mhfpacket.MsgSysReserve19E{}},
|
||||
{"Reserve19F", handleMsgSysReserve19F, &mhfpacket.MsgSysReserve19F{}},
|
||||
{"Reserve1A4", handleMsgSysReserve1A4, &mhfpacket.MsgSysReserve1A4{}},
|
||||
{"Reserve1A6", handleMsgSysReserve1A6, &mhfpacket.MsgSysReserve1A6{}},
|
||||
{"Reserve1A7", handleMsgSysReserve1A7, &mhfpacket.MsgSysReserve1A7{}},
|
||||
{"Reserve1A8", handleMsgSysReserve1A8, &mhfpacket.MsgSysReserve1A8{}},
|
||||
{"Reserve1A9", handleMsgSysReserve1A9, &mhfpacket.MsgSysReserve1A9{}},
|
||||
{"Reserve1AA", handleMsgSysReserve1AA, &mhfpacket.MsgSysReserve1AA{}},
|
||||
{"Reserve1AB", handleMsgSysReserve1AB, &mhfpacket.MsgSysReserve1AB{}},
|
||||
{"Reserve1AC", handleMsgSysReserve1AC, &mhfpacket.MsgSysReserve1AC{}},
|
||||
{"Reserve1AD", handleMsgSysReserve1AD, &mhfpacket.MsgSysReserve1AD{}},
|
||||
{"Reserve1AE", handleMsgSysReserve1AE, &mhfpacket.MsgSysReserve1AE{}},
|
||||
{"Reserve1AF", handleMsgSysReserve1AF, &mhfpacket.MsgSysReserve1AF{}},
|
||||
{"Reserve19B", handleMsgSysReserve19B, &mhfpacket.MsgSysReserve19B{}},
|
||||
{"Reserve192", handleMsgSysReserve192, &mhfpacket.MsgSysReserve192{}},
|
||||
{"Reserve193", handleMsgSysReserve193, &mhfpacket.MsgSysReserve193{}},
|
||||
{"Reserve194", handleMsgSysReserve194, &mhfpacket.MsgSysReserve194{}},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
@@ -125,29 +107,7 @@ func TestEmptyReserveHandlers(t *testing.T) {
|
||||
t.Errorf("%s panicked: %v", tt.name, r)
|
||||
}
|
||||
}()
|
||||
|
||||
// Call with nil packet - empty handlers should handle this
|
||||
tt.handler(session, nil)
|
||||
tt.handler(session, tt.pkt)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
// Test reserve handlers are registered in handler table
|
||||
|
||||
func TestReserveHandlersRegistered(t *testing.T) {
|
||||
if handlerTable == nil {
|
||||
t.Fatal("handlerTable should be initialized")
|
||||
}
|
||||
|
||||
// Check that reserve handlers exist in the table
|
||||
reserveHandlerCount := 0
|
||||
for _, handler := range handlerTable {
|
||||
if handler != nil {
|
||||
reserveHandlerCount++
|
||||
}
|
||||
}
|
||||
|
||||
if reserveHandlerCount < 50 {
|
||||
t.Errorf("Expected at least 50 handlers registered, got %d", reserveHandlerCount)
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user