268 lines
18 KiB
C++
268 lines
18 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
#include "formats/executable_layout.hpp"
|
|
#include <algorithm>
|
|
#include <chrono>
|
|
#include <cstdio>
|
|
#include <filesystem>
|
|
#include <optional>
|
|
#include <stdexcept>
|
|
#include <string>
|
|
#include <vector>
|
|
|
|
#include "app/controller.hpp"
|
|
#include "game/save.hpp"
|
|
|
|
using namespace bmh;
|
|
namespace fs=std::filesystem;
|
|
namespace {
|
|
void require(bool ok,const char* message){if(!ok)throw std::runtime_error(message);}
|
|
struct TemporarySaves {
|
|
fs::path path;
|
|
TemporarySaves(const fs::path& input){
|
|
static unsigned serial=0;
|
|
path=fs::temp_directory_path()/("openbmh-pending-desk-app-"+
|
|
std::to_string(std::chrono::steady_clock::now().time_since_epoch().count())+"-"+std::to_string(++serial));
|
|
require(fs::create_directory(path),"isolated test save directory created");
|
|
fs::copy_file(input,path/"AUTOSAVE.FBM");
|
|
}
|
|
~TemporarySaves(){std::error_code ignored;fs::remove_all(path,ignored);}
|
|
};
|
|
struct Context {
|
|
fs::path data;
|
|
TemporarySaves saves;
|
|
ui::StartupFlow flow;
|
|
std::unique_ptr<app::CareerSession> session;
|
|
uint64_t revision=0;
|
|
openbmh::audio::Playback playback;
|
|
std::optional<uint64_t> audio;
|
|
Context(const fs::path& d,const fs::path& input):data(d),saves(input),flow(d,saves.path){
|
|
require(load_savegame(input).checksum_ok,"genuine native fixture checksum");
|
|
playback.set_muted(true);
|
|
flow.click(214,215);
|
|
auto load=flow.send_key("ENTER");
|
|
require(load.request==ui::FlowRequest::file_action&&load.file_action.action==ui::SaveLoadAction::load,
|
|
"actual production load request selects the isolated native fixture");
|
|
require(serve(load).empty()&&session&&revision==1&&flow.screen_name()=="desktop",
|
|
"actual controller loads genuine Native QA_INPUT at revision1");
|
|
require(session->state().memory.u32(::bmh::layout::OfferSlots)==0x80003800u&&
|
|
session->state().manager_teams.size()==1&&session->state().manager_teams[0]==33,
|
|
"actual loaded desk contains original N.Brown salary demand");
|
|
}
|
|
std::string serve(const ui::FlowResult& request,PendingOfferHooks hooks={},
|
|
std::function<void(int,const std::vector<MatchGroup>&,const GameState&)> live={}){
|
|
return app::serve_flow_request(flow,request,session,data,saves.path,1,revision,playback,audio,false,
|
|
std::move(live),{},{},{},{},{},{},{},std::move(hooks),
|
|
app::PendingOfferEntryPolicy::normal_interactive);
|
|
}
|
|
ui::FlowResult advance(){
|
|
require(flow.desktop()!=nullptr&&!flow.desktop()->pending(),"desktop is available for a fresh actual request");
|
|
const auto& items=flow.desktop()->state().items;
|
|
const auto item=std::find_if(items.begin(),items.end(),[](const auto& i){return !i.disabled&&(i.kind==12||(i.kind==58&&i.open));});
|
|
require(item!=items.end(),"actual native advance item is enabled");
|
|
auto request=flow.click(item->x+item->width/2,item->y+item->height/2);
|
|
require(request.request==ui::FlowRequest::kickoff&&flow.desktop()->pending()&&request.desk_action.revision==revision,
|
|
"actual flow owns same-revision advance request");return request;
|
|
}
|
|
};
|
|
struct Snapshot {Bytes native;WatcomRandom w;GameRandom g;};
|
|
Snapshot snapshot(const GameState& state,const WatcomRandom& w,const GameRandom& g){return {save_stream(state),w,g};}
|
|
Snapshot snapshot(app::CareerSession& s){return snapshot(s.state(),s.rand(),s.game());}
|
|
void same(const Snapshot& a,const Snapshot& b){
|
|
require(a.native==b.native&&a.w.seed()==b.w.seed()&&a.w.calls()==b.w.calls()&&
|
|
a.g.seed()==b.g.seed()&&a.g.calls()==b.g.calls(),"full native state and W/G match the owned snapshot");
|
|
}
|
|
bool same_group(const MatchGroup& a,const MatchGroup& b){
|
|
return a.desc==b.desc&&a.fixtures==b.fixtures&&a.results==b.results&&a.cup_results==b.cup_results&&
|
|
a.cup_other_leg==b.cup_other_leg&&a.cup_result_address[0]==b.cup_result_address[0]&&
|
|
a.cup_result_address[1]==b.cup_result_address[1]&&a.phase==b.phase&&a.records==b.records&&
|
|
a.end_minute==b.end_minute&&a.spectators==b.spectators&&a.log==b.log&&a.ended==b.ended&&
|
|
a.kickoff_void_mask==b.kickoff_void_mask;
|
|
}
|
|
bool same_groups(const std::vector<MatchGroup>& a,const std::vector<MatchGroup>& b){
|
|
return a.size()==b.size()&&std::equal(a.begin(),a.end(),b.begin(),same_group);
|
|
}
|
|
void same_driver(const TurnDriver& a,const TurnDriver& b){
|
|
require(a.stage==b.stage&&a.manager_position==b.manager_position&&a.revision==b.revision&&
|
|
a.loaded_matchday_resume==b.loaded_matchday_resume&&
|
|
a.suppress_remaining_pre_match_offers==b.suppress_remaining_pre_match_offers&&
|
|
a.calendar_entry==b.calendar_entry&&a.session_id==b.session_id&&a.next_event_id==b.next_event_id&&
|
|
a.referee_source==b.referee_source&&a.referees==b.referees&&same_groups(a.groups,b.groups)&&
|
|
a.last_results.valid==b.last_results.valid&&a.last_results.date==b.last_results.date&&
|
|
a.last_results.calendar_entry==b.last_results.calendar_entry&&a.last_results.matchday==b.last_results.matchday&&
|
|
same_groups(a.last_results.groups,b.last_results.groups),"waiting retains complete unclaimed driver cursor and event data");
|
|
}
|
|
struct AnswerSentinel {
|
|
const void* identity;
|
|
PendingOfferAnswer operator()(const GameState&,const PendingOfferQuestion&)const{return PendingOfferAnswer::unsupported;}
|
|
};
|
|
struct ChoiceSentinel {
|
|
const void* identity;
|
|
PendingOfferTransferChoice operator()(const GameState&,const TransferOfferListView&)const{return {};}
|
|
};
|
|
struct NoticeSentinel {
|
|
const void* identity;
|
|
void operator()(const GameState&,const PendingOfferNotice&)const{}
|
|
};
|
|
void install_sentinels(Context& c,const void* id){
|
|
PendingOfferHooks h;h.answer=AnswerSentinel{id};h.select_transfer=ChoiceSentinel{id};h.notice=NoticeSentinel{id};
|
|
c.session->set_pending_offer_hooks(std::move(h));
|
|
}
|
|
void restored(const Context& c,const void* id){
|
|
const auto& h=c.session->pending_offer_hooks();
|
|
const auto* a=h.answer.target<AnswerSentinel>();const auto* s=h.select_transfer.target<ChoiceSentinel>();
|
|
const auto* n=h.notice.target<NoticeSentinel>();
|
|
require(a&&s&&n&&a->identity==id&&s->identity==id&&n->identity==id,
|
|
"controller restores all three preexisting pending presenters after borrowed scope");
|
|
require(c.session->pending_offer_entry_policy()==app::PendingOfferEntryPolicy::legacy_unpresented,
|
|
"controller restores previous explicit legacy entry policy after normal-mode borrowed scope");
|
|
}
|
|
void waiting(Context& c,const Snapshot& before,const TurnDriver& driver){
|
|
same(snapshot(*c.session),before);same_driver(c.session->manager_join_checkpoint().driver,driver);
|
|
require(c.revision==1&&c.flow.desktop()->state().revision==1&&!c.flow.desktop()->pending()&&
|
|
c.flow.screen_name()=="desktop"&&!c.session->completed_matchday_results()&&c.playback.queued_bytes()==0,
|
|
"waiting rejects UI request at unchanged revision, without audio/result handoff");
|
|
}
|
|
struct Oracle {
|
|
Snapshot pending,first_minute,final;
|
|
std::vector<Bytes> question_states,chooser_states,notice_states;
|
|
std::vector<uint32_t> notice_addresses;
|
|
TurnAdvanceResult result;
|
|
bool minute_seen=false;
|
|
};
|
|
Oracle oracle(Context& c,const ui::FlowResult& request,bool fee){
|
|
auto checkpoint=c.session->manager_join_checkpoint();Oracle out;
|
|
PendingOfferHooks h;
|
|
h.answer=[&](const GameState& state,const PendingOfferQuestion&){out.question_states.push_back(save_stream(state));return PendingOfferAnswer::yes;};
|
|
h.select_transfer=[&](const GameState& state,const TransferOfferListView&){out.chooser_states.push_back(save_stream(state));return PendingOfferTransferChoice{PendingOfferTransferChoiceKind::bid,0};};
|
|
h.notice=[&](const GameState& state,const PendingOfferNotice& n){out.notice_states.push_back(save_stream(state));out.notice_addresses.push_back(n.text_address);};
|
|
MinuteReport report;
|
|
const auto processed=process_natural_pending_offers_after_desk(checkpoint.state,
|
|
{PendingOfferDeskRuntimeMode::normal_interactive,1,checkpoint.driver.manager_position},
|
|
checkpoint.game,checkpoint.rand,h,report);
|
|
require(processed.completed&&!report.unsupported&&processed.processed==1,
|
|
"direct actual Core oracle completes genuine native post-desk batch");
|
|
require(checkpoint.state.memory.u8(::bmh::layout::DeskPosition)==1&&checkpoint.state.date==c.session->state().date,
|
|
"Core oracle completes manager cursor before match/date advancement");
|
|
out.pending=snapshot(checkpoint.state,checkpoint.rand,checkpoint.game);
|
|
require(fee?out.chooser_states.size()==1&&out.notice_addresses==std::vector<uint32_t>{::bmh::layout::PendingOffer_FormatError_ExecutableField2}:
|
|
out.question_states.size()==1&&processed.salary_accepted==1,
|
|
"oracle takes intended salary or actual rawbid0 settlement branch");
|
|
checkpoint.driver.revision=c.revision;
|
|
checkpoint.driver.live_minute=[&](int,MatchEngine&,std::vector<MatchGroup>&,GameState& state){
|
|
if(!out.minute_seen){out.first_minute=snapshot(state,checkpoint.rand,checkpoint.game);out.minute_seen=true;}
|
|
};
|
|
MinuteReport turn_report;
|
|
out.result=advance_to_next_desk(checkpoint.driver,checkpoint.state,
|
|
{request.desk_action.manager_slot,request.desk_action.revision},checkpoint.game,checkpoint.rand,turn_report);
|
|
require(!turn_report.unsupported&&out.result.kind!=TurnDeskKind::Failed&&out.minute_seen,
|
|
"actual bound Native event oracle reaches next desk and has a real first minute");
|
|
out.final=snapshot(checkpoint.state,checkpoint.rand,checkpoint.game);return out;
|
|
}
|
|
void guards(Context& c,const ui::FlowResult& request,const Snapshot& before){
|
|
same(snapshot(*c.session),before);
|
|
require(c.revision==1&&c.flow.desktop()->state().revision==1&&
|
|
c.session->pending_offer_entry_policy()==app::PendingOfferEntryPolicy::normal_interactive,
|
|
"pending callback borrows explicit normal policy without intermediate revision publication");
|
|
std::string error;
|
|
require(c.session->dispatch_kickoff(request.desk_action,c.revision,error).kind==TurnDeskKind::Failed&&
|
|
error=="pending_offer_decision_active","nested kickoff is blocked inside pending presenter");
|
|
require(!c.session->dispatch_club_player_pending_offers({33,14,5,5,-1},1,{},c.revision,error),
|
|
"nested manual batch is blocked inside natural pending presenter");
|
|
const auto forbidden=c.saves.path/"MUST-NOT-WRITE.FBM";
|
|
require(!c.session->save_game(forbidden,0,false,error)&&error=="pending_offer_decision_active"&&
|
|
!fs::exists(forbidden),"partial pending transaction cannot write a save");
|
|
same(snapshot(*c.session),before);
|
|
}
|
|
void successful_retry(Context& c,bool fee){
|
|
auto request=c.advance();auto before=snapshot(*c.session);const auto before_date=c.session->state().date;
|
|
const auto expected=oracle(c,request,fee);
|
|
size_t questions=0,choosers=0,notices=0;bool minute_seen=false;
|
|
PendingOfferHooks h;
|
|
h.answer=[&](const GameState& staged,const PendingOfferQuestion& q){
|
|
require(!fee&&questions<expected.question_states.size()&&save_stream(staged)==expected.question_states[questions++]&&
|
|
q.source_flags==1&&q.clicked_source_slot==797&&q.amount==52300,
|
|
"actual controller salary presenter borrows exact pre-driver Core state");
|
|
guards(c,request,before);return PendingOfferAnswer::yes;
|
|
};
|
|
h.select_transfer=[&](const GameState& staged,const TransferOfferListView& v){
|
|
require(fee&&choosers<expected.chooser_states.size()&&save_stream(staged)==expected.chooser_states[choosers++]&&
|
|
v.valid&&v.list_entry==40,"actual chooser borrows exact Core special-entry quote state");
|
|
guards(c,request,before);return PendingOfferTransferChoice{PendingOfferTransferChoiceKind::bid,0};
|
|
};
|
|
h.notice=[&](const GameState& staged,const PendingOfferNotice& n){
|
|
require(fee&¬ices<expected.notice_states.size()&&save_stream(staged)==expected.notice_states[notices]&&
|
|
n.text_address==expected.notice_addresses[notices],"actual notice borrows settled staged accounting before driver");
|
|
++notices;guards(c,request,before);
|
|
};
|
|
auto live=[&](int,const std::vector<MatchGroup>&,const GameState& state){
|
|
if(minute_seen)return;minute_seen=true;
|
|
require(&state==&c.session->state()&&c.revision==1&&state.date==before_date&&
|
|
state.memory.u8(::bmh::layout::DeskPosition)==1,"real live-minute callback sees committed manager phase without intermediate publication");
|
|
same(snapshot(state,c.session->rand(),c.session->game()),expected.first_minute);
|
|
};
|
|
require(c.serve(request,std::move(h),live).empty()&&minute_seen&&c.revision==2&&
|
|
c.flow.desktop()->state().revision==2&&!c.flow.desktop()->pending(),
|
|
"fresh same-revision retry completes through actual controller with one outer revision publication");
|
|
require(fee?choosers==1&¬ices==1&&questions==0:questions==1&&choosers==0&¬ices==0,
|
|
"borrowed pending presenters run exactly on the intended Core branch");
|
|
same(snapshot(*c.session),expected.final);
|
|
const auto settled=snapshot(*c.session);
|
|
c.serve(request,{});same(snapshot(*c.session),settled);
|
|
require(c.revision==2,"consumed kickoff replay cannot repeat decision or simulation");
|
|
}
|
|
void missing_then_retry(const fs::path& data,const fs::path& input){
|
|
Context c(data,input);int marker=0;install_sentinels(c,&marker);
|
|
const auto before=snapshot(*c.session);const auto driver=c.session->manager_join_checkpoint().driver;
|
|
auto request=c.advance();require(c.serve(request).empty(),"absent borrowed presenter returns a controlled waiting rejection");
|
|
waiting(c,before,driver);restored(c,&marker);
|
|
// Same Source request is now retryable; a fresh UI request must be accepted.
|
|
successful_retry(c,false);restored(c,&marker);
|
|
}
|
|
void quoted_throw_then_retry(const fs::path& data,const fs::path& input){
|
|
Context c(data,input);int marker=0;install_sentinels(c,&marker);
|
|
// Controlled scalar transform of the genuine offered record, retaining rawbid0.
|
|
c.session->state().memory.set32(::bmh::layout::OfferSlots,c.session->state().memory.u32(::bmh::layout::OfferSlots)&0x7fffffffu);
|
|
const auto before=snapshot(*c.session);const auto driver=c.session->manager_join_checkpoint().driver;
|
|
auto request=c.advance();int calls=0;PendingOfferHooks h;
|
|
h.select_transfer=[&](const GameState&,const TransferOfferListView& v)->PendingOfferTransferChoice{
|
|
require(v.valid&&v.list_entry==40&&v.quoted_fee>0,"actual Core quote precedes throwing chooser");
|
|
++calls;guards(c,request,before);throw std::runtime_error("");
|
|
};
|
|
require(c.serve(request,std::move(h)).empty()&&calls==1,"empty-message presenter throw yields typed waiting with safe nonempty UI reason");
|
|
waiting(c,before,driver);restored(c,&marker);
|
|
successful_retry(c,true);restored(c,&marker);
|
|
}
|
|
void partial_sale_rollback(const fs::path& data,const fs::path& input){
|
|
Context c(data,input);int marker=0;install_sentinels(c,&marker);
|
|
auto& state=c.session->state();const int second=state.squad_slots.at(798)&0xfff;
|
|
require(second!=0xfff&&second!=14,"genuine native next squad row supplies second offered player");
|
|
const uint32_t from=::bmh::layout::EditorList+40*0x58,to=from+0x58;
|
|
for(uint32_t i=0;i<0x58;++i)state.memory.set8(to+i,state.memory.u8(from+i));
|
|
state.memory.set32(::bmh::layout::Weekly_PreMatchOffer_RuntimeField,0x80000000u|uint32_t(second)*1024);state.squad_slots.at(0xb70+41)=uint16_t(second);
|
|
const auto before=snapshot(*c.session);const auto driver=c.session->manager_join_checkpoint().driver;
|
|
auto request=c.advance();int calls=0;PendingOfferHooks h;
|
|
h.answer=[&](const GameState& staged,const PendingOfferQuestion& q){
|
|
++calls;guards(c,request,before);
|
|
if(q.raw_offer_slot==0)return PendingOfferAnswer::no;
|
|
require(q.raw_offer_slot==1&&staged.memory.u32(::bmh::layout::OfferSlots)==0xffffffffu&&save_stream(staged)!=before.native,
|
|
"first native forced sale really settled before unavailable second answer");
|
|
return PendingOfferAnswer::unsupported;
|
|
};
|
|
require(c.serve(request,std::move(h)).empty()&&calls==2,"incomplete later answer rejects whole previously settled batch");
|
|
waiting(c,before,driver);restored(c,&marker);
|
|
// A direct typed call with the restored unsupported sentinel proves RAII guards
|
|
// reset and the same native driver remains retryable, without a default NO.
|
|
auto retry=c.advance();std::string error;
|
|
c.session->set_pending_offer_entry_policy(app::PendingOfferEntryPolicy::normal_interactive);
|
|
auto result=c.session->dispatch_kickoff(retry.desk_action,c.revision,error);
|
|
require(result.kind==TurnDeskKind::WaitingAtDesk&&!error.empty(),"unclaimed driver accepts retry and explicitly waits for a real answer");
|
|
same(snapshot(*c.session),before);same_driver(c.session->manager_join_checkpoint().driver,driver);
|
|
}
|
|
}
|
|
int main(int argc,char** argv){try{
|
|
require(argc==3,"usage: pending_offer_desk_app_tests ORIGINAL_DATA QA_INPUT.FBM");
|
|
if(!*argv[1]){std::puts("pending offer desk app tests skipped: Original data not configured");return 77;}
|
|
missing_then_retry(argv[1],argv[2]);quoted_throw_then_retry(argv[1],argv[2]);partial_sale_rollback(argv[1],argv[2]);
|
|
std::puts("pending offer desk app tests: real Native controller load, waiting rollback/retry, staged oracle and hook restoration passed");return 0;
|
|
}catch(const std::exception& e){std::fprintf(stderr,"pending_offer_desk_app_tests: %s\n",e.what());return 1;}}
|