#include "network/network.h" #include #include #include 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 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 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 sticky_stream; sticky_stream.push_back(HEADER_GC_PING); const uint8_t* p_ping = reinterpret_cast(&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(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 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 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 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(&s_time); const uint8_t* p_dt = reinterpret_cast(&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 auth_resp; auth_resp.push_back(HEADER_GC_AUTH_SUCCESS); uint32_t account_id = 42; const uint8_t* p_acc = reinterpret_cast(&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 chat_pkt; chat_pkt.push_back(HEADER_GC_CHAT); uint16_t chat_len = static_cast(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; }