Files

203 lines
7.1 KiB
C++

#include "network/network.h"
#include <iostream>
#include <cassert>
#include <cstring>
using namespace metin2::network;
void TestPhaseStateMachine() {
std::cout << "[Test] Phase State Machine...\n";
PhaseStateMachine fsm;
assert(fsm.GetCurrentPhase() == ConnectionPhase::Disconnected);
assert(!fsm.IsConnected());
// Invalid transition
assert(!fsm.CanTransitionTo(ConnectionPhase::InGame));
// Valid flow: Disconnected -> Handshake -> Auth -> CharacterSelect -> GameLoading -> InGame
assert(fsm.TransitionTo(ConnectionPhase::Handshake));
assert(fsm.GetCurrentPhase() == ConnectionPhase::Handshake);
assert(fsm.IsConnected());
assert(fsm.TransitionTo(ConnectionPhase::Auth));
assert(fsm.TransitionTo(ConnectionPhase::CharacterSelect));
assert(fsm.TransitionTo(ConnectionPhase::GameLoading));
assert(fsm.TransitionTo(ConnectionPhase::InGame));
assert(fsm.IsInGame());
// Disconnect from anywhere
assert(fsm.TransitionTo(ConnectionPhase::Disconnected));
assert(!fsm.IsConnected());
std::cout << " -> Phase transitions passed!\n";
}
void TestCipher() {
std::cout << "[Test] TEA & Rolling XOR Cipher...\n";
TeaKey key = { 0x12345678, 0x9ABCDEF0, 0x0FEDCBA9, 0x87654321 };
TeaCipher tea(key);
std::string text = "Metin2 cross-platform network packet payload encryption!";
std::vector<uint8_t> plain(text.begin(), text.end());
auto encrypted = tea.Encrypt(plain);
assert(encrypted.size() >= plain.size());
assert(encrypted.size() % 8 == 0);
auto decrypted = tea.Decrypt(encrypted);
assert(std::memcmp(plain.data(), decrypted.data(), plain.size()) == 0);
// Rolling XOR
RollingXorCipher xor_cipher1(0xA5A55A5A);
RollingXorCipher xor_cipher2(0xA5A55A5A);
std::vector<uint8_t> xor_buf(plain.begin(), plain.end());
xor_cipher1.Process(xor_buf.data(), xor_buf.size());
assert(std::memcmp(plain.data(), xor_buf.data(), plain.size()) != 0);
xor_cipher2.Process(xor_buf.data(), xor_buf.size());
assert(std::memcmp(plain.data(), xor_buf.data(), plain.size()) == 0);
std::cout << " -> Cipher encryption and decryption passed!\n";
}
void TestPacketSegmentationAndReassembly() {
std::cout << "[Test] Packet Buffer Fragmentation & Reassembly...\n";
PacketRegistry registry;
PacketBuffer buffer;
// 1. Pack multiple packets into one stream (Sticky packets / 粘包)
// Packet A: HEADER_GC_PING (header=253, 4 bytes payload)
// Packet B: HEADER_CG_CHARACTER_SELECT (header=6, 1 byte payload)
uint32_t ping_id = 9999;
uint8_t char_slot = 2;
std::vector<uint8_t> sticky_stream;
sticky_stream.push_back(HEADER_GC_PING);
const uint8_t* p_ping = reinterpret_cast<const uint8_t*>(&ping_id);
sticky_stream.insert(sticky_stream.end(), p_ping, p_ping + 4);
sticky_stream.push_back(HEADER_CG_CHARACTER_SELECT);
sticky_stream.push_back(char_slot);
buffer.Append(sticky_stream);
auto packets = buffer.ExtractPackets(registry);
assert(packets.size() == 2);
assert(packets[0].header == HEADER_GC_PING);
assert(packets[0].payload.size() == 4);
assert(*reinterpret_cast<const uint32_t*>(packets[0].payload.data()) == 9999);
assert(packets[1].header == HEADER_CG_CHARACTER_SELECT);
assert(packets[1].payload[0] == 2);
// 2. Partial packets (半包)
// Send 1st half of a packet
std::vector<uint8_t> half1;
half1.push_back(HEADER_GC_PING);
half1.push_back(0x11);
half1.push_back(0x22);
buffer.Append(half1);
auto partial = buffer.ExtractPackets(registry);
assert(partial.empty()); // Not complete yet
// Send 2nd half
std::vector<uint8_t> half2;
half2.push_back(0x33);
half2.push_back(0x44);
buffer.Append(half2);
auto completed = buffer.ExtractPackets(registry);
assert(completed.size() == 1);
assert(completed[0].header == HEADER_GC_PING);
assert(completed[0].payload[0] == 0x11 && completed[0].payload[3] == 0x44);
std::cout << " -> Packet segmentation and reassembly passed!\n";
}
void TestNetworkClientEndToEnd() {
std::cout << "[Test] NetworkClient Full Protocol Pipeline...\n";
NetworkClient client;
bool handshake_called = false;
bool auth_called = false;
std::string received_chat;
client.SetOnHandshake([&](uint32_t s_time) {
handshake_called = true;
assert(s_time == 12345678);
});
client.SetOnAuthResult([&](bool success, uint32_t err, const std::string& msg) {
auth_called = true;
assert(success);
});
client.SetOnChat([&](uint32_t sender, uint8_t type, const std::string& msg) {
received_chat = msg;
});
// Client connects -> Handshake phase
client.SetPhase(ConnectionPhase::Handshake);
assert(client.GetPhase() == ConnectionPhase::Handshake);
// Server sends GC_HANDSHAKE (header 255, 8 bytes: time=12345678, delta=0)
std::vector<uint8_t> server_handshake;
server_handshake.push_back(HEADER_GC_HANDSHAKE);
uint32_t s_time = 12345678;
uint32_t delta = 0;
const uint8_t* p_st = reinterpret_cast<const uint8_t*>(&s_time);
const uint8_t* p_dt = reinterpret_cast<const uint8_t*>(&delta);
server_handshake.insert(server_handshake.end(), p_st, p_st + 4);
server_handshake.insert(server_handshake.end(), p_dt, p_dt + 4);
client.PushReceivedData(server_handshake.data(), server_handshake.size());
assert(handshake_called);
// Client responds with Handshake Ack
client.SendHandshakeAck(87654321);
assert(client.HasPendingSendData());
auto out_data = client.PopSendData();
assert(!out_data.empty());
assert(out_data[0] == HEADER_CG_HANDSHAKE);
// Move to Auth phase & authenticate
client.SetPhase(ConnectionPhase::Auth);
client.SendLogin("player_tester", "secret_pass");
auto login_send = client.PopSendData();
assert(login_send[0] == HEADER_CG_LOGIN);
// Server sends Auth success (HEADER_GC_AUTH_SUCCESS: header 101, account_id 42)
std::vector<uint8_t> auth_resp;
auth_resp.push_back(HEADER_GC_AUTH_SUCCESS);
uint32_t account_id = 42;
const uint8_t* p_acc = reinterpret_cast<const uint8_t*>(&account_id);
auth_resp.insert(auth_resp.end(), p_acc, p_acc + 4);
client.PushReceivedData(auth_resp.data(), auth_resp.size());
assert(auth_called);
assert(client.GetPhase() == ConnectionPhase::CharacterSelect);
// Server sends Chat dynamic packet
std::string test_msg = "Welcome to Metin2 World!";
std::vector<uint8_t> chat_pkt;
chat_pkt.push_back(HEADER_GC_CHAT);
uint16_t chat_len = static_cast<uint16_t>(1 + test_msg.size());
chat_pkt.push_back(chat_len & 0xFF);
chat_pkt.push_back((chat_len >> 8) & 0xFF);
chat_pkt.push_back(1); // chat type
chat_pkt.insert(chat_pkt.end(), test_msg.begin(), test_msg.end());
client.PushReceivedData(chat_pkt.data(), chat_pkt.size());
assert(received_chat == test_msg);
std::cout << " -> NetworkClient pipeline passed!\n";
}
int main() {
std::cout << "=== Running Metin2 Network SDK Tests ===\n";
TestPhaseStateMachine();
TestCipher();
TestPacketSegmentationAndReassembly();
TestNetworkClientEndToEnd();
std::cout << "All Network SDK Tests PASSED!\n";
return 0;
}