Files
Dreierpack-Manager/tests/training_camp_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

164 lines
11 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "formats/executable_layout.hpp"
#include <cstdio>
#include <stdexcept>
#include <algorithm>
#include <chrono>
#include "app/career_session.hpp"
#include "formats/le.hpp"
#include "game/save.hpp"
#include "ui/flow.hpp"
#include "testing/check.hpp"
using namespace bmh;
using namespace bmh::ui;
namespace {
using bmh::test_support::check;
void content_lifecycle(const std::filesystem::path& data) {
const auto exe = load_le(data / "BMH.exe");
app::CareerSession live(data, 0x12345678);
SetupOptions options;
options.world = false;
ManagerChoice choice;
choice.name = "CampTest";
std::string error;
check(live.confirm_manager(options, choice, error), error.c_str());
CareerInitializationResult initialized;
check(live.finish(initialized, error), error.c_str());
for (size_t r = 0; r < 8; ++r) {
check(live.state().training_camp_base_prices[r] == int32_t(exe.u32(::bmh::layout::DeskActions_ConfigureTrainingCampData_RuntimeField2 + uint32_t(r * 4))),
"new career installs the selected edition's resort prices");
for (size_t q = 0; q < 4; ++q)
check(live.state().training_camp_quality[r][q] == exe.u8(::bmh::layout::DeskActions_ConfigureTrainingCampData_RuntimeField + uint32_t(r * 4 + q)),
"new career installs the selected edition's resort qualities");
}
const auto native = save_stream(live.state());
const auto expected_prices = live.state().training_camp_base_prices;
const auto expected_quality = live.state().training_camp_quality;
live.state().training_camp_base_prices.fill(123);
for (auto& grades : live.state().training_camp_quality) grades.fill(1);
check(save_stream(live.state()) == native, "runtime resort content never changes the Native save stream");
const auto file = std::filesystem::temp_directory_path() / ("openbmh-camp-content-" +
std::to_string(std::chrono::steady_clock::now().time_since_epoch().count()) + ".FBM");
WatcomRandom serialize(731);
write_savegame(file, make_savegame(live.state(), serialize));
app::CareerSession reloaded(data, 731, file);
std::filesystem::remove(file);
check(reloaded.state().training_camp_base_prices == expected_prices &&
reloaded.state().training_camp_quality == expected_quality,
"fresh save loading restores resort content from the selected EXE, not defaults or save bytes");
auto projected = training_camp_from_game(reloaded.state(), exe, 0, 1);
check(projected.quality == expected_quality, "UI stars project the same table that booking effects use");
// GameState carries no built-in resort content; a career must take it from the EXE.
GameState defaults;
check(expected_prices != defaults.training_camp_base_prices,
"resort prices come from the selected EXE, not from empty defaults");
}
}
int main(int argc, char** argv) {
try {
if (argc < 2 || argc > 3) throw std::runtime_error("training_camp_app_tests DATA [--content-only]");
const std::filesystem::path data = argv[1];
content_lifecycle(data);
if (argc == 3) {
check(std::string(argv[2]) == "--content-only", "unknown training camp test option");
std::puts("training camp content: actual new-career/save-reload tables and Native isolation OK");
return 0;
}
StartupFlow flow(data);
flow.click(150, 215); // Disable world competition for the ordinary club desk.
flow.click(5, 225, true); // Setup -> first manager.
flow.click(5, 225, true); // Close the manager-name editor.
const auto confirmed = flow.click(90, 169);
check(confirmed.request == FlowRequest::new_career && flow.pending_career(), "UI confirms one manager");
app::CareerSession session(data, 0x12345678);
std::string error;
check(session.confirm_manager(flow.pending_career()->options, flow.pending_career()->managers[0], error),
"career controller accepts UI manager choice");
CareerInitializationResult initialized;
check(session.finish(initialized, error), "career reaches the first desk");
uint64_t revision = initialized.desktop.revision;
auto preparation = std::move(initialized.preparation);
flow.attach_initialized_career(std::move(initialized));
flow.attach_preparation_context(std::move(preparation));
const auto camp_item = std::find_if(flow.desktop()->state().items.begin(), flow.desktop()->state().items.end(),
[](const DeskItem& item) { return item.kind == 15 && !item.disabled; });
check(camp_item != flow.desktop()->state().items.end(), "camp menu is available on the career desk");
const int camp_x = camp_item->x + camp_item->width / 2, camp_y = camp_item->y + camp_item->height / 2;
const auto opened = flow.click(camp_x, camp_y);
check(flow.screen_name() == "training_camp", "desk enters the camp screen");
if (opened.request == FlowRequest::submenu_action) {
const auto& request = std::get<TrainingCampRequest>(opened.submenu_action);
check(request.kind == TrainingCampRequestKind::set_focus, "first camp draw emits derived-focus normalization");
check(session.dispatch_training_camp(request, revision, error), "controller accepts focus normalization");
flow.acknowledge_preparation(session.preparation_projection(revision));
} else check(opened.request == FlowRequest::submenu_opened, "camp opens without a pending engine action");
LeImage exe = load_le(asset_path(data, "BMH.exe"));
const int resort_x = exe.u8(::bmh::layout::TrainingCamp_Click_RuntimeField) + 1, resort_y = exe.u8(::bmh::layout::TrainingCamp_Click_RuntimeField2) + 1;
check(flow.state_json().find("\"selected_resort\":-1")!=std::string::npos,
"entry focus is available before a resort is hovered");
auto focus = flow.click(255 + 7 * 3, exe.u8(::bmh::layout::TrainingCamp_FocusControls_RuntimeField) + 2);
check(focus.request == FlowRequest::submenu_action, "focus slider produces a typed app request");
auto focus_request = std::get<TrainingCampRequest>(focus.submenu_action);
check(focus_request.kind == TrainingCampRequestKind::set_focus && focus_request.revision == revision &&
focus_request.manager_slot == 0 && focus_request.runtime_club == session.state().manager_teams[0],
"focus request carries live manager, club and revision");
check(session.dispatch_training_camp(focus_request, revision, error), "controller writes focus once");
flow.acknowledge_preparation(session.preparation_projection(revision));
const size_t record = size_t(session.state().memory.u8(::bmh::layout::ActiveManager)) * 0xb0c;
check(session.state().manager_records[record + 0xc1] == 7 &&
session.state().manager_records[record + 0xc4] == uint8_t(15 - (7 +
session.state().manager_records[record + 0xc2] + session.state().manager_records[record + 0xc3]) / 3),
"confirmed focus is persisted with the derived fourth value");
const int32_t balance_before = int32_t(uint32_t(session.state().manager_records[record + 0x314]) |
uint32_t(session.state().manager_records[record + 0x315]) << 8 |
uint32_t(session.state().manager_records[record + 0x316]) << 16 |
uint32_t(session.state().manager_records[record + 0x317]) << 24);
const uint8_t visits_before = session.state().manager_records[record + 0x21f];
const auto selected = flow.click(resort_x, resort_y);
check(selected.request == FlowRequest::none, "map click selects resort locally");
const auto booking = flow.click(240, 218);
check(booking.request == FlowRequest::submenu_action, "original OK button emits one booking request");
const auto booking_request = std::get<TrainingCampRequest>(booking.submenu_action);
check(booking_request.kind == TrainingCampRequestKind::book && booking_request.resort == 0 &&
booking_request.revision == revision, "booking retains selection and authoritative context");
check(session.dispatch_training_camp(booking_request, revision, error), "controller performs affordable booking");
flow.acknowledge_preparation(session.preparation_projection(revision));
const int32_t balance_after = int32_t(uint32_t(session.state().manager_records[record + 0x314]) |
uint32_t(session.state().manager_records[record + 0x315]) << 8 |
uint32_t(session.state().manager_records[record + 0x316]) << 16 |
uint32_t(session.state().manager_records[record + 0x317]) << 24);
check(balance_after < balance_before && session.state().manager_records[record + 0x21f] == uint8_t((visits_before + 1) | 0x80),
"booking updates balance and visit/week state exactly once");
check(flow.state_json().find("\"feedback\":\"booked\"") != std::string::npos,
"acknowledgement returns the booked feedback projection");
const auto native_after_booking=save_stream(session.state());
const auto game_after_booking=session.game();const auto rand_after_booking=session.rand();
const auto booked_revision=revision;
const auto close = flow.click(150,170); // legacy routine returns after57eca's KLICK.
check(close.request == FlowRequest::submenu_closed && !flow.in_preparation_menu() &&
flow.screen_name()=="desktop", "success acknowledgement returns the camp caller to the desk");
check(save_stream(session.state())==native_after_booking && revision==booked_revision &&
session.game().seed()==game_after_booking.seed()&&session.game().calls()==game_after_booking.calls()&&
session.rand().seed()==rand_after_booking.seed()&&session.rand().calls()==rand_after_booking.calls(),
"success acknowledgement preserves complete Native/G/W/revision without another booking");
const auto state_after = session.state().manager_records;
flow.click(camp_x, camp_y);
check(flow.screen_name() == "training_camp", "camp can be opened again after returning to desk");
const auto before_abort = session.state().manager_records;
const auto abort = flow.send_key("ESC");
check(abort.request == FlowRequest::submenu_closed && session.state().manager_records == before_abort &&
session.state().manager_records == state_after, "ESC before booking leaves engine state unchanged");
std::puts("training camp app: entry, focus, one booking, returned projection and abort OK");
return 0;
} catch (const std::exception& e) { std::fprintf(stderr, "FAIL: %s\n", e.what()); return 1; }
}