Files
Dreierpack-Manager/tests/balance_plan_app_tests.cpp
T
ClaudeandClaude 9870d90d65 Tests share one check helper; stale references in comments corrected
116 test files had their own identical copy of check(bool, const char*); they
use bmh::test_support::check from src/testing/check.hpp. Seven comments pointed
to documents that no longer exist or named a former author.

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-11 14:52:42 +01:00

230 lines
16 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include <filesystem>
#include <iostream>
#include <stdexcept>
#include <algorithm>
#include <memory>
#include <limits>
#include "app/controller.hpp"
#include "app/career_session.hpp"
#include "game/balance_plan.hpp"
#include "game/save.hpp"
#include "ui/balance_plan.hpp"
#include "testing/check.hpp"
using namespace bmh;
namespace fs=std::filesystem;
using bmh::test_support::check;
static void immediate_close(const fs::path& data,const fs::path& save){
app::CareerSession session(data,911,save);uint64_t revision=23;std::string error;
const int manager=session.state().memory.u8(::bmh::layout::ActiveManager);auto& records=session.state().manager_records;
const size_t account=size_t(manager)*0xb0c+0x314;
for(unsigned i=0;i<4;++i)records[account+i]=uint8_t(uint32_t(std::numeric_limits<int32_t>::min())>>(i*8));
auto checkpoint=session.balance_checkpoint();
const auto set_gate=[&](uint32_t address,uint8_t value){
if(checkpoint.state.memory.has(address))checkpoint.state.memory.set8(address,value);
else checkpoint.runtime[address]=value;
};
set_gate(::bmh::layout::CompactDialogFrame,0);set_gate(::bmh::layout::BalancePlan_BalanceFromGame_RuntimeField2,1);set_gate(::bmh::layout::BalancePlan_BalanceFromGame_RuntimeField,1);
session.restore_balance_checkpoint(std::move(checkpoint));
const Image underlay(320,240,0);
auto page=session.open_balance_plan({ui::DeskRequestKind::open_menu,manager,-1,28,-1,revision},
revision,underlay,error);
check(page.has_value(),error.empty()?"notice-skip entry succeeds":error.c_str());
const auto before=session.balance_checkpoint();auto expected=before.draft->state;
bmh::close_balance_plan(expected,page->draft);
auto result=session.dispatch_balance_plan({page->identity,ui::BalanceAction::close,-1,0},revision,error);
check(result&&result->closed&&!result->page.pending_close,"Source notice gate skips timed warning and commits immediately");
check(result->page.identity.revision==24&&result->page.identity.sequence==page->identity.sequence+1&&revision==24&&
save_stream(session.state())==save_stream(expected),"immediate close advances revision and owner sequence exactly once");
}
static void actual_controller(const fs::path& data){
ui::StartupFlow flow(data);flow.click(150,215);flow.click(5,225,true);flow.click(5,225,true);
auto start=flow.click(90,169);std::unique_ptr<app::CareerSession> session;uint64_t revision=0;
openbmh::audio::Playback audio;audio.set_muted(true);std::optional<uint64_t> audio_session;
auto serve=[&](const ui::FlowResult& request){return app::serve_flow_request(flow,request,session,data,data,
0x1789abcd,revision,audio,audio_session,false);};
check(serve(start).empty()&&session&&flow.desktop(),"real career reaches the accepted desk through controller");
const int manager=flow.desktop()->state().manager_slot;
auto& records=session->state().manager_records;const size_t account=size_t(manager)*0xb0c+0x314;
check(account+4<=records.size(),"career contains manager account record");
for(unsigned i=0;i<4;++i)records[account+i]=uint8_t(uint32_t(std::numeric_limits<int32_t>::min())>>(i*8));
auto menu=[&](){const auto& items=flow.desktop()->state().items;
const auto it=std::find_if(items.begin(),items.end(),[](const auto& item){return item.kind==28&&!item.disabled;});
check(it!=items.end(),"actual desk exposes Balance menu 28");
return flow.click(it->x+it->width/2,it->y+it->height/2);};
auto open=menu();check(open.request==ui::FlowRequest::desk_action,"menu 28 creates a pending desk action");
const auto before_open=session->balance_checkpoint();std::string error;
auto projected=session->open_balance_plan(open.desk_action,revision,flow.desktop()->render(),error);
check(projected.has_value(),error.empty()?"preflight opening for ACK rollback":error.c_str());
auto corrupt=*projected;corrupt.identity.scope=0;
bool rejected=false;try{flow.show_balance(std::move(corrupt),open.desk_action);}catch(const std::exception&){rejected=true;}
check(rejected,"malformed UI opening ACK is rejected");
session->restore_balance_checkpoint(before_open);
check(!session->balance_active()&&session->club_modal_runtime_checkpoint()==before_open.runtime&&
session->balance_checkpoint().next_scope==before_open.next_scope&&revision==open.desk_action.revision,
"failed opening ACK rolls back scope and a4856 runtime publication");
const auto retry_open_error=serve(open);
check(retry_open_error.empty()&&flow.in_balance(),retry_open_error.empty()?"same pending menu retries after opening ACK rollback":retry_open_error.c_str());
const auto accepted_native=save_stream(session->state());const auto accepted_runtime=session->club_modal_runtime_checkpoint();
ui::FlowResult foreign{};foreign.request=ui::FlowRequest::desk_action;
check(!serve(foreign).empty()&&flow.in_balance()&&session->balance_active()&&
save_stream(session->state())==accepted_native&&session->club_modal_runtime_checkpoint()==accepted_runtime,
"cross-family session requests are blocked while the Balance owner is open");
const auto G=session->game();const auto W=session->rand();const auto accepted_revision=revision;
auto page_id=flow.balance()->state().identity;
if(flow.balance()->state().draft.view==BalanceView::so_far){
flow.pointer_down(171,215);const auto make_editable=flow.click(171,215);
check(make_editable.request==ui::FlowRequest::balance_action&&serve(make_editable).empty(),
"read-only Balance view cycles through typed controller action");
}
page_id=flow.balance()->state().identity;
flow.pointer_down(5,40);
flow.pointer_down(105,81);
flow.move_action(155,95);
const auto moved=flow.click(155,95);
check(moved.request==ui::FlowRequest::none&&flow.balance()->state().calculator_x==150&&
flow.balance()->state().calculator_y==94&&save_stream(session->state())==accepted_native&&
session->game().seed()==G.seed()&&session->rand().seed()==W.seed(),
"calculator drag is local UI state and preserves Native/RNG");
flow.send_key("ESC");
flow.pointer_down(171,215);
const auto cycle=flow.hold(171,215,2000);
check(cycle.request==ui::FlowRequest::balance_action&&serve(cycle).empty(),"long-held Balance button releases through controller action");
check(save_stream(session->state())==accepted_native&&session->club_modal_runtime_checkpoint()==accepted_runtime&&
session->game().seed()==G.seed()&&session->game().calls()==G.calls()&&session->rand().seed()==W.seed()&&
session->rand().calls()==W.calls()&&revision==accepted_revision&&flow.balance()->state().identity.sequence==page_id.sequence+1&&
flow.balance()->state().calculator_x==150&&flow.balance()->state().calculator_y==94,
"actual controller preview changes only the owner sequence and retains dragged calculator position");
auto close=flow.pointer_down(0,0,true);
check(close.request==ui::FlowRequest::balance_action&&serve(close).empty(),"actual close enters controller path");
check(flow.in_balance()&&flow.balance()->state().pending_close&&save_stream(session->state())==accepted_native&&
session->club_modal_runtime_checkpoint()==accepted_runtime&&revision==accepted_revision,
"timed warning holds live Native/runtime/revision until confirmation");
auto dismiss=flow.pointer_down(1,1);
check(dismiss.request==ui::FlowRequest::balance_action,"left press produces typed warning confirmation");
const auto close_checkpoint=session->balance_checkpoint();const auto close_revision=revision;
auto committed=session->dispatch_balance_plan(dismiss.balance_action,revision,error);
check(committed&&committed->closed,"staged warning confirmation commits Core close");
auto malformed=*committed;malformed.page.identity.sequence++;
rejected=false;try{flow.close_balance(std::move(malformed.page),std::move(malformed.preparation));}
catch(const std::exception&){rejected=true;}
check(rejected,"malformed post-commit close ACK is rejected");
session->restore_balance_checkpoint(close_checkpoint);revision=close_revision;
flow.reject_balance("simulated close projection acknowledgement fault");
check(flow.in_balance()&&flow.balance()->state().pending_close&&save_stream(session->state())==accepted_native&&
session->club_modal_runtime_checkpoint()==accepted_runtime&&revision==accepted_revision,
"post-commit ACK failure restores Native/runtime/revision and retains warning for retry");
auto retry=flow.pointer_down(1,1);
check(retry.request==ui::FlowRequest::balance_action&&serve(retry).empty()&&!flow.in_balance()&&revision==accepted_revision+1,
"retained warning retries and commits exactly once");
const auto orphan_release=flow.click(1,1);
check(orphan_release.request==ui::FlowRequest::none,"warning dismissal mouse-up cannot leak into parent desk");
}
static bool same_draft(const BalancePlanDraft& a,const BalancePlanDraft& b){
return a.manager==b.manager&&a.view==b.view&&a.rows==b.rows&&a.adjustments==b.adjustments&&
a.refresh==b.refresh&&a.months_left==b.months_left&&a.days_left==b.days_left&&
a.depreciation==b.depreciation&&a.total==b.total;
}
int main(int argc,char** argv){
try{
if(argc<3)throw std::runtime_error("usage: balance_plan_app_tests DATA SAVE");
const fs::path data=argv[1],save=argv[2];
immediate_close(data,save);
actual_controller(data);
app::CareerSession session(data,731,save);uint64_t revision=17;std::string error;
const auto& live=session.state();
const int manager=live.memory.u8(::bmh::layout::ActiveManager);
auto& manager_records=session.state().manager_records;
const size_t account_at=size_t(manager)*0xb0c+0x314;
check(account_at+4<=manager_records.size(),"fixture has a complete Source manager account record");
const uint32_t forced_balance=uint32_t(std::numeric_limits<int32_t>::min());
for(unsigned i=0;i<4;++i)manager_records[account_at+i]=uint8_t(forced_balance>>(i*8));
const ui::DeskRequest entry{ui::DeskRequestKind::open_menu,manager,-1,28,-1,revision};
const Image underlay(320,240,0x1a);
const auto native=save_stream(live);const auto runtime=session.club_modal_runtime_checkpoint();
const auto G=session.game();const auto W=session.rand();
auto page=session.open_balance_plan(entry,revision,underlay,error);
check(bool(page),error.empty()?"actual menu 28 owner opens":error.c_str());
check(page->underlay.pixels==underlay.pixels&&page->identity.manager_slot==manager&&
page->identity.revision==revision&&page->identity.sequence==0&&page->identity.scope>0,
"opening binds the exact request, captured underlay and scoped sequence");
check(same_draft(page->draft,bmh::open_balance_plan(live,manager)),"SDL projection is the Core preview");
const int32_t initial_price=page->draft.rows[kBalanceTicketPrice];
auto accepted_runtime=runtime;
if(!live.memory.has(::bmh::layout::PlanTicketPrice+uint32_t(manager)))
accepted_runtime[::bmh::layout::PlanTicketPrice+uint32_t(manager)]=uint8_t(page->draft.rows[kBalanceTicketPrice]);
check(session.club_modal_runtime_checkpoint()==accepted_runtime,
"accepted open publishes the a4856 fallback to live runtime only");
check(session.balance_checkpoint().draft->original_runtime==accepted_runtime,
"stale-owner guard snapshots the accepted runtime cache after open");
auto stable=[&]{return save_stream(session.state())==native&&session.club_modal_runtime_checkpoint()==accepted_runtime&&
session.game().seed()==G.seed()&&session.game().calls()==G.calls()&&session.rand().seed()==W.seed()&&
session.rand().calls()==W.calls()&&revision==17;};
check(stable(),"opening leaves Native/RNG/runtime/revision unchanged");
const auto open_id=page->identity;
const auto expected_view=BalanceView((int(page->draft.view)+1)%3);
auto first=session.dispatch_balance_plan({open_id,ui::BalanceAction::cycle_view,-1,0},revision,error);
check(first&&!first->closed&&first->page.identity.sequence==1&&first->page.identity.revision==revision&&
first->page.draft.view==expected_view&&stable(),"view cycle stays staged and increments only owner sequence");
page=first->page;
check(!session.dispatch_balance_plan({open_id,ui::BalanceAction::take_actuals,-1,0},revision,error)&&stable(),
"replayed request is rejected without changing live state");
check(!session.open_balance_plan(entry,revision,underlay,error)&&stable(),
"nested Balance opening is rejected while the accepted owner holds the session");
const int32_t maximum=balance_row_maximum(page->draft,0);
check(maximum>0,"fixture exposes an editable balance row");
const auto edit_request=ui::BalanceRequest{page->identity,ui::BalanceAction::edit_row,0,maximum/2};
auto edited=session.dispatch_balance_plan(edit_request,revision,error);
check(edited&&!edited->closed&&edited->page.identity.sequence==2&&stable(),
"accepted numeric edit changes the staged Core draft only");
page=edited->page;
const int32_t ticket_price=initial_price==25?12:25;
auto ticket=session.dispatch_balance_plan({page->identity,ui::BalanceAction::edit_row,
kBalanceTicketPrice,ticket_price},revision,error);
check(ticket&&!ticket->closed&&ticket->page.draft.rows[kBalanceTicketPrice]==ticket_price&&stable(),
"ticket price is edited in the staged Source draft");
page=ticket->page;
auto close=session.balance_checkpoint();
auto expected=close.draft->state;
bmh::close_balance_plan(expected,page->draft);
auto closed=session.dispatch_balance_plan({page->identity,ui::BalanceAction::close,-1,0},revision,error);
check(bool(closed),error.empty()?"close action accepted":error.c_str());
check(!closed->closed&&closed->page.pending_close,
"forced low balance enters the Source timed warning phase before Native publication");
if(!closed->closed){
check(closed->page.pending_close&&stable(),"DFB warning keeps the once-closed Native state staged");
const auto pending_warning=session.balance_checkpoint();
check(!session.dispatch_balance_plan({closed->page.identity,ui::BalanceAction::confirm_close,0,0},revision,error),
"malformed DFB confirmation is rejected");
session.restore_balance_checkpoint(pending_warning);
check(stable()&&session.balance_checkpoint().draft->page.pending_close,
"malformed warning confirmation leaves the original warning retryable");
auto confirmed=session.dispatch_balance_plan({closed->page.identity,ui::BalanceAction::confirm_close,-1,0},revision,error);
check(confirmed&&confirmed->closed,"timed warning confirmation publishes the staged close");
closed=std::move(confirmed);
}
check(revision==18&&save_stream(session.state())==save_stream(expected),
"close publishes the exact Core write set once and advances revision once");
check(!session.balance_active(),"closed Balance owner releases its scope");
if(!session.state().memory.has(::bmh::layout::PlanTicketPrice+uint32_t(manager))){
const auto runtime_after=session.club_modal_runtime_checkpoint();
check(runtime_after.at(::bmh::layout::PlanTicketPrice+uint32_t(manager))==uint8_t(ticket_price),
"format field ticket cache remains in checkpointed runtime, outside serialized Native");
const ui::DeskRequest reopen{ui::DeskRequestKind::open_menu,manager,-1,28,-1,revision};
auto again=session.open_balance_plan(reopen,revision,underlay,error);
check(again&&again->draft.rows[kBalanceTicketPrice]==ticket_price,
"same-process reopen uses the staged runtime ticket cache");
}
app::CareerSession fresh(data,731,save);const auto fresh_native=save_stream(fresh.state());
const auto fresh_manager=fresh.state().memory.u8(::bmh::layout::ActiveManager);
auto fresh_page=fresh.open_balance_plan({ui::DeskRequestKind::open_menu,int(fresh_manager),-1,28,-1,revision},
revision,underlay,error);
check(fresh_page&&fresh_page->draft.rows[kBalanceTicketPrice]==initial_price&&save_stream(fresh.state())==fresh_native,
"fresh session falls back to the saved manager ticket price and leaves Native unchanged");
std::cout<<"balance app owner, staged preview, replay rejection and close write set passed\n";
return 0;
}catch(const std::exception& e){std::cerr<<e.what()<<'\n';return 1;}
}