// SPDX-License-Identifier: GPL-3.0-only #include "formats/executable_layout.hpp" #include #include #include #include #include #include "app/career_session.hpp" #include "game/save.hpp" #include "formats/le.hpp" #include "ui/league_family_request.hpp" #include "ui/league_table.hpp" #include "testing/check.hpp" using namespace bmh; namespace fs = std::filesystem; namespace { using bmh::test_support::check; struct Fixture { app::CareerSession session; uint64_t revision = 1; ui::StrengthsIdentity id; app::CareerSession::LeagueTableDispatch page; Fixture(const fs::path& data, const fs::path& save, bool raw_round_0x80=false) : session(data, 0x3710u, save) { if(raw_round_0x80) session.state().league_rounds.at(2)=0x80; std::string error; const auto source = session.strengths_open_request(revision); check(bool(source), "loaded WEEK196 has a live manager identity"); id = source->identity; check(id.manager == 0 && id.runtime_club == 45 && id.league == 2 && id.day_counter == session.state().date && id.club_identity == int(session.state().club_ids.at(45)), "family identity is checked against the actual WEEK196 manager, club, league and date"); check(session.prepare_league_family_child(id, 1, revision, error), "Source Table entry prepares its selector context"); const auto begun = session.begin_league_family(id, 1, revision, error); check(bool(begun), "validated Table family opens"); id = *begun; const auto current = session.current_league_table_dispatch(error); check(bool(current), "active Table family has a source-owned page"); page = *current; } ui::LeagueFamilyRequest control(int n) const { ui::LeagueFamilyRequest r; r.identity=id; r.kind=ui::LeagueFamilyRequestKind::control; r.from_child=1; r.control_index=n; return r; } void ack(const app::CareerSession::LeagueTableDispatch& p) { page=p; id=p.identity; } }; void ten_controls(const fs::path& data, const fs::path& save) { for (int n=0;n<10;++n) { Fixture f(data,save); const auto g=f.session.game(); const auto w=f.session.rand(); const auto native=save_stream(f.session.state()); const auto runtime=f.session.club_modal_runtime_checkpoint(); std::string error; const auto pre=f.session.current_league_table_dispatch(error); check(bool(pre), "ready Table projection exists before a control"); const uint16_t old=pre->identity.expected_family_word; auto result=f.session.dispatch_league_table_control(f.control(n),f.revision,error); check(bool(result)&&error.empty()&&f.revision==2, "each Source button 0..9 consumes one bound request"); check(f.session.state().date==f.id.day_counter && f.session.state().club_ids.at(size_t(f.id.runtime_club))==f.id.club_identity, "controls retain fixture date and manager-club identity"); check(f.session.rand().seed()==w.seed()&&f.session.rand().calls()==w.calls(), "Table controls do not consume Watcom RNG"); const uint16_t actual=result->identity.expected_family_word; if(n==3) { check(result->phase==app::CareerSession::TableDispatchPhase::forecast_pending_present && result->page.forecast && save_stream(f.session.state())==native && f.session.club_modal_runtime_checkpoint()==runtime && f.session.game().seed()==g.seed()&&f.session.game().calls()==g.calls(), "control 3 stages forecast and G until its bound frame-Present ACK"); uint16_t source_display=uint16_t(old&0xff7fu); source_display=uint16_t((source_display|0x0008u)&0x0f7fu); source_display=uint16_t((source_display&0x0cf7u)+0x0108u); check(actual==old && result->page.display_word==source_display, "KI keeps its live owner word unchanged until Present and draws its independent source display word"); } else if(n==9) { check(result->phase==app::CareerSession::TableDispatchPhase::range_start&&result->dialog&& result->dialog->title_textd_address==::bmh::layout::CareerSession_CurrentLeagueTableDispatch_ExecutableField, "control 9 starts the Source start-round dialog"); } else { check(result->phase==app::CareerSession::TableDispatchPhase::ready, "ordinary controls return to the ready phase"); const bool normal=(result->page.source_normal_mode!=0); uint16_t expected=old; if(n<=2) expected=uint16_t((old&0x0ff0u)|uint16_t(1u<page.source_controls_projection, "projection advertises the active Source controls"); if(n<=2) check(result->page.source_aggregation_flags==(n==0?7:n==1?1:2), "controls 0–2 select their independently specified aggregation flags"); check(f.session.game().seed()==g.seed()&&f.session.game().calls()==g.calls(), "non-forecast controls preserve the live G stream"); } } } void ranges(const fs::path& data,const fs::path& save) { Fixture f(data,save); const auto base=f.session.league_family_checkpoint(); std::string error; auto start=f.session.dispatch_league_table_control(f.control(9),f.revision,error); check(bool(start)&&start->phase==app::CareerSession::TableDispatchPhase::range_start,"start dialog phase is active"); const auto after_control9=f.session.league_family_checkpoint(); auto reply=[&](const app::CareerSession::LeagueTableDispatch& p,ui::TableDialogStage stage, ui::TableDialogOutcome outcome,int value,int x=140,int y=80) { ui::LeagueFamilyRequest r; r.identity=p.identity;r.kind=ui::LeagueFamilyRequestKind::table_range_result; r.from_child=1;r.control_index=9;r.table_dialog_reply=ui::TableDialogReply{stage,outcome,value,x,y}; return f.session.dispatch_league_table_range_reply(r,f.revision,error); }; check(!reply(*start,ui::TableDialogStage::end,ui::TableDialogOutcome::accept,1), "wrong-stage end reply cannot satisfy the first modal"); auto canceled_first=reply(*start,ui::TableDialogStage::start,ui::TableDialogOutcome::cancel,0,143,86); check(bool(canceled_first)&&canceled_first->phase==app::CareerSession::TableDispatchPhase::ready && save_stream(f.session.state())==save_stream(after_control9.state) && f.session.club_modal_runtime_checkpoint()==after_control9.runtime && f.session.game().seed()==after_control9.game.seed()&&f.session.game().calls()==after_control9.game.calls()&& f.session.rand().seed()==after_control9.rand.seed()&&f.session.rand().calls()==after_control9.rand.calls(), "cancel-first exits cleanly without half-range, Native, or RNG effects"); f.ack(*canceled_first); auto again=f.session.dispatch_league_table_control(f.control(9),f.revision,error); auto accepted_start=reply(*again,ui::TableDialogStage::start,ui::TableDialogOutcome::accept,1,151,92); check(bool(accepted_start)&&accepted_start->phase==app::CareerSession::TableDispatchPhase::range_end&& accepted_start->dialog&&accepted_start->dialog->minimum==1&& accepted_start->dialog->x==151&&accepted_start->dialog->y==92, "accepted start opens distinct end stage with carried modal position and legal minimum"); auto wrong_shape=f.control(9);wrong_shape.identity=accepted_start->identity; wrong_shape.kind=ui::LeagueFamilyRequestKind::table_range_result; wrong_shape.table_dialog_reply=ui::TableDialogReply{ui::TableDialogStage::end, static_cast(99),0,151,92}; check(!f.session.dispatch_league_table_range_reply(wrong_shape,f.revision,error), "current end-stage owner rejects an invalid typed outcome instead of passing on a stale token"); const auto before_second_cancel=f.session.league_family_checkpoint().family->table.value(); auto canceled_second=reply(*accepted_start,ui::TableDialogStage::end,ui::TableDialogOutcome::cancel,0,151,92); const auto after_second_cancel=f.session.league_family_checkpoint().family->table.value(); check(bool(canceled_second)&&canceled_second->phase==app::CareerSession::TableDispatchPhase::ready&& after_second_cancel.first_round==before_second_cancel.previous_start_round&& after_second_cancel.end_round==before_second_cancel.previous_end_round&& after_second_cancel.retained_range_label_source_bytes==before_second_cancel.retained_range_label_source_bytes, "second cancel restores the prior endpoints and exact previously retained label, while leaving Source custom-mode effects distinct"); f.ack(*canceled_second); auto equal=f.session.dispatch_league_table_control(f.control(9),f.revision,error); auto one=reply(*equal,ui::TableDialogStage::start,ui::TableDialogOutcome::accept,1); auto same=reply(*one,ui::TableDialogStage::end,ui::TableDialogOutcome::accept,1); check(bool(same)&&same->phase==app::CareerSession::TableDispatchPhase::ready&& same->page.retained_range_label_source_bytes.size()>0&& f.session.league_family_checkpoint().family->table->first_round==0&& f.session.league_family_checkpoint().family->table->end_round==1, "equal start/end normalizes to the literal one-round Source range and carries its label"); } void forecast_range_preserves_visible_and_scratch(const fs::path& data,const fs::path& save) { Fixture f(data,save);std::string error; auto staged=f.session.dispatch_league_table_control(f.control(3),f.revision,error); check(bool(staged)&&staged->page.forecast,"KI fixture reaches the staged forecast page"); ui::LeagueFamilyRequest present;present.identity=staged->identity; present.kind=ui::LeagueFamilyRequestKind::table_forecast_presented;present.from_child=1;present.control_index=3; auto accepted=f.session.acknowledge_league_forecast_present(present,f.revision,error); check(bool(accepted)&&accepted->page.forecast,"Present ACK retains the visible forecast projection"); f.ack(*accepted); const auto accepted_owner=f.session.league_family_checkpoint().family->table.value(); auto dialog=f.session.dispatch_league_table_control(f.control(9),f.revision,error); check(bool(dialog)&&dialog->phase==app::CareerSession::TableDispatchPhase::range_start&& dialog->page==*accepted_owner.forecast_page&& f.session.league_family_checkpoint().family->table->page==accepted_owner.page&& f.session.league_family_checkpoint().family->table->forecast_page==accepted_owner.forecast_page, "opening KB6 preserves both the accepted visible forecast and normal scratch table"); auto reply=[&](const app::CareerSession::LeagueTableDispatch& p,ui::TableDialogStage stage, ui::TableDialogOutcome outcome,int value) { ui::LeagueFamilyRequest r;r.identity=p.identity;r.kind=ui::LeagueFamilyRequestKind::table_range_result; r.from_child=1;r.control_index=9;r.table_dialog_reply=ui::TableDialogReply{stage,outcome,value,140,80}; return f.session.dispatch_league_table_range_reply(r,f.revision,error); }; auto second=reply(*dialog,ui::TableDialogStage::start,ui::TableDialogOutcome::accept,1); check(bool(second)&&second->phase==app::CareerSession::TableDispatchPhase::range_end&& second->page==*accepted_owner.forecast_page&& f.session.league_family_checkpoint().family->table->page==accepted_owner.page&& f.session.league_family_checkpoint().family->table->forecast_page==accepted_owner.forecast_page, "accepted first modal keeps the original forecast backdrop and scratch through KB6 call two"); auto ready=reply(*second,ui::TableDialogStage::end,ui::TableDialogOutcome::cancel,0); check(bool(ready)&&ready->phase==app::CareerSession::TableDispatchPhase::ready&&!ready->page.forecast&& !f.session.league_family_checkpoint().family->table->forecast_page&& f.session.league_family_checkpoint().family->table->page==ready->page, "returning ready redraws normal Source scratch and clears the transient forecast"); } void team_info_uses_visible_identity_and_normal_rank(const fs::path& data,const fs::path& save) { Fixture f(data,save);std::string error; auto staged=f.session.dispatch_league_table_control(f.control(3),f.revision,error); ui::LeagueFamilyRequest present;present.identity=staged->identity; present.kind=ui::LeagueFamilyRequestKind::table_forecast_presented;present.from_child=1;present.control_index=3; auto forecast=f.session.acknowledge_league_forecast_present(present,f.revision,error); check(bool(forecast)&&forecast->page.forecast,"TeamInfo fixture has a presented KI table");f.ack(*forecast); const auto before=f.session.league_family_checkpoint(); const auto visible=before.family->table->forecast_page.value(); const auto normal=before.family->table->page; check(!visible.rows.empty()&&!normal.rows.empty(),"visible and normal rank rows are populated"); size_t clicked=visible.rows.size(); for(size_t i=0;itable&&after.family->table->phase==app::CareerSession::TableDispatchPhase::ready&& !after.family->table->forecast_page&&after.family->table->page.rows.size()==normal.rows.size()&& after.family->table->display_word_override==refreshed->expected_family_word, "TeamInfo LAB return installs the normalized ready page and clears the consumed forecast view"); } void control_four_then_domestic_map_preserves_source_locals(const fs::path& data,const fs::path& save) { Fixture f(data,save);std::string error; auto filter=f.session.dispatch_league_table_control(f.control(4),f.revision,error); check(bool(filter)&&filter->phase==app::CareerSession::TableDispatchPhase::ready, "Control4 produces a ready Source table before a domestic map change"); f.ack(*filter); auto filter_word=filter->identity.expected_family_word; if(filter_word&0x10u) { filter=f.session.dispatch_league_table_control(f.control(4),f.revision,error); check(bool(filter)&&filter->phase==app::CareerSession::TableDispatchPhase::ready, "Control4 can turn the Source suppression bit back off"); f.ack(*filter);filter_word=filter->identity.expected_family_word; } check((filter_word&0x10u)==0, "fixture reaches the explicit Source suppression-0x10-off selector state"); const auto before=f.session.league_family_checkpoint(); const auto retained=before.family->table.value(); const uint8_t selected_mode=load_le(data/"BMH.exe").u8(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField+3); const uint16_t common=uint16_t((filter_word&0x0f7fu)|(selected_mode?0x80u:0u)); const uint16_t redraw=uint16_t(common&0xff7fu); ui::LeagueFamilyRequest map;map.identity=f.id;map.kind=ui::LeagueFamilyRequestKind::select_league; map.from_child=1;map.league_id=3; check(f.session.select_league_family_page(map,f.revision,error), "league2-to-league3 domestic map click is accepted"); const auto dispatch=f.session.current_league_table_dispatch(error); const auto after=f.session.league_family_checkpoint(); check(bool(dispatch)&&dispatch->identity.league==3&&dispatch->identity.league_group==f.id.league_group, "domestic map changes league while preserving Source group"); check(after.family->table->aggregation_flags==retained.aggregation_flags&& after.family->table->first_round==retained.first_round&& after.family->table->end_round==retained.end_round&& after.family->table->retained_range_label_source_bytes==retained.retained_range_label_source_bytes, "outer Table redraw retains Control4 aggregation, round range and exact Source range-label bytes"); check((dispatch->identity.expected_family_word&0x10u)==0&& dispatch->identity.expected_family_word==redraw&& dispatch->page.display_word==redraw&& dispatch->page.source_aggregation_flags==retained.aggregation_flags, "map applies exact common-event then outer-redraw word masks and preserves suppression-0x10-off"); check(after.state.date==before.state.date&&after.runtime.at(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField)==selected_mode&& after.game.seed()==before.game.seed()&&after.game.calls()==before.game.calls()&& after.rand.seed()==before.rand.seed()&&after.rand.calls()==before.rand.calls(), "different domestic map causes no calendar or RNG mutation"); } void selector_and_no_lab_range(const fs::path& data,const fs::path& save) { Fixture f(data,save); const auto original_club=f.id.runtime_club; const auto original_default=f.id.manager_default_league; std::string error; auto rejected_selector=[&](ui::LeagueFamilyRequest request) { const auto before=f.session.league_family_checkpoint();const auto old_revision=f.revision; check(!f.session.select_league_family_page(request,f.revision,error), "forged map/group selector is rejected"); const auto after=f.session.league_family_checkpoint(); check(f.revision==old_revision&&save_stream(after.state)==save_stream(before.state)&& after.runtime==before.runtime&&after.family==before.family&& after.game.seed()==before.game.seed()&&after.game.calls()==before.game.calls()&& after.rand.seed()==before.rand.seed()&&after.rand.calls()==before.rand.calls(), "bad map/group target, group, or sequence rolls back the complete owned checkpoint"); }; ui::LeagueFamilyRequest invalid;invalid.identity=f.id;invalid.kind=ui::LeagueFamilyRequestKind::select_league; invalid.from_child=1;invalid.league_id=5;rejected_selector(invalid); // foreign map row is not in group 0. invalid.identity=f.id;invalid.kind=ui::LeagueFamilyRequestKind::toggle_league_group; invalid.from_child=1;invalid.league_id=6;rejected_selector(invalid); // not EXE's group-1 target. invalid.identity=f.id;invalid.identity.league_group=1;invalid.league_id=5;rejected_selector(invalid); invalid.identity=f.id;invalid.identity.family_sequence++;invalid.league_id=5;rejected_selector(invalid); invalid.identity=f.id;invalid.kind=static_cast(255); invalid.league_id=2;rejected_selector(invalid); invalid.identity=f.id;invalid.kind=ui::LeagueFamilyRequestKind::select_league; invalid.league_id=2;invalid.control_index=0;rejected_selector(invalid); // selector cannot carry a Table control. invalid.control_index=-1;invalid.table_dialog_reply=ui::TableDialogReply{};rejected_selector(invalid); const auto selector_baseline=f.session.league_family_checkpoint(); auto unavailable=selector_baseline; check(unavailable.state.memory.has(::bmh::layout::CalendarState_FormatError_RuntimeField2),"WEEK196 exposes the Source group availability byte"); unavailable.state.memory.set8(::bmh::layout::CalendarState_FormatError_RuntimeField2,1); unavailable.family->native=save_stream(unavailable.state); f.session.restore_league_family_checkpoint(std::move(unavailable)); invalid={};invalid.identity=f.id;invalid.kind=ui::LeagueFamilyRequestKind::toggle_league_group; invalid.from_child=1;invalid.league_id=5;rejected_selector(invalid); f.session.restore_league_family_checkpoint(selector_baseline); auto select=[&](ui::LeagueFamilyRequestKind kind,int league) { ui::LeagueFamilyRequest request;request.identity=f.id;request.kind=kind; request.from_child=1;request.league_id=league; check(f.session.select_league_family_page(request,f.revision,error), "bound Table map/group selector is accepted"); auto result=f.session.current_league_table_dispatch(error); check(bool(result),"accepted selector exposes the authoritative Table page"); f.ack(*result);return *result; }; // WEEK196 is Source group 0. Its map click to 3 changes league but must // keep the independently owned group. The Source group button targets 5. auto mapped=select(ui::LeagueFamilyRequestKind::select_league,3); check(mapped.identity.league==3&&mapped.identity.league_group==0&& mapped.identity.runtime_club==original_club&&mapped.identity.manager_default_league==original_default&& f.session.club_modal_runtime_checkpoint().at(::bmh::layout::CareerSession_BeginFriendlyOpponentTable_RuntimeField2)==3&& f.session.club_modal_runtime_checkpoint().at(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField)==0, "map click changes only the selected league and preserves Source group/manager identity"); const auto same_page=mapped.page;const auto prior_identity=mapped.identity; const uint16_t prior_word=f.session.state().memory.u16(::bmh::layout::LeagueTableDisplayModes+uint32_t(f.id.manager)*2); auto same_map=select(ui::LeagueFamilyRequestKind::select_league,3); check(same_map.identity.league==3&&same_map.identity.league_group==0&& same_map.page==same_page&&same_map.identity.family_sequence==prior_identity.family_sequence+1&& f.session.state().memory.u16(::bmh::layout::LeagueTableDisplayModes+uint32_t(f.id.manager)*2)== uint16_t((prior_word&0x0f7f)|((f.session.club_modal_runtime_checkpoint().at(::bmh::layout::CareerSession_AdvanceLeagueFamily_ExecutableField)!=0)?0x80:0)), "same-league map consumes one owner token and Source event mask while retaining the full body"); auto toggled=select(ui::LeagueFamilyRequestKind::toggle_league_group,5); check(toggled.identity.league==5&&toggled.identity.league_group==1&& f.session.club_modal_runtime_checkpoint().at(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField)==1, "group button uses explicit Source XOR target instead of deriving group from league selection"); auto mapped_group1=select(ui::LeagueFamilyRequestKind::select_league,6); check(mapped_group1.identity.league==6&&mapped_group1.identity.league_group==1&& f.session.club_modal_runtime_checkpoint().at(::bmh::layout::CareerSession_AdvertisingSessionUnchanged_ExecutableField)==1, "a foreign-map click to league6 preserves the independently bound group1"); const auto group1_page=mapped_group1.page; auto toggled_back=select(ui::LeagueFamilyRequestKind::toggle_league_group,original_default); check(toggled_back.identity.league==original_default&&toggled_back.identity.league_group==0&& toggled_back.page.league_id==original_default&& toggled_back.page!=group1_page, "changed-target toggle returns to manager default and rebuilds only the selected league body"); f.ack(toggled_back); auto foreign_default_group1=select(ui::LeagueFamilyRequestKind::toggle_league_group,5); check(foreign_default_group1.identity.league==5&&foreign_default_group1.identity.league_group==1, "fixture reaches the audited foreign group before the controlled default case"); // Explicit controlled-domain case only: the Source owner accepts manager // defaults 5..8 even though ordinary career creation does not produce them. auto controlled=f.session.league_family_checkpoint(); const size_t manager_record=size_t(f.id.manager)*0xb0c; controlled.state.manager_records[manager_record+0x210]=5; controlled.family->identity.manager_default_league=5; controlled.family->native=save_stream(controlled.state); f.session.restore_league_family_checkpoint(std::move(controlled)); f.id=f.session.league_family_owner()->identity; auto controlled_page=f.session.current_league_table_dispatch(error); check(bool(controlled_page),"controlled foreign-default owner remains internally consistent"); f.ack(*controlled_page); const auto retained_group1=controlled_page->page; auto same_target_toggle=select(ui::LeagueFamilyRequestKind::toggle_league_group,5); check(same_target_toggle.identity.league==5&&same_target_toggle.identity.league_group==0&& same_target_toggle.page==retained_group1, "same-target group toggle preserves the Table body when group0 manager default is league5"); f.ack(same_target_toggle); auto same_target_back=select(ui::LeagueFamilyRequestKind::toggle_league_group,5); check(same_target_back.identity.league==5&&same_target_back.identity.league_group==1&& same_target_back.page==retained_group1, "group1 base toggle back to the same league also retains its body"); f.ack(same_target_back); auto staged=f.session.dispatch_league_table_control(f.control(3),f.revision,error); check(bool(staged)&&staged->phase==app::CareerSession::TableDispatchPhase::forecast_pending_present, "forecast can be staged before a same-league map event"); ui::LeagueFamilyRequest presented;presented.identity=staged->identity; presented.kind=ui::LeagueFamilyRequestKind::table_forecast_presented;presented.from_child=1; presented.control_index=3; auto accepted=f.session.acknowledge_league_forecast_present(presented,f.revision,error); check(bool(accepted)&&accepted->page.forecast,"forecast is visible after its bound Present ACK");f.ack(*accepted); const auto accepted_forecast=accepted->page; auto same_after_forecast=select(ui::LeagueFamilyRequestKind::select_league,5); const auto retained=f.session.league_family_checkpoint().family->table.value(); check(same_after_forecast.page==accepted_forecast&&retained.forecast_page&& *retained.forecast_page==accepted_forecast, "same-league map consumes its event while preserving exact accepted forecast pixels/body"); f.ack(same_after_forecast); const auto before_full=f.session.league_family_checkpoint().family->table.value(); auto full=f.session.dispatch_league_table_control(f.control(8),f.revision,error); const auto after_full=f.session.league_family_checkpoint().family->table.value(); check(bool(full)&&after_full.first_round==0&&after_full.end_round==league_matchdays(f.id.league)&& after_full.retained_range_label_source_bytes==before_full.retained_range_label_source_bytes, "Control8 sets all games without LAB and retains exact prior label bytes"); } void table_group_toggle_is_typed_and_non_optimistic(const fs::path& data,const fs::path& save) { Fixture f(data,save); auto tables=ui::league_tables_from_game(f.session.state(),f.id.manager); auto screen=ui::LeagueTableScreen(data,std::move(tables),f.id.league, ui::LeagueTableScreen::FamilyMode{f.id}); bool emitted=false; for(int y=176;y<=216&&!emitted;++y)for(int x=262;x<=317&&!emitted;++x) { if(!screen.pointer_down(x,y))continue; const auto& pending=screen.pending_family_action(); check(bool(pending),"group selector DOWN creates its typed request"); const uint8_t next_group=uint8_t(f.id.league_group^1u); const auto exe=load_le(data/"BMH.exe"); const int expected=next_group?int(exe.u8(::bmh::layout::CareerSession_FormatError_RuntimeField4)):f.id.manager_default_league; check(pending->kind==ui::LeagueFamilyRequestKind::toggle_league_group&& pending->identity==f.id&&pending->from_child==1&&pending->league_id==expected, "group selector carries operation plus UI-computed expected target bound to old owner"); check(screen.selected_league()==f.id.league&&f.id.league_group!=next_group, "group request does not optimistically change the owned screen identity"); emitted=true; } check(emitted,"Source map exposes a physical group-selector hit pixel"); } void invalid_identity_and_close(const fs::path& data,const fs::path& save) { Fixture f(data,save); const auto base=f.session.league_family_checkpoint(); auto rejected_without_change=[&](ui::LeagueFamilyRequest r,uint64_t rev) { const auto before=f.session.league_family_checkpoint(); std::string error; const auto result=f.session.dispatch_league_table_control(r,rev,error); const auto after=f.session.league_family_checkpoint(); check(!result&&save_stream(after.state)==save_stream(before.state)&&after.runtime==before.runtime&& after.family==before.family&&after.game.seed()==before.game.seed()&&after.game.calls()==before.game.calls()&& after.rand.seed()==before.rand.seed()&&after.rand.calls()==before.rand.calls(), "invalid identity or revision is rejected without mutating current checkpoint"); }; auto r=f.control(0);r.identity.day_counter++; rejected_without_change(r,f.revision); r=f.control(0);r.identity.club_identity++; rejected_without_change(r,f.revision); r=f.control(0);r.identity.manager++; rejected_without_change(r,f.revision); r=f.control(0);rejected_without_change(r,f.revision+1); const auto original=f.session.state();f.session.state().date++; r=f.control(0);rejected_without_change(r,f.revision); f.session.state()=original; ui::LeagueFamilyRequest close;close.identity=f.id;close.kind=ui::LeagueFamilyRequestKind::close; close.from_child=1;close.target_child=0; const auto w=f.session.rand();const auto g=f.session.game(); const uint32_t ws=w.seed()*0x41c64e6du+0x3039u; const uint32_t count=(((ws>>16)&32767u)*201u/32768u)+100u; int32_t gs=g.seed(); for(uint32_t i=0;iphase==app::CareerSession::TableDispatchPhase::forecast_pending_present, "first KI click enters staged-present phase"); auto present=[&](const ui::StrengthsIdentity& id) {ui::LeagueFamilyRequest r;r.identity=id; r.kind=ui::LeagueFamilyRequestKind::table_forecast_presented;r.from_child=1;r.control_index=3; return f.session.acknowledge_league_forecast_present(r,f.revision,error);}; auto wrong=staged->identity;wrong.family_sequence++; check(!present(wrong)&&save_stream(f.session.state())==native&&f.session.game().calls()==G.calls(), "wrong/stale Present token cannot commit staged G"); check(save_stream(f.session.state())==native&&f.session.club_modal_runtime_checkpoint()==runtime&& f.session.rand().seed()==W.seed()&&f.session.rand().calls()==W.calls()&& f.session.game().seed()==G.seed()&&f.session.game().calls()==G.calls(), "before actual-frame ACK every live Native/runtime/W/G value is unchanged"); auto first=present(staged->identity); check(bool(first)&&first->phase==app::CareerSession::TableDispatchPhase::ready&& f.session.game().calls()>G.calls()&&f.session.state().date==f.id.day_counter&& f.session.club_modal_runtime_checkpoint()==runtime&& (first->identity.expected_family_word&0x80u)==0, "bound ACK commits forecast G while retaining calendar and returns to ordinary mode"); f.ack(*first); auto staged2=f.session.dispatch_league_table_control(f.control(3),f.revision,error); check(bool(staged2)&&staged2->phase==app::CareerSession::TableDispatchPhase::forecast_pending_present, "a second KI click is accepted only after first ACK and stages a fresh forecast"); auto second=present(staged2->identity); check(bool(second)&&second->phase==app::CareerSession::TableDispatchPhase::ready, "second forecast has its own bound Present completion"); check(!present(staged2->identity),"duplicate consumed Present request is rejected"); Fixture bad(data,save);const auto checkpoint=bad.session.league_family_checkpoint(); auto reject_same=[&](ui::LeagueFamilyRequest r) { std::string why;const auto out=bad.session.dispatch_league_table_control(r,bad.revision,why); const auto now=bad.session.league_family_checkpoint(); check(!out&&save_stream(now.state)==save_stream(checkpoint.state)&&now.runtime==checkpoint.runtime&& now.family==checkpoint.family&&now.game.seed()==checkpoint.game.seed()&& now.game.calls()==checkpoint.game.calls()&&now.rand.seed()==checkpoint.rand.seed()&& now.rand.calls()==checkpoint.rand.calls()&&bad.session.state().date==checkpoint.state.date, "invalid/stale typed request leaves the complete Session checkpoint fixed"); }; auto r=bad.control(0);r.from_child=2;reject_same(r); r=bad.control(0);r.identity.manager++;reject_same(r); r=bad.control(0);r.identity.sequence++;reject_same(r); r=bad.control(10);reject_same(r); r=bad.control(0);r.kind=ui::LeagueFamilyRequestKind::table_range_result;reject_same(r); r=bad.control(0);r.identity.source_param2=1;reject_same(r); auto close=bad.control(0);close.kind=ui::LeagueFamilyRequestKind::close; close.identity.family_id++;close.target_child=0; std::string why;check(!bad.session.close_league_family(close,bad.revision,why)&& save_stream(bad.session.state())==save_stream(checkpoint.state)&& bad.session.game().calls()==checkpoint.game.calls()&&bad.session.rand().calls()==checkpoint.rand.calls(), "forged unowned final close is rejected without RNG effects"); } } int main(int argc,char** argv) { try { check(argc==3,"usage: league_table_controls_app_tests "); const fs::path data(argv[1]),save(argv[2]); ten_controls(data,save);ranges(data,save);forecast_present_and_rejections(data,save); forecast_range_preserves_visible_and_scratch(data,save);team_info_uses_visible_identity_and_normal_rank(data,save); invalid_identity_and_close(data,save);control_four_then_domestic_map_preserves_source_locals(data,save); selector_and_no_lab_range(data,save); table_group_toggle_is_typed_and_non_optimistic(data,save); Fixture high_round(data,save,true); std::string high_error;auto high_range=high_round.session.dispatch_league_table_control(high_round.control(9),high_round.revision,high_error); check(bool(high_range),"0x80 round-byte fixture opens the range selector"); ui::LeagueFamilyRequest high_start;high_start.identity=high_range->identity;high_start.kind=ui::LeagueFamilyRequestKind::table_range_result; high_start.from_child=1;high_start.control_index=9; high_start.table_dialog_reply=ui::TableDialogReply{ui::TableDialogStage::start,ui::TableDialogOutcome::accept,1,140,80}; auto high_end=high_round.session.dispatch_league_table_range_reply(high_start,high_round.revision,high_error); check(bool(high_end),"0x80 fixture accepts a Source-valid start round"); ui::LeagueFamilyRequest high_finish;high_finish.identity=high_end->identity;high_finish.kind=ui::LeagueFamilyRequestKind::table_range_result; high_finish.from_child=1;high_finish.control_index=9; high_finish.table_dialog_reply=ui::TableDialogReply{ui::TableDialogStage::end,ui::TableDialogOutcome::accept,10,140,80}; auto high_ready=high_round.session.dispatch_league_table_range_reply(high_finish,high_round.revision,high_error); check(bool(high_ready)&&high_round.session.league_family_checkpoint().family->table->end_round==10, "raw 0x80 compares as unsigned current round against signed end and preserves accepted range end"); std::cout<<"Table controls/range/forecast Session protocol assertions completed\n";return 0; } catch(const std::exception& e) { std::cerr<