// SPDX-License-Identifier: GPL-3.0-only #include "formats/executable_layout.hpp" #include "app/desktop_actions.hpp" #include "game/save.hpp" #include "game/messages.hpp" #include #include #include #include using namespace bmh; namespace { void check(bool condition, const char* message) { if (!condition) throw std::runtime_error(message); } struct Snapshot { Bytes native; GameRandom game; WatcomRandom rand; uint64_t revision; std::map runtime; Snapshot(app::CareerSession& session, uint64_t rev) : native(save_stream(session.state())), game(session.game()), rand(session.rand()), revision(rev), runtime(session.club_modal_runtime_checkpoint()) {} void unchanged(app::CareerSession& session, uint64_t rev) const { check(save_stream(session.state()) == native && rev == revision && session.game().seed() == game.seed() && session.game().calls() == game.calls() && session.rand().seed() == rand.seed() && session.rand().calls() == rand.calls() && session.club_modal_runtime_checkpoint() == runtime, "shared action rejection preserves complete Native/G/W/revision/runtime"); } }; void reject_ack(app::CareerSession& session) { ++session.state().date; session.game().range(0, 10); session.rand().rand(); throw std::runtime_error("controlled frontend ACK rejection"); } void settings(const std::filesystem::path& data, const std::filesystem::path& save) { app::CareerSession session(data, 0x10351a7u, save); uint64_t revision = 1; app::DeskSettingsActions actions(session); std::string error; const auto desk = session.desktop_projection(revision); const auto request = app::DesktopActions::menu(desk, 19); const Snapshot before(session, revision); const auto old_scope = session.desk_settings_checkpoint(revision).next_scope; auto stale = request; ++stale.revision; check(!actions.open(stale, revision, error), "shared settings rejects a stale observed desktop entry"); before.unchanged(session, revision); bool acknowledged = false; try { actions.open(request, revision, error, [&](app::CareerSession::DeskSettingsProjection&) { acknowledged = session.desk_settings_active(); reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged && !session.desk_settings_active() && session.desk_settings_checkpoint(revision).next_scope == old_scope, "failed settings open ACK restores owner and next scope"); before.unchanged(session, revision); const auto opened = actions.open(request, revision, error); check(bool(opened), error.c_str()); const Snapshot owned(session, revision); acknowledged = false; try { actions.close(opened->owner.sequence, opened->owner.revision, request, revision, error, [&](app::CareerSession::DeskSettingsDispatch& result) { acknowledged = result.closed && !session.desk_settings_active(); reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged && session.desk_settings_active(), "failed settings close ACK restores its real owner"); owned.unchanged(session, revision); const auto closed = actions.close(opened->owner.sequence, opened->owner.revision, request, revision, error); check(closed && closed->closed && !session.desk_settings_active(), "settings retry accepts the restored owner and its original RNG identity"); } void balance(const std::filesystem::path& data, const std::filesystem::path& save) { app::CareerSession session(data, 0x103ba1u, save); uint64_t revision = 1; app::BalanceActions actions(session); std::string error; const auto desk = session.desktop_projection(revision); const auto request = app::DesktopActions::menu(desk, 28); const Snapshot before(session, revision); const auto next_scope = session.balance_checkpoint().next_scope; auto stale = request; ++stale.revision; check(!actions.open(stale, revision, Image(320,240,0), error), "shared balance rejects stale observed entry"); before.unchanged(session, revision); bool acknowledged = false; try { actions.open(request, revision, Image(320,240,0), error, [&](ui::BalanceState&) { acknowledged = session.balance_active(); reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged && !session.balance_active() && session.balance_checkpoint().next_scope == next_scope, "failed balance open ACK restores its draft owner and scope"); before.unchanged(session, revision); auto draft = actions.open_draft(desk.manager_slot); while (draft.view != BalanceView::future) actions.cycle_draft(draft); check(actions.edit_draft(draft, 0, 100000) == BalanceEditStatus::changed, "shared console balance draft retains its existing edit operation"); before.unchanged(session, revision); bool stored = false; try { actions.apply(revision, [&] { (void)actions.close_draft(draft, revision); stored = revision == before.revision + 1; reject_ack(session); return true; }); } catch (const std::runtime_error&) {} check(stored, "console balance close still stores once and consumes exactly one revision"); before.unchanged(session, revision); } void other_games(const std::filesystem::path& data, const std::filesystem::path& save) { app::CareerSession session(data, 0x10305u, save); uint64_t revision = 1; app::OtherGamesActions actions(session); std::string error; const auto request = app::DesktopActions::menu(session.desktop_projection(revision), 5); const Snapshot before(session, revision); const auto next_scope = session.other_games_checkpoint().next_scope; auto stale = request; ++stale.revision; check(!actions.open(stale, revision, Image(320,240,0), error), "shared Other Games rejects stale entry"); before.unchanged(session, revision); bool acknowledged = false; try { actions.open(request, revision, Image(320,240,0), error, [&](ui::OtherGamesState&) { acknowledged = session.other_games_active(); reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged && !session.other_games_active() && session.other_games_checkpoint().next_scope == next_scope, "failed Other Games open ACK restores owner and scope"); before.unchanged(session, revision); const auto page = actions.open(request, revision, Image(320,240,0), error); check(bool(page), error.c_str()); const Snapshot owned(session, revision); const ui::OtherGamesRequest close{page->identity, ui::OtherGamesAction::close, -1}; acknowledged = false; try { actions.dispatch(close, revision, error, {}, [&](app::CareerSession::OtherGamesDispatch& result) { acknowledged = result.closed; reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged && session.other_games_active(), "Other Games close ACK failure restores its owner"); owned.unchanged(session, revision); const auto closed = actions.dispatch(close, revision, error); check(closed && closed->closed && !session.other_games_active(), "Other Games restored close can be retried once"); } void top_scorers(const std::filesystem::path& data, const std::filesystem::path& save) { app::CareerSession session(data, 0x10320u, save); uint64_t revision = 1; app::TopScorersActions actions(session); std::string error; const auto request = app::DesktopActions::menu(session.desktop_projection(revision), 20); const Snapshot before(session, revision); const auto next_scope = session.top_scorers_checkpoint().next_scope; auto stale = request; ++stale.revision; check(!actions.open(stale, revision, Image(320,240,0), error), "shared Top Scorers rejects stale entry"); before.unchanged(session, revision); bool acknowledged = false; try { actions.open(request, revision, Image(320,240,0), error, [&](ui::TopScorersState&) { acknowledged = session.top_scorers_active(); reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged && !session.top_scorers_active() && session.top_scorers_checkpoint().next_scope == next_scope, "failed Top Scorers open ACK restores owner and scope"); before.unchanged(session, revision); const auto page = actions.open(request, revision, Image(320,240,0), error); check(page && revision == before.revision + 1, "shared Top Scorers opening advances revision exactly once"); const Snapshot owned(session, revision); const ui::TopScorersRequest close{page->identity, ui::TopScorersAction::close, page->metric, page->scope}; acknowledged = false; try { actions.dispatch(close, revision, error, [&](app::CareerSession::TopScorersDispatch& result) { acknowledged = result.closed; reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged && session.top_scorers_active(), "Top Scorers close ACK failure restores its owner"); owned.unchanged(session, revision); const auto closed = actions.dispatch(close, revision, error); check(closed && closed->closed && !session.top_scorers_active(), "Top Scorers restored close can be retried once"); } void opportunities(const std::filesystem::path& data, const std::filesystem::path& save) { app::CareerSession session(data, 0x103adu, save); uint64_t revision = 1; app::OpportunitiesActions actions(session); std::string error; const auto request = app::DesktopActions::menu(session.desktop_projection(revision), 23); const Snapshot before(session, revision); const auto next_scope = session.opportunities_checkpoint().next_scope; ui::AnalyticsRequest preference; preference.owner = request; preference.manager_slot = request.manager_slot; preference.metric = 0; preference.expected_flags = session.state().memory.u8(::bmh::layout::Flags + uint32_t(request.manager_slot) * 3); preference.target_flags = uint8_t(preference.expected_flags ^ 1); bool preference_ack = false; try { actions.preference(preference, revision, error, [&] { preference_ack = revision == before.revision + 1; reject_ack(session); }); } catch (const std::runtime_error&) {} check(preference_ack, "shared analytics preference preserves its existing single revision"); before.unchanged(session, revision); auto stale = request; ++stale.revision; check(!actions.open(stale, revision, Image(320,240,0), error), "shared Opportunities rejects stale entry"); before.unchanged(session, revision); bool acknowledged = false; try { actions.open(request, revision, Image(320,240,0), error, false, -1, [&](ui::OpportunitiesState&) { acknowledged = session.opportunities_active(); reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged && !session.opportunities_active() && session.opportunities_checkpoint().next_scope == next_scope, "failed Opportunities open ACK restores owner and scope"); before.unchanged(session, revision); const auto page = actions.open(request, revision, Image(320,240,0), error); check(page && revision == before.revision + 1, "shared Opportunities opening advances revision exactly once"); const Snapshot owned(session, revision); const auto close = app::OpportunitiesActions::close_request(*page); acknowledged = false; try { actions.dispatch(close, revision, error, [&](app::CareerSession::OpportunitiesDispatch& result) { acknowledged = result.closed; reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged && session.opportunities_active(), "Opportunities close ACK failure restores its owner"); owned.unchanged(session, revision); const auto closed = actions.dispatch(close, revision, error); check(closed && closed->closed && !session.opportunities_active(), "Opportunities restored close can be retried once"); } void manager_join(const std::filesystem::path& data, const std::filesystem::path& save) { app::CareerSession session(data, 0x10329u, save); uint64_t revision = 1; app::ManagerJoinActions actions(session); const Snapshot before(session, revision); std::string error; bool acknowledged = false; check(!actions.commit(revision, error, [&](ui::CareerInitializationResult&) { acknowledged = true; }) && !acknowledged, "shared manager join rejects a commit without completed selection before any ACK"); before.unchanged(session, revision); check(!actions.apply(revision, [&] { ++session.state().date; session.game().range(0,10); session.rand().rand(); ++revision; return false; }), "shared manager join rolls back a rejected partial operation"); before.unchanged(session, revision); } void mailbox(const std::filesystem::path& data, const std::filesystem::path& save) { app::CareerSession session(data, 0x10344u, save); uint64_t revision = 1; app::MailboxActions actions(session); const int manager = session.desktop_projection(revision).manager_slot; // Controlled in-memory fixture using the real Core writer; the captured FBM // stays unchanged and is not claimed to contain this test message. post_composed(session.state(), manager, "COMMON ROLLBACK"); const auto observed = ui::mailbox_state_from_game(session.state(), manager, revision); const auto message = std::find_if(observed.messages.begin(), observed.messages.end(), [](const ui::MailboxMessage& m) { return m.text == "COMMON ROLLBACK"; }); check(message != observed.messages.end(), "Core-posted controlled mailbox message is visible"); const auto request = app::MailboxActions::request(manager, revision, ui::MailboxActionKind::delete_for_manager, *message); const Snapshot before(session, revision); std::string error; auto stale = request; ++stale.revision; check(!actions.dispatch(stale, revision, error), "shared mailbox rejects a stale observed message action"); before.unchanged(session, revision); bool acknowledged = false; try { actions.dispatch(request, revision, error, [&] { acknowledged = true; reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged, "real mailbox deletion reaches the shared acknowledgement boundary"); before.unchanged(session, revision); acknowledged = false; try { actions.close({manager,revision}, revision, error, [&] { acknowledged = true; reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged, "real mailbox close reaches its shared acknowledgement boundary"); before.unchanged(session, revision); check(actions.dispatch(request, revision, error), "restored mailbox message can be deleted on retry"); } void menu_layout(const std::filesystem::path& data, const std::filesystem::path& save) { app::CareerSession session(data, 0x10372u, save); uint64_t revision = 1; app::MenuLayoutActions actions(session); const int manager = session.desktop_projection(revision).manager_slot; const auto directory = std::filesystem::temp_directory_path() / ("openbmh-shared-layout-" + std::to_string(std::chrono::steady_clock::now().time_since_epoch().count())); check(std::filesystem::create_directory(directory), "isolated shared layout test directory"); struct Cleanup { std::filesystem::path path; ~Cleanup() { std::error_code ignored; std::filesystem::remove_all(path, ignored); } } cleanup{directory}; const ui::SaveLoadRequest request{ui::SaveLoadAction::save, manager, revision, directory/"TEST.MEN", false, ui::SaveLoadFileKind::menu_layout, 53}; const Snapshot before(session, revision); std::string error; auto stale = request; ++stale.revision; check(!actions.dispatch(stale, revision, error), "shared layout rejects a stale file request"); before.unchanged(session, revision); bool acknowledged = false; try { actions.dispatch(request, revision, error, [&] { acknowledged = std::filesystem::file_size(request.path) == 0x360; reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged, error.empty() ? "real layout save reaches its shared ACK" : error.c_str()); before.unchanged(session, revision); // As before, native rollback does not undo the already written .MEN file. auto retry = request; retry.overwrite = true; check(actions.dispatch(retry, revision, error) && revision == before.revision + 1, "layout retry uses the existing overwrite confirmation and advances once"); } void environment(const std::filesystem::path& data, const std::filesystem::path& save) { app::CareerSession session(data, 0x10324u, save); uint64_t revision = 1; app::EnvironmentActions actions(session); const auto observed = ui::environment_from_game(session.state(), revision); const int level = (observed.values.level[kCoTrainer] + 1) % 7; const auto request = app::EnvironmentActions::request(observed, kCoTrainer, level); const Snapshot before(session, revision); std::string error; auto stale = request; ++stale.revision; check(!actions.set(stale, revision, error), "shared environment rejects a stale observed staff change"); before.unchanged(session, revision); bool acknowledged = false; try { actions.set(request, revision, error, {}, [&](bool changed) { acknowledged = changed && revision == before.revision + 1; reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged, "real staff change reaches the shared acknowledgement with one revision"); before.unchanged(session, revision); const auto applied = actions.set_console(observed, kCoTrainer, level, revision, error); check(applied == EnvironmentResult::changed && revision == before.revision + 1, "shared console environment retains its actual staff write and one revision"); } void reschedule(const std::filesystem::path& data, const std::filesystem::path& save) { app::CareerSession session(data, 0x10307u, save); uint64_t revision = 1; app::RescheduleActions actions(session); const Snapshot before(session, revision); ui::RescheduleAction request; request.owner = app::DesktopActions::menu(session.desktop_projection(revision), 7); ++request.owner.revision; check(actions.dispatch(request, revision) == RescheduleStatus::invalid_match, "shared reschedule rejects a stale observed calendar owner"); before.unchanged(session, revision); check(actions.move(-1, {}, -1, revision) == RescheduleStatus::invalid_manager, "shared console reschedule rejects an invalid manager without a revision"); before.unchanged(session, revision); check(!actions.apply(revision, [&] { ++session.state().date; session.game().range(0,10); session.rand().rand(); ++revision; return false; }), "shared reschedule rejects a partial operation"); before.unchanged(session, revision); } void contracts(const std::filesystem::path& data, const std::filesystem::path& save) { app::CareerSession session(data, 0x10327u, save); uint64_t revision = 1; app::ContractActions actions(session); const auto observed = ui::contracts_from_game(session.state(), session.desktop_projection(revision).manager_slot, revision); const auto player = std::find_if(observed.players.begin(), observed.players.end(), [](const ui::ContractPlayer& p) { return !p.offer_blocked; }); check(player != observed.players.end(), "captured squad has a player for an actual demands query"); const auto request = app::ContractActions::demands(observed, *player, 1); const Snapshot before(session, revision); std::string error; ui::ContractActionResult result; auto stale = request; ++stale.revision; check(!actions.dispatch(stale, revision, result, error), "shared contracts reject a stale observed demands query"); before.unchanged(session, revision); bool acknowledged = false; try { actions.dispatch(request, revision, result, error, [&] { acknowledged = result.quote_id != 0; reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged, "actual contract quote reaches its shared acknowledgement boundary"); before.unchanged(session, revision); const auto retry = app::ContractActions::demands(observed, *player, 2); check(actions.dispatch(retry, revision, result, error) && result.quote_id != 0, "contracts preserve the existing new-request-ID retry and quote cleanup policy"); } void friendly(const std::filesystem::path& data, const std::filesystem::path& save) { app::CareerSession session(data, 0x10306u, save); uint64_t revision = 1; app::FriendlyActions actions(session); const int manager = session.desktop_projection(revision).manager_slot; FriendlyBookingQuote quote; int selected_day = -1; for (int opponent = 0; opponent < 138 && selected_day < 0; ++opponent) { const auto candidate = actions.quote(manager, opponent, false); if (candidate.status != FriendlyQuoteStatus::quoted || candidate.opponent_manager >= 0) continue; for (int day = 0; day <= 365; ++day) { const auto status = actions.date_status(candidate, uint16_t(day)); if (status == FriendlyDateStatus::available || status == FriendlyDateStatus::available_with_calendar_event) { quote = candidate; selected_day = day; break; } } } check(selected_day >= 0, "captured career offers an actual AI friendly and free date"); ui::FriendlyMatchRequest request; request.kind = ui::FriendlyRequestKind::book; request.request_id = 1; request.quote_id = 1; request.revision = revision; request.manager_slot = quote.manager; request.runtime_team = quote.manager_team; request.opponent = quote.opponent; request.manager_home = quote.manager_home; request.home_team = quote.home_team; request.away_team = quote.away_team; request.payer_manager = quote.payer_manager; request.opponent_manager = quote.opponent_manager; request.cost = quote.cost; request.planner_count = quote.planner_count; request.season_day = selected_day; request.accept_cost = true; request.approving_manager = quote.payer_manager; request.accept_opponent = false; request.consenting_manager = quote.opponent_manager; const Snapshot before(session, revision); auto stale = request; ++stale.revision; check(!actions.book_club(stale, revision).applied, "shared friendly booking rejects a stale observed request"); before.unchanged(session, revision); bool acknowledged = false; try { actions.book_club(request, revision, [&](const ui::FriendlyBookingAck& ack) { acknowledged = ack.revision == before.revision + 1 && revision == before.revision && ack.planner_count == request.planner_count + 2; reject_ack(session); }); } catch (const std::runtime_error&) {} check(acknowledged, "real friendly booking keeps the old revision during ACK and supplies the two new plan rows"); before.unchanged(session, revision); const auto retry = actions.book_console(quote, uint16_t(selected_day), false, quote.opponent_manager, true, quote.payer_manager, revision); check(retry.status == FriendlyBookingStatus::booked && revision == before.revision + 1, "shared console friendly retry books the restored quote and consumes one revision"); } } // namespace int main(int argc, char** argv) { try { if (argc != 3) throw std::runtime_error("usage: shared_desktop_actions_tests DATA SAVE"); settings(argv[1], argv[2]); balance(argv[1], argv[2]); other_games(argv[1], argv[2]); top_scorers(argv[1], argv[2]); opportunities(argv[1], argv[2]); manager_join(argv[1], argv[2]); mailbox(argv[1], argv[2]); menu_layout(argv[1], argv[2]); environment(argv[1], argv[2]); reschedule(argv[1], argv[2]); contracts(argv[1], argv[2]); friendly(argv[1], argv[2]); std::puts("shared desktop application boundaries OK"); } catch (const std::exception& error) { std::fprintf(stderr, "FAIL: %s\n", error.what()); return 1; } return 0; }