Files
metin2-server/tests/features/test_gold64.py
T

261 lines
13 KiB
Python

#!/usr/bin/env python3
"""
Unit test suite for Metin2 Stage 7: 64-bit Gold System (GOLD_MAX_64 = 2,000,000,000,000,000LL).
Validates:
1. Full 64-bit integer coverage across tables, character, safebox, exchange, guild, db.
2. Overflow prevention and underflow guards across all economic systems.
3. 20-billion boundary transition, 50-billion exchange, and 100-billion cold restart persistence.
4. Database migration and rollback SQL safety.
5. Client-side Python long integer bridging.
"""
import unittest
import os
import re
import subprocess
import tempfile
SERVER_ROOT = os.path.abspath(os.path.join(os.path.dirname(__file__), "..", ".."))
CLIENT_ROOT = os.path.abspath(os.path.join(SERVER_ROOT, "..", "metin2-client"))
def read_server_file(rel_path):
with open(os.path.join(SERVER_ROOT, rel_path), "r", encoding="latin1") as f:
return f.read()
def read_client_file(rel_path):
with open(os.path.join(CLIENT_ROOT, rel_path), "r", encoding="latin1") as f:
return f.read()
class TestGold64System(unittest.TestCase):
def test_constants_and_table_declarations(self):
length_h = read_server_file("src/server/common/length.h")
self.assertIn("GOLD_MAX = 2000000000,", length_h)
self.assertIn("GOLD_MAX_64 = 2000000000000000LL,", length_h)
tables_h = read_server_file("src/server/common/tables.h")
self.assertTrue(re.search(r'int64_t\s+gold;', tables_h))
self.assertTrue(re.search(r'int64_t\s+dwGold;', tables_h))
self.assertTrue(re.search(r'int64_t\s+iGold;', tables_h))
self.assertTrue(re.search(r'int64_t\s+iTotalGold;', tables_h))
self.assertTrue(re.search(r'int64_t\s+iChangeGold;', tables_h))
utils_h = read_server_file("src/server/common/utils.h")
self.assertIn("inline bool str_to_number (long long& out, const char *in)", utils_h)
self.assertIn("inline bool str_to_number (unsigned long long& out, const char *in)", utils_h)
def test_character_and_economy_interfaces(self):
char_h = read_server_file("src/server/game/src/char.h")
self.assertTrue(re.search(r'void\s+PointChange\s*\(\s*BYTE\s+type,\s*int64_t\s+amount,', char_h))
self.assertTrue(re.search(r'int64_t\s+GetGold\s*\(\)\s*const\s*\{\s*return\s+m_points\.gold;\s*\}', char_h))
self.assertTrue(re.search(r'void\s+SetGold\s*\(\s*int64_t\s+gold\s*\)\s*\{\s*m_points\.gold\s*=\s*gold;\s*\}', char_h))
self.assertTrue(re.search(r'bool\s+DropGold\s*\(\s*int64_t\s+gold\s*\);', char_h))
self.assertTrue(re.search(r'int64_t\s+GetAllowedGold\s*\(\)\s*const;', char_h))
self.assertTrue(re.search(r'bool\s+GiveGold\s*\(\s*int64_t\s+iAmount\s*\);', char_h))
self.assertTrue(re.search(r'void\s+LoadSafebox\s*\(\s*int\s+iSize,\s*int64_t\s+dwGold,', char_h))
safebox_h = read_server_file("src/server/game/src/safebox.h")
self.assertTrue(re.search(r'CSafebox\s*\(\s*LPCHARACTER\s+pkChrOwner,\s*int\s+iSize,\s*int64_t\s+dwGold\s*\);', safebox_h))
self.assertTrue(re.search(r'int64_t\s+GetGold\s*\(\)\s*const\s*\{\s*return\s+m_lGold;\s*\}', safebox_h))
self.assertTrue(re.search(r'int64_t\s+m_lGold;', safebox_h))
exchange_h = read_server_file("src/server/game/src/exchange.h")
self.assertTrue(re.search(r'bool\s+AddGold\s*\(\s*int64_t\s+lGold\s*\);', exchange_h))
self.assertTrue(re.search(r'int64_t\s+m_lGold;', exchange_h))
guild_h = read_server_file("src/server/game/src/guild.h")
self.assertTrue(re.search(r'int64_t\s+gold;\s*\}\s*TGuildData;', guild_h))
self.assertTrue(re.search(r'void\s+RequestDepositMoney\s*\(\s*LPCHARACTER\s+ch,\s*int64_t\s+iGold\s*\);', guild_h))
self.assertTrue(re.search(r'void\s+RequestWithdrawMoney\s*\(\s*LPCHARACTER\s+ch,\s*int64_t\s+iGold\s*\);', guild_h))
self.assertTrue(re.search(r'void\s+RecvMoneyChange\s*\(\s*int64_t\s+iGold\s*\);', guild_h))
self.assertTrue(re.search(r'void\s+RecvWithdrawMoneyGive\s*\(\s*int64_t\s+iChangeGold\s*\);', guild_h))
self.assertTrue(re.search(r'int64_t\s+GetGuildMoney\s*\(\)\s*const\s*\{\s*return\s+m_data\.gold;\s*\}', guild_h))
def test_db_manager_and_logging_interfaces(self):
db_h = read_server_file("src/server/game/src/db.h")
self.assertIn("void\t\t\tSendMoneyLog(BYTE type, DWORD vnum, int64_t gold);", db_h)
money_log_h = read_server_file("src/server/db/src/MoneyLog.h")
self.assertIn("void AddLog(BYTE bType, DWORD dwVnum, int64_t iGold);", money_log_h)
self.assertIn("std::map<DWORD, int64_t> m_MoneyLogContainer", money_log_h)
guild_manager_h = read_server_file("src/server/db/src/GuildManager.h")
self.assertIn("int64_t\tgold;", guild_manager_h)
self.assertIn("void\tDepositMoney(DWORD dwGuild, int64_t lGold);", guild_manager_h)
self.assertIn("void\tWithdrawMoney(CPeer* peer, DWORD dwGuild, int64_t lGold);", guild_manager_h)
self.assertIn("void\tWithdrawMoneyReply(DWORD dwGuild, BYTE bGiveSuccess, int64_t lGold);", guild_manager_h)
self.assertIn("void\tMoneyChange(DWORD dwGuild, int64_t dwGold);", guild_manager_h)
def test_overflow_and_security_guards(self):
char_cpp = read_server_file("src/server/game/src/char.cpp")
self.assertTrue("PortGoldCanChange(GetGold(),amount,GOLD_MAX_64)" in char_cpp)
self.assertNotIn("else if (amount < 0 && -amount > GetGold())", char_cpp)
self.assertIn("!PortGoldCanChange(nTotalMoney, price, GOLD_MAX_64)", char_cpp)
exchange_cpp = read_server_file("src/server/game/src/exchange.cpp")
self.assertIn("if (m_lGold > 0 && victim->GetGold() > GOLD_MAX_64 - m_lGold)", exchange_cpp)
self.assertTrue("int64_t dwPacketGold = m_lGold;" in exchange_cpp)
shop_cpp = read_server_file("src/server/game/src/shop_manager.cpp")
self.assertIn("!PortGoldCanChange(ch->GetGold(), dwPrice, GOLD_MAX_64)", shop_cpp)
offlineshop_cpp = read_server_file("src/server/game/src/offlineshop_manager.cpp")
self.assertIn("if (GOLD_MAX_64 <= nTotalMoney)", offlineshop_cpp)
input_main_cpp = read_server_file("src/server/game/src/input_main.cpp")
self.assertIn("if (ch->GetGold() >= GOLD_MAX_64)", input_main_cpp)
self.assertTrue("pinfo->arg1 > GOLD_MAX_64-" in input_main_cpp)
guild_cpp = read_server_file("src/server/game/src/guild.cpp")
self.assertIn("if (m_data.gold > GOLD_MAX_64 - iGold)", guild_cpp)
self.assertIn("if (ch->GetGold() > GOLD_MAX_64 - iGold)", guild_cpp)
self.assertTrue("pack_sub.gold\t= m_data.gold;" in guild_cpp)
self.assertTrue("int64_t packet_gold = iGold;" in guild_cpp)
def test_database_persistence_and_queries(self):
cmp_cpp = read_server_file("src/server/db/src/ClientManagerPlayer.cpp")
self.assertIn('"gold = %lld, "', cmp_cpp)
self.assertIn("(long long) pkTab->gold,", cmp_cpp)
self.assertIn("(long long) pTab->gold", cmp_cpp)
self.assertIn('0, %lld, 0, "', cmp_cpp)
self.assertIn("(long long) packet->player_table.gold", cmp_cpp)
cm_cpp = read_server_file("src/server/db/src/ClientManager.cpp")
self.assertIn("SELECT account_id, size, password, gold FROM safebox", cm_cpp)
self.assertIn("str_to_number(pSafebox->dwGold, row[3]);", cm_cpp)
self.assertIn("UPDATE safebox%s SET gold='%lld' WHERE account_id=%u", cm_cpp)
gm_cpp = read_server_file("src/server/db/src/GuildManager.cpp")
self.assertIn("UPDATE guild%s SET gold=%lld WHERE id = %u", gm_cpp)
def test_sql_migration_and_rollback_scripts(self):
migrate_sql = read_server_file("tools/gold64/migrate_gold64.sql")
self.assertIn("SIGNAL SQLSTATE", migrate_sql)
planner=read_server_file("tools/gold64/migrate_gold64.py")
self.assertIn("'player_deleted'", planner)
self.assertIn("'money_log'", planner)
self.assertNotIn("UPDATE `player` SET `gold`", planner)
rollback_sql = read_server_file("tools/gold64/rollback_gold64.sql")
self.assertNotRegex(rollback_sql, r'(?im)^\s*(UPDATE|ALTER|DELETE|TRUNCATE)\b')
self.assertIn("compatible", rollback_sql)
def test_client_python_64bit_bridging(self):
if os.path.exists(CLIENT_ROOT):
exchange_mod = read_client_file("src/port/UserInterface/PythonExchangeModule.cpp")
self.assertIn("return PyLong_FromLongLong(CPythonExchange::Instance().GetElkFromSelf());", exchange_mod)
self.assertIn("return PyLong_FromLongLong(CPythonExchange::Instance().GetElkFromTarget());", exchange_mod)
safebox_mod = read_client_file("src/port/UserInterface/PythonSafeBox.cpp")
self.assertIn("return PyLong_FromLongLong(CPythonSafeBox::Instance().GetMoney());", safebox_mod)
guild_mod = read_client_file("src/port/UserInterface/PythonGuild.cpp")
self.assertIn("return PyLong_FromLongLong(rGuildInfo.dwGuildMoney);", guild_mod)
def test_cxx_execution_boundary_simulation(self):
"""
Compiles and executes a native C++ probe that verifies:
- 20-billion boundary transition without 32-bit integer overflow.
- 50-billion exchange between entities with asset conservation.
- Cold restart serialization via snprintf and deserialization via strtoull.
- Overflow and underflow mathematical safety.
"""
cxx_code = r'''
#include <iostream>
#include <cstdint>
#include <cassert>
#include <cstdio>
#include <cstdlib>
#include <cstring>
static const int64_t GOLD_MAX_64 = 2000000000000000LL;
static const int64_t LEGACY_GOLD_MAX = 2000000000LL;
#include "src/server/common/gold_bounds.h"
struct MockCharacter {
int64_t gold;
MockCharacter(int64_t value=0):gold(value){}
bool PointChange(int64_t delta){if(!PortGoldCanChange(gold,delta,GOLD_MAX_64))return false;gold+=delta;return true;}
int32_t GetLegacyClampedGold(){return gold>LEGACY_GOLD_MAX?LEGACY_GOLD_MAX:gold;}
};
int main() {
// 1. Boundary transition past 2 billion
MockCharacter player(1900000000LL);
assert(player.GetLegacyClampedGold() == 1900000000);
// Add 200 million -> 2.1 billion
bool ok = player.PointChange(200000000LL);
assert(ok);
assert(player.gold == 2100000000LL);
assert(player.GetLegacyClampedGold() == 2000000000); // Clamped to 2B for legacy packets
// 2. 50-billion exchange between two characters
MockCharacter charA(60000000000LL); // 60B
MockCharacter charB(10000000000LL); // 10B
int64_t tradeAmount = 5000000000LL; // 5B
// Check victim overflow before trade
assert(!(tradeAmount > 0 && charB.gold > GOLD_MAX_64 - tradeAmount));
assert(charA.gold >= tradeAmount);
charA.PointChange(-tradeAmount);
charB.PointChange(tradeAmount);
assert(charA.gold == 55000000000LL);
assert(charB.gold == 15000000000LL);
assert(charA.gold + charB.gold == 70000000000LL); // Conservation
// 3. Overflow protection at GOLD_MAX_64
MockCharacter richPlayer(GOLD_MAX_64 - 1000LL);
bool overflowBlocked = richPlayer.PointChange(2000LL);
assert(!overflowBlocked);
assert(richPlayer.gold == GOLD_MAX_64 - 1000LL);
// 4. Underflow protection
MockCharacter poorPlayer(500LL);
bool underflowBlocked = poorPlayer.PointChange(-1000LL);
assert(!underflowBlocked);
assert(poorPlayer.gold == 500);
// 5. Cold restart persistence (100 billion gold)
int64_t originalGold = 100000000000LL; // 100B
char sqlQuery[256];
snprintf(sqlQuery, sizeof(sqlQuery), "UPDATE player SET gold = %lld WHERE id = 1;", (long long)originalGold);
// Parse back from SQL query simulation
const char* valStr = strstr(sqlQuery, "gold = ");
assert(valStr != nullptr);
valStr += 7;
int64_t loadedGold = (int64_t)strtoull(valStr, nullptr, 10);
assert(loadedGold == originalGold);
// 6. Safebox cold restart
char safeboxQuery[256];
snprintf(safeboxQuery, sizeof(safeboxQuery), "UPDATE safebox SET gold='%lld' WHERE account_id=1", (long long)originalGold);
const char* sbValStr = strstr(safeboxQuery, "gold='");
assert(sbValStr != nullptr);
sbValStr += 6;
int64_t loadedSbGold = (int64_t)strtoull(sbValStr, nullptr, 10);
assert(loadedSbGold == originalGold);
std::cout << "PASS: All 64-bit gold simulation checks succeeded" << std::endl;
return 0;
}
'''
with tempfile.TemporaryDirectory() as tmpdir:
src_file = os.path.join(tmpdir, "probe_gold64.cpp")
bin_file = os.path.join(tmpdir, "probe_gold64")
with open(src_file, "w") as f:
f.write(cxx_code)
compile_cmd = ["clang++", "-std=c++17", "-I"+SERVER_ROOT, "-O2", src_file, "-o", bin_file]
res = subprocess.run(compile_cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
self.assertEqual(res.returncode, 0, f"Compilation failed: {res.stderr}")
run_res = subprocess.run([bin_file], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True)
self.assertEqual(run_res.returncode, 0, f"Runtime failed: {run_res.stderr}")
self.assertIn("PASS: All 64-bit gold simulation checks succeeded", run_res.stdout)
if __name__ == "__main__":
unittest.main()