137 lines
11 KiB
Python
137 lines
11 KiB
Python
"""Preparation protocol/state core. No assertion of complete actor quiescence."""
|
|
import subprocess
|
|
import tempfile
|
|
import unittest
|
|
from pathlib import Path
|
|
|
|
ROOT=Path(__file__).resolve().parents[2]
|
|
|
|
|
|
class CubeHandshake(unittest.TestCase):
|
|
def test_actual_game_snapshot_covers_all_owned_windows_and_metadata(self):
|
|
body=(ROOT/'src/server/game/src/port_cube_actor.cpp').read_text().split('struct Snapshot ',1)[1].split('bool matches(',1)[0]
|
|
source=r'''
|
|
#include "src/server/common/cube_handshake.h"
|
|
#include "src/server/common/cube_craft.h"
|
|
#include "src/server/common/cube_live_image.h"
|
|
#include "src/server/common/cube_presentation.h"
|
|
#include "src/server/game/src/port_cube_restore.h"
|
|
#include "src/server/common/cube_gold_outbox.h"
|
|
#define sys_err(...) ((void)0)
|
|
#include <cassert>
|
|
#include <map>
|
|
#include <set>
|
|
constexpr unsigned INVENTORY=1,DRAGON_SOUL_INVENTORY=5,SWITCHBOT=7,UPGRADE_INVENTORY=8,COSTUME_INVENTORY=12;
|
|
constexpr unsigned INVENTORY_MAX_NUM=225,INVENTORY_AND_EQUIP_SLOT_MAX=300,DRAGON_SOUL_INVENTORY_MAX_NUM=32,SWITCHBOT_SLOT_COUNT=6,SPECIAL_INVENTORY_MAX_NUM=225;
|
|
#define ENABLE_SPECIAL_STORAGE
|
|
struct TItemPos{unsigned window,cell;TItemPos(unsigned w,unsigned c):window(w),cell(c){}};
|
|
struct CHARACTER;
|
|
struct Item{CHARACTER* owner=nullptr;unsigned id=10,vnum=30006,count=10,window=1,cell=0;bool locked=false,exchanging=false,equipped=false;long sockets[3]={};struct Attr{uint8_t bType=0;int16_t sValue=0;} attr[7];struct Extra{uint8_t data[69]={};}extra;
|
|
unsigned GetID(){return id;}unsigned GetOriginalVnum(){return vnum;}unsigned GetCount(){return count;}unsigned GetWindow(){return window;}unsigned GetCell(){return cell;}CHARACTER* GetOwner(){return owner;}
|
|
bool isLocked(){return locked;}bool IsExchanging(){return exchanging;}bool IsEquipped(){return equipped;}long GetSocket(unsigned n){return sockets[n];}Attr* GetAttributes(){return attr;}const Extra& GetPortExtra(){return extra;}};
|
|
using LPITEM=Item*;
|
|
struct CHARACTER{int64_t gold=1000;std::map<std::pair<unsigned,unsigned>,LPITEM> cells;int64_t GetGold(){return gold;}LPITEM GetItem(TItemPos pos){auto it=cells.find({pos.window,pos.cell});return it==cells.end()?nullptr:it->second;}};
|
|
using LPCHARACTER=CHARACTER*;
|
|
'''
|
|
tests=r'''
|
|
int main(){CHARACTER ch,foreign;Item item;item.owner=&ch;item.sockets[0]=INT32_MIN;item.attr[0]={255,INT16_MIN};item.extra.data[68]=0x81;ch.cells[{1,0}]=&item;ch.cells[{1,5}]=&item;
|
|
std::vector<Item> extras(8);unsigned n=0;for(unsigned window:{1u,5u,7u,8u,9u,10u,11u,12u}){auto& x=extras[n];x.owner=&ch;x.window=window;x.cell=window==1?225:0;x.id=20+n++;x.equipped=window==1;ch.cells[{window,x.cell}]=&x;}
|
|
Snapshot original;assert(capture(&ch,original)&&original.items.size()==9&&original.ordinary.size()==1);assert(original.ordinary[0].value.sockets[0]==INT32_MIN&&original.ordinary[0].value.values[0]==INT16_MIN&&original.ordinary[0].value.extra[68]==0x81);
|
|
for(auto& x:extras){x.count++;Snapshot changed;assert(capture(&ch,changed)&&changed.seal!=original.seal);x.count--;}
|
|
item.locked=true;{Snapshot x;assert(capture(&ch,x)&&x.seal!=original.seal&&!x.ordinary[0].usable);}item.locked=false;
|
|
item.owner=&foreign;{Snapshot x;assert(!capture(&ch,x));}item.owner=&ch;
|
|
Item alias=item;alias.cell=1;ch.cells[{1,1}]=&alias;{Snapshot x;assert(!capture(&ch,x));}ch.cells.erase({1,1});
|
|
if(sizeof(long)>4){item.sockets[0]=int64_t(INT32_MAX)+1;Snapshot x;assert(!capture(&ch,x));item.sockets[0]=INT32_MIN;}
|
|
ch.gold=-1;{Snapshot x;assert(!capture(&ch,x));}
|
|
}
|
|
'''
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
cpp=Path(folder)/'snapshot.cpp';exe=Path(folder)/'snapshot';cpp.write_text(source+'struct Snapshot '+body+tests)
|
|
subprocess.run(['c++','-std=c++17','-fsanitize=address,undefined',
|
|
'-fno-sanitize-recover=all','-I'+str(ROOT),str(cpp),'-o',str(exe)],check=True)
|
|
subprocess.run([str(exe)],check=True)
|
|
|
|
def test_bounded_wire_and_fail_closed_actor_state(self):
|
|
prefix=(ROOT/'tests/features/fixtures/cube_batch_probe.cpp').read_text().split('int main(int argc,char** argv)',1)[0]
|
|
tests=r'''
|
|
#include "src/server/common/cube_handshake.h"
|
|
int main(){
|
|
assert(!HandshakeEnabled&&!ActorMutationAuditComplete);
|
|
auto b=batch();auto arm=ArmFrame(b,123);assert(ValidHandshake(arm));auto bytes=EncodeHandshake(arm);Handshake decoded;
|
|
assert(bytes.size()==HandshakeFixed+Encode(b).size());assert(DecodeHandshake(bytes.data(),bytes.size(),decoded));assert(SameIdentity(decoded,arm)&&decoded.body==arm.body);
|
|
for(size_t i=0;i<bytes.size();++i)assert(!DecodeHandshake(bytes.data(),i,decoded));
|
|
auto bad=bytes;bad+='x';assert(!DecodeHandshake(bad.data(),bad.size(),decoded));
|
|
for(unsigned field:{4u,5u,6u,7u,100u,101u}){bad=bytes;bad[field]=char(255);assert(!DecodeHandshake(bad.data(),bad.size(),decoded));}
|
|
assert(!DecodeHandshake(nullptr,102,decoded));assert(!DecodeHandshake(bytes.data(),HandshakeMaximum+1,decoded));
|
|
auto wrong=arm;wrong.player++;assert(EncodeHandshake(wrong).empty());wrong=arm;wrong.cookie=1;assert(EncodeHandshake(wrong).empty());
|
|
Handshake reply=arm;reply.body.clear();reply.message=Message::Answer;reply.status=Status::Armed;reply.cookie=7;
|
|
ActorHandshake flow;assert(!flow.Start(b,123,100,false)&&!flow.BlocksActions());
|
|
// true is an EXPLICIT audited-freeze boundary substitute, not a real character.
|
|
assert(flow.Start(b,123,100,true)&&flow.BlocksActions());assert(!flow.Start(b,123,100,true));
|
|
wrong=reply;wrong.session++;assert(!flow.Armed(wrong,101));wrong=reply;wrong.epoch++;assert(!flow.Armed(wrong,101));
|
|
assert(flow.Armed(reply,101));wrong=reply;wrong.cookie++;assert(!flow.Armed(wrong,102));
|
|
assert(!flow.Submit(false,102)&&flow.BlocksActions());assert(flow.Submit(true,102));assert(!flow.Cancel());
|
|
reply.status=Status::Cancelled;assert(!flow.Answer(reply)&&flow.BlocksActions());
|
|
assert(!flow.TimedOut(101)&&!flow.TimedOut(111));assert(flow.TimedOut(112)&&flow.State()==ActorHandshake::Held);
|
|
reply.status=Status::Denied;assert(!flow.Answer(reply)&&flow.BlocksActions());reply.status=Status::Frozen;assert(flow.Answer(reply)&&flow.BlocksActions());
|
|
reply.status=Status::Cancelled;assert(!flow.Answer(reply)); // no timeout-to-cancel shortcut
|
|
ActorHandshake cancel;assert(cancel.Start(b,123,100,true));reply.status=Status::Armed;assert(cancel.Armed(reply,101)&&cancel.Cancel());
|
|
wrong=reply;wrong.status=Status::Cancelled;wrong.token=std::string(32,'c');assert(!cancel.Answer(wrong));reply.status=Status::Cancelled;assert(cancel.Answer(reply)&&!cancel.BlocksActions());
|
|
assert(!cancel.Answer(reply)); // late reply cannot affect the next generation
|
|
ActorHandshake dirty;assert(dirty.Start(b,123,100,true));dirty.Invalidate(ItemWrite);reply.status=Status::Armed;
|
|
assert(dirty.Invalidated()==ItemWrite&&dirty.Armed(reply,101)&&!dirty.Submit(true,102)&&dirty.Cancel());
|
|
reply.status=Status::Cancelled;assert(dirty.Answer(reply)&&!dirty.BlocksActions());
|
|
assert(dirty.Start(b,123,100,true)&&!dirty.Invalidated());reply.status=Status::Armed;assert(dirty.Armed(reply,101)&&dirty.Submit(true,102));
|
|
dirty.Invalidate(GoldWrite);dirty.Invalidate(ItemWrite);assert(dirty.State()==ActorHandshake::Held&&dirty.Invalidated()==(GoldWrite|ItemWrite)&&!dirty.Cancel());
|
|
auto invalid=dirty.Request(Message::Invalidate);auto encoded=EncodeHandshake(invalid);assert(!encoded.empty()&&DecodeHandshake(encoded.data(),encoded.size(),decoded));
|
|
b.epoch++;assert(cancel.Start(b,124,200,true));assert(!cancel.Armed(reply,201));cancel.LostTransport();assert(cancel.State()==ActorHandshake::Held&&!cancel.Armed(reply,202)&&!cancel.Cancel());
|
|
puts("PASS bounded LE preparation wire and explicit-freeze-substitute state core: identity, epoch, duplicate/stale ACK, timeout, lost connection, no post-submit thaw");
|
|
}
|
|
'''
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
cpp=Path(folder)/'handshake.cpp';exe=Path(folder)/'handshake'
|
|
cpp.write_text(prefix+tests)
|
|
subprocess.run(['c++','-std=c++17','-fsanitize=address,undefined',
|
|
'-fno-sanitize-recover=all','-I'+str(ROOT),str(cpp),'-lsqlite3','-o',str(exe)],check=True)
|
|
subprocess.run([str(exe)],check=True)
|
|
|
|
def test_flush_includes_dirty_detached_items_without_stealing_other_owners(self):
|
|
body=(ROOT/'src/server/game/src/port_cube_flush.inc').read_text()
|
|
source=r'''
|
|
#include <cassert>
|
|
#include <unordered_set>
|
|
#include <vector>
|
|
using DWORD=unsigned;
|
|
struct CHARACTER{unsigned id;unsigned GetPlayerID(){return id;}};
|
|
struct CItem{CHARACTER* owner;unsigned last;CHARACTER* GetOwner(){return owner;}unsigned GetLastOwnerPID(){return last;}};
|
|
using LPITEM=CItem*;
|
|
struct ITEM_MANAGER{std::unordered_set<LPITEM> m_set_pkItemForDelayedSave;std::vector<LPITEM> saved;void SaveSingleItem(LPITEM p){saved.push_back(p);}void FlushDelayedSaveForPlayer(DWORD);};
|
|
'''
|
|
tests=r'''
|
|
int main(){CHARACTER a{1},b{2};CItem owned{&a,1},detached{nullptr,1},foreign{&b,1},other{nullptr,2};ITEM_MANAGER m;
|
|
m.m_set_pkItemForDelayedSave={&owned,&detached,&foreign,&other};m.FlushDelayedSaveForPlayer(0);assert(m.saved.empty());m.FlushDelayedSaveForPlayer(1);
|
|
assert(m.saved.size()==2&&!m.m_set_pkItemForDelayedSave.count(&owned)&&!m.m_set_pkItemForDelayedSave.count(&detached));
|
|
assert(m.m_set_pkItemForDelayedSave.count(&foreign)&&m.m_set_pkItemForDelayedSave.count(&other));m.FlushDelayedSaveForPlayer(1);assert(m.saved.size()==2);
|
|
}
|
|
'''
|
|
with tempfile.TemporaryDirectory() as folder:
|
|
cpp=Path(folder)/'flush.cpp';exe=Path(folder)/'flush';cpp.write_text(source+body+tests)
|
|
subprocess.run(['c++','-std=c++17','-fsanitize=address,undefined','-I'+str(ROOT),str(cpp),'-o',str(exe)],check=True)
|
|
subprocess.run([str(exe)],check=True)
|
|
|
|
def test_game_dispatch_keeps_gate_closed_and_saves_precede_submit(self):
|
|
source=(ROOT/'src/server/game/src/port_cube_actor.cpp').read_text()
|
|
self.assertIn('if(!PortCube::HandshakeEnabled||!PortCube::ActorMutationAuditComplete)return false;',source)
|
|
self.assertLess(source.index('ch->SaveReal();'),source.index('o.flow.Submit(true,now)'))
|
|
self.assertIn('FlushDelayedSaveForPlayer(f.player)',source)
|
|
self.assertIn('PortCubeActorHeld(this)',(ROOT/'src/server/game/src/char_item.cpp').read_text())
|
|
self.assertIn('PortCubeActorForget(this)',(ROOT/'src/server/game/src/char.cpp').read_text())
|
|
self.assertIn('PortCubeActorTick();',(ROOT/'src/server/game/src/main.cpp').read_text())
|
|
db=(ROOT/'src/server/game/src/input_db.cpp').read_text()
|
|
self.assertIn('!PortCube::DecodeHandshake(pRealData,size_t(iSize),frame)',db)
|
|
# These two legacy-encoding files only receive narrow ASCII insertions.
|
|
self.assertIn(b'#include "port_cube_flush.inc"',(ROOT/'src/server/game/src/item_manager.cpp').read_bytes())
|
|
|
|
|
|
if __name__=='__main__':unittest.main()
|