// SPDX-License-Identifier: GPL-3.0-only // The engine side of the Modern interface contract (docs/new_engine/ui-anbindung.md): the // envelope, identities, money, errors and that a read changes nothing. Needs game data // (a Modern session on the Classic data). #include #include #include #include "cli/json.hpp" #include "modern/app/modern_session.hpp" #include "modern/content/ui_contract.hpp" #include "modern/game/save.hpp" using namespace bmh; using J = cli::Json; using O = J::Object; namespace { int failures = 0; void check(bool ok, const char* what) { if (!ok) { std::fprintf(stderr, "FAIL: %s\n", what); ++failures; } } const J& at(const J& j, const char* key) { static const J none; const auto* o = j.object(); if (!o) return none; const auto it = o->find(key); return it == o->end() ? none : it->second; } std::string s(const J& j) { return j.string() ? *j.string() : std::string{}; } bool truth(const J& j) { const bool* b = std::get_if(&j.value); return b && *b; } } // namespace int main(int argc, char** argv) { if (argc < 2) { std::fprintf(stderr, "usage: modern_ui_contract_tests \n"); return 2; } try { modern::app::ModernSession session(argv[1], 1u); ui::SetupOptions options; ui::ManagerChoice choice; choice.name = "TEST"; choice.master_club = 0; std::string error; if (!session.confirm_manager(options, choice, error)) throw std::runtime_error("manager: " + error); ui::CareerInitializationResult init; if (!session.finish(init, error)) throw std::runtime_error("career start: " + error); const uint64_t revision = init.desktop.revision; const auto before = modern::save_stream(session.state()); const std::string career = session.state().career_id; // session: envelope and identities const J sess = session.ui_read(O{{"kind", "session"}, {"requestId", "request:1"}}, revision); check(s(at(sess, "messageType")) == "snapshot", "session is a snapshot"); check(s(at(sess, "requestId")) == "request:1", "request id echoed"); const J& meta = at(sess, "meta"); check(s(at(meta, "contractVersion")) == "bmh-modern-ui@draft1", "contract version"); check(s(at(meta, "careerId")).starts_with("career:") && s(at(meta, "careerId")).size() == 23, "career id"); check(s(at(meta, "stateRevision")) == std::to_string(revision), "state revision as decimal string"); check(s(at(at(meta, "scope"), "managerId")) == "manager:1", "first manager id"); check(s(at(at(meta, "currency"), "code")) == "EUR" && at(at(meta, "currency"), "minorUnits").integer() && *at(at(meta, "currency"), "minorUnits").integer() == 2, "currency"); const auto* managers = at(at(sess, "data"), "managers").array(); check(managers && managers->size() == 1 && s(at((*managers)[0], "status")) == "active", "one active manager"); // desktop: money in minor units, menus const J desk = session.ui_read(O{{"kind", "desktop"}}, revision); const J status = session.read(O{{"kind", "status"}}); const int64_t euros = at(status, "money").integer() ? *at(status, "money").integer() : -1; check(s(at(at(at(at(desk, "data"), "accounts"), "cash"), "minor")) == std::to_string(euros * 100), "cash in cents"); const auto* menus = at(at(desk, "data"), "menuAvailability").object(); check(menus && menus->size() == 16 && s(at(menus->at("bank"), "status")) == "available", "menus at a club desk"); // squad: own club with salaries, another club without const J own = session.ui_read(O{{"kind", "squad"}}, revision); const auto* players = at(at(own, "data"), "players").array(); check(players && players->size() >= 11, "own squad"); check(players && !players->empty() && at((*players)[0], "salaryMonthly").object(), "own salaries known"); const J other = session.ui_read(O{{"kind", "squad"}, {"teamId", "team:5"}}, revision); const auto* others = at(at(other, "data"), "players").array(); check(others && !others->empty() && std::holds_alternative(at((*others)[0], "salaryMonthly").value), "foreign salaries unknown"); // errors check(s(at(session.ui_read(O{{"kind", "nonsense"}}, revision), "code")) == "unknown_read", "unknown read"); check(s(at(session.ui_read(O{{"kind", "desktop"}, {"managerId", "manager:7"}}, revision), "code")) == "manager_not_active", "other manager refused"); check(s(at(session.ui_read(O{{"kind", "squad"}, {"teamId", "club:none"}}, revision), "code")) == "unknown_team", "unknown team"); // reads change nothing check(modern::save_stream(session.state()) == before, "reads leave the state unchanged"); check(session.state().career_id == career, "career id unchanged"); // identities: never reused, nothing set is replaced modern::ModernState copy = session.state(); modern::ensure_ui_identities(copy); check(copy.manager_ids == session.state().manager_ids && copy.career_id == career, "identities stable"); copy.manager_ids.clear(); modern::ensure_ui_identities(copy); check(copy.manager_ids.size() == 1 && copy.manager_ids[0] == "manager:2", "a freed slot gets a new id"); // money check(s(at(modern::ui_money(15), "minor")) == "1500" && s(at(modern::ui_money(-3), "minor")) == "-300", "money"); // camps: read with binding quotes, then camp.book as the first command const J camps = session.ui_read(O{{"kind", "camps"}}, revision); const auto* list = at(at(camps, "data"), "camps").array(); check(list && list->size() == session.state().training_camps.size() && !list->empty(), "camp catalogue"); const std::string camp_id = list && !list->empty() ? s(at((*list)[0], "id")) : ""; const std::string price = list && !list->empty() ? s(at(at(at((*list)[0], "quote"), "total"), "minor")) : ""; check(list && !list->empty() && truth(at(at((*list)[0], "quote"), "allowed")), "camp quote allowed"); uint64_t rev = revision; const auto command = [&](const std::string& id, const std::string& expected, const std::string& manager, const std::string& camp) { return J(O{{"messageType", "command"}, {"requestId", id}, {"expectedRevision", expected}, {"owner", O{{"managerId", manager}}}, {"kind", "camp.book"}, {"payload", O{{"campId", camp}}}}); }; const auto unchanged = modern::save_stream(session.state()); check(s(at(session.ui_command(command("request:c1", "999", "manager:1", camp_id), rev), "code")) == "stale_revision", "stale revision refused"); check(s(at(session.ui_command(command("request:c2", std::to_string(rev), "manager:9", camp_id), rev), "code")) == "manager_not_active", "foreign owner refused"); check(s(at(session.ui_command(command("request:c3", std::to_string(rev), "manager:1", "resort:none"), rev), "code")) == "unknown_camp", "unknown camp refused"); check(rev == revision && modern::save_stream(session.state()) == unchanged, "refused commands change nothing"); const int64_t cash_before = *at(session.read(O{{"kind", "status"}}), "money").integer(); const J booked = session.ui_command(command("request:c4", std::to_string(rev), "manager:1", camp_id), rev); check(s(at(booked, "messageType")) == "command_result" && s(at(booked, "newRevision")) == std::to_string(revision + 1) && rev == revision + 1, "camp booked, one revision"); const int64_t cash_after = *at(session.read(O{{"kind", "status"}}), "money").integer(); check(std::to_string((cash_before - cash_after) * 100) == price, "the quoted price was charged"); const J again = session.ui_command(command("request:c4", std::to_string(revision), "manager:1", camp_id), rev); check(cli::dump_json(again) == cli::dump_json(booked) && rev == revision + 1 && *at(session.read(O{{"kind", "status"}}), "money").integer() == cash_after, "repeated request answered, not booked twice"); check(s(at(session.ui_command(command("request:c4", std::to_string(rev), "manager:1", camp_id), rev), "code")) == "duplicate_request", "same id, other command"); const auto after_booking = modern::save_stream(session.state()); check(s(at(session.ui_command(command("request:c5", std::to_string(rev), "manager:1", camp_id), rev), "code")) == "booked_this_week" && modern::save_stream(session.state()) == after_booking && rev == revision + 1, "second booking in a week refused without change"); const J after = session.ui_read(O{{"kind", "camps"}}, rev); check(at(at(after, "data"), "staysThisSeason").integer() && *at(at(after, "data"), "staysThisSeason").integer() == 1 && truth(at(at(after, "data"), "bookedThisWeek")), "camp read shows the stay"); // lineup, tactics, training: read, one accepted and one refused command each const auto cmd = [&](const std::string& id, const char* kind, J payload) { return J(O{{"messageType", "command"}, {"requestId", id}, {"expectedRevision", std::to_string(rev)}, {"owner", O{{"managerId", "manager:1"}}}, {"kind", kind}, {"payload", std::move(payload)}}); }; const J lineup = session.ui_read(O{{"kind", "lineup"}}, rev); const auto* order = at(at(lineup, "data"), "order").array(); check(order && order->size() >= 12 && at(at(lineup, "data"), "positions").array() && at(at(lineup, "data"), "positions").array()->size() == 11, "lineup read"); if (order && order->size() >= 12) { J::Array wanted = *order; std::swap(wanted[0], wanted[1]); std::swap(wanted[10], wanted[11]); const uint64_t before_lineup = rev; const J done = session.ui_command(cmd("request:l1", "lineup.commit", O{{"order", wanted}}), rev); if (s(at(done, "messageType")) != "command_result") std::fprintf(stderr, "lineup: %s\n", cli::dump_json(done).c_str()); const J reread = session.ui_read(O{{"kind", "lineup"}}, rev); const auto* now = at(at(reread, "data"), "order").array(); if (now && (s((*now)[0]) != s(wanted[0]) || s((*now)[10]) != s(wanted[10]) || rev != before_lineup + 1)) std::fprintf(stderr, "lineup: rev %llu/%llu, now %s %s %s, wanted %s %s %s\n", (unsigned long long)rev, (unsigned long long)before_lineup, s((*now)[0]).c_str(), s((*now)[1]).c_str(), s((*now)[10]).c_str(), s(wanted[0]).c_str(), s(wanted[1]).c_str(), s(wanted[10]).c_str()); check(s(at(done, "messageType")) == "command_result" && rev == before_lineup + 1 && now && s((*now)[0]) == s(wanted[0]) && s((*now)[10]) == s(wanted[10]), "lineup committed"); const auto kept = modern::save_stream(session.state()); check(s(at(session.ui_command(cmd("request:l2", "lineup.commit", O{{"order", J::Array{J("player:none")}}}), rev), "code")) == "unknown_player" && modern::save_stream(session.state()) == kept && rev == before_lineup + 1, "unknown player refused without change"); } const J tactics = session.ui_read(O{{"kind", "tactics"}}, rev); const auto* controls = at(at(tactics, "data"), "controls").array(); check(controls && controls->size() == 8, "tactics read"); if (controls && controls->size() == 8) { J::Array values; for (const auto& c : *controls) values.push_back(at(c, "value")); const int64_t max7 = *at(at((*controls)[7], "range"), "max").integer(); const int64_t v7 = *values[7].integer(); values[7] = J(v7 == max7 ? v7 - 1 : v7 + 1); const uint64_t before_tactics = rev; const J done = session.ui_command(cmd("request:t1", "tactics.commit", O{{"values", values}}), rev); const J reread = session.ui_read(O{{"kind", "tactics"}}, rev); const auto* now = at(at(reread, "data"), "controls").array(); check(s(at(done, "messageType")) == "command_result" && rev == before_tactics + 1 && now && *at((*now)[7], "value").integer() == *values[7].integer(), "tactics committed"); values[7] = J(max7 + 1); const auto kept = modern::save_stream(session.state()); check(s(at(session.ui_command(cmd("request:t2", "tactics.commit", O{{"values", values}}), rev), "code")) == "invalid_tactic" && modern::save_stream(session.state()) == kept, "tactic above its maximum refused"); } const J training = session.ui_read(O{{"kind", "training"}}, rev); check(s(at(training, "messageType")) == "snapshot" && at(at(training, "data"), "areas").array() && at(at(training, "data"), "areas").array()->size() == 9, "training read"); { const uint64_t before_training = rev; const J done = session.ui_command(cmd("request:p1", "training.commit", O{{"types", J::Array{J(2), J(2), J(2), J(2)}}, {"areas", J::Array{J(2), J(2), J(2), J(2), J(2), J(2), J(2), J(2), J(2)}}}), rev); const J now = session.ui_read(O{{"kind", "training"}}, rev); const auto* areas = at(at(now, "data"), "areas").array(); check(s(at(done, "messageType")) == "command_result" && rev == before_training + 1 && areas && *at((*areas)[8], "allocation").integer() == 2, "training committed"); const auto kept = modern::save_stream(session.state()); check(s(at(session.ui_command(cmd("request:p2", "training.commit", O{{"types", J::Array{J(3), J(3), J(3), J(3)}}}), rev), "messageType")) == "error" && modern::save_stream(session.state()) == kept && rev == before_training + 1, "training over the limit refused without change"); } // bank: read, fixed deposit, a share, a refused withdrawal { const J bank = session.ui_read(O{{"kind", "bank"}}, rev); const J& accounts = at(at(bank, "data"), "accounts"); const auto* stocks = at(at(bank, "data"), "stocks").array(); check(s(at(bank, "messageType")) == "snapshot" && stocks && stocks->size() == 12, "bank read"); const std::string deposit_before = s(at(at(accounts, "deposit"), "minor")); const uint64_t before_bank = rev; const J done = session.ui_command(cmd("request:b1", "bank.commit", O{{"action", "deposit"}, {"amount", O{{"minor", "10000000"}, {"currency", "EUR"}, {"minorUnits", 2}}}}), rev); const J after = session.ui_read(O{{"kind", "bank"}}, rev); check(s(at(done, "messageType")) == "command_result" && rev == before_bank + 1 && std::stoll(s(at(at(at(at(after, "data"), "accounts"), "deposit"), "minor"))) == std::stoll(deposit_before) + 10000000, "100000 euros to the fixed deposit"); const J share = session.ui_command(cmd("request:b2", "bank.commit", O{{"action", "buy"}, {"assetId", "stock:0"}, {"count", 1}}), rev); check(s(at(share, "messageType")) == "command_result" && rev == before_bank + 2, "one share bought"); const auto kept = modern::save_stream(session.state()); const J refused = session.ui_command(cmd("request:b3", "bank.commit", O{{"action", "withdraw"}, {"amount", O{{"minor", "99999999900"}, {"currency", "EUR"}, {"minorUnits", 2}}}}), rev); check(s(at(refused, "messageType")) == "error" && modern::save_stream(session.state()) == kept && rev == before_bank + 2, "withdrawal above the deposit refused without change"); } // contracts: demands as a quote, an offer against it, a stale quote refused { const J contracts = session.ui_read(O{{"kind", "contracts"}}, rev); const auto* players = at(at(contracts, "data"), "players").array(); check(players && !players->empty(), "contracts read"); const std::string player = players && !players->empty() ? s(at((*players)[0], "playerId")) : ""; const uint64_t before = rev; const J quoted = session.ui_command(cmd("request:k1", "quote.request", O{{"kind", "contract"}, {"playerId", player}}), rev); check(s(at(quoted, "outcome")) == "offer_pending" && rev == before + 1, "demands quoted"); const J with_quote = session.ui_read(O{{"kind", "contracts"}}, rev); const J& quote = at(at(with_quote, "data"), "quote"); const auto* demands = at(quote, "demands").array(); check(s(at(quote, "playerId")) == player && demands && demands->size() == 4, "quote with four terms"); if (demands && demands->size() == 4) { const std::string id = s(at(quote, "id")); const J offer = session.ui_command(cmd("request:k2", "contract.offer", O{{"quoteId", id}, {"years", 2}, {"monthlySalary", O{{"minor", "100"}, {"currency", "EUR"}, {"minorUnits", 2}}}}), rev); const std::string outcome = s(at(offer, "outcome")); check(s(at(offer, "messageType")) == "command_result" && (outcome == "applied" || outcome == "offer_rejected") && rev == before + 2, "offer answered"); check(s(at(session.ui_command(cmd("request:k3", "contract.offer", O{{"quoteId", id}, {"years", 2}, {"monthlySalary", O{{"minor", "100"}, {"currency", "EUR"}, {"minorUnits", 2}}}}), rev), "code")) == "stale_quote" && rev == before + 2, "a used quote is gone"); } } // advertising: the first acceptable offer, a budget { const J ads = session.ui_read(O{{"kind", "advertising"}}, rev); check(s(at(ads, "messageType")) == "snapshot" && at(at(ads, "data"), "boards").array() && at(at(ads, "data"), "boards").array()->size() == 14, "advertising read"); std::string offer; const auto pick = [&](const J& place) { if (const auto* list = at(place, "offers").array()) for (const auto& o : *list) if (offer.empty() && truth(at(o, "allowed"))) offer = s(at(o, "id")); }; pick(at(at(ads, "data"), "shirt")); pick(at(at(ads, "data"), "television")); if (const auto* boards = at(at(ads, "data"), "boards").array()) for (const auto& b : *boards) pick(b); const uint64_t before = rev; if (!offer.empty()) { const J done = session.ui_command(cmd("request:w1", "advertising.accept", O{{"offerId", offer}}), rev); if (s(at(done, "messageType")) != "command_result") std::fprintf(stderr, "advertising: %s\n", cli::dump_json(done).c_str()); check(s(at(done, "messageType")) == "command_result" && rev == before + 1, "advertising offer accepted"); } const auto kept = modern::save_stream(session.state()); check(s(at(session.ui_command(cmd("request:w2", "advertising.accept", O{{"offerId", "offer:ad-3-99"}}), rev), "code")) == "unknown_offer" && modern::save_stream(session.state()) == kept, "unknown offer refused"); std::printf("(advertising offer %s)\n", offer.empty() ? "none" : offer.c_str()); } // stadium: periphery, facilities, blocks; the ticket price { const J stadium = session.ui_read(O{{"kind", "stadium"}}, rev); const J& d = at(stadium, "data"); if (s(at(stadium, "messageType")) != "snapshot") std::fprintf(stderr, "stadium: %s\n", cli::dump_json(stadium).c_str()); check(at(d, "periphery").array() && at(d, "periphery").array()->size() == 14 && at(d, "blocks").array() && at(d, "blocks").array()->size() == 8 && at(d, "facilities").array() && at(d, "facilities").array()->size() == 8, "stadium read"); if (const auto* p = at(d, "periphery").array(); p && !p->empty()) check(!s(at((*p)[0], "name")).empty() && at((*p)[0], "stage").integer(), "traffic access with its stage"); const uint64_t before = rev; const J done = session.ui_command(cmd("request:e1", "ticket.commit", O{{"price", O{{"minor", "1200"}, {"currency", "EUR"}, {"minorUnits", 2}}}}), rev); if (s(at(done, "messageType")) != "command_result") std::fprintf(stderr, "ticket: %s\n", cli::dump_json(done).c_str()); const J after = session.ui_read(O{{"kind", "stadium"}}, rev); check(s(at(done, "messageType")) == "command_result" && s(at(at(at(after, "data"), "ticketPrice"), "minor")) == "1200" && rev <= before + 1, "ticket price set"); check(s(at(session.ui_command(cmd("request:e2", "ticket.commit", O{{"price", O{{"minor", "3000"}, {"currency", "EUR"}, {"minorUnits", 2}}}}), rev), "code")) == "invalid_amount", "ticket price above 25 refused"); // building: a periphery object not built yet, then a facility level without the tip std::string object; if (const auto* p = at(at(after, "data"), "periphery").array()) for (const auto& o : *p) if (object.empty() && at(o, "built").value.index() == 1 && !truth(at(o, "built")) && *at(o, "constructionDays").integer() == 0) object = s(at(o, "id")); const auto quote_of = [&]() { const J st = session.ui_read(O{{"kind", "stadium"}}, rev); return J(at(at(st, "data"), "quote")); }; if (!object.empty()) { const uint64_t b0 = rev; const J q = session.ui_command(cmd("request:e3", "quote.request", O{{"kind", "periphery"}, {"objectId", object}}), rev); if (s(at(q, "messageType")) != "command_result") std::fprintf(stderr, "periphery quote: %s\n", cli::dump_json(q).c_str()); const J quote = quote_of(); check(s(at(q, "outcome")) == "offer_pending" && s(at(quote, "objectId")) == object && rev == b0 + 1, "periphery quoted"); const J built = session.ui_command(cmd("request:e4", "stadium.commit", O{{"quoteId", at(quote, "id")}, {"accept", true}}), rev); if (s(at(built, "messageType")) != "command_result") std::fprintf(stderr, "periphery build: %s\n", cli::dump_json(built).c_str()); check(s(at(built, "messageType")) == "command_result" && rev == b0 + 2 && std::holds_alternative(quote_of().value), "periphery built, the stadium closed"); } { const uint64_t b0 = rev; const J q = session.ui_command(cmd("request:e5", "quote.request", O{{"kind", "facility"}, {"facilityId", "facility:safety"}, {"increment", 1}}), rev); const J quote = quote_of(); if (s(at(q, "messageType")) == "command_result") { check(s(at(quote, "kind")) == "facility" && at(quote, "price").object(), "facility quoted"); const J done = session.ui_command(cmd("request:e6", "stadium.commit", O{{"quoteId", at(quote, "id")}, {"accept", true}, {"tip", false}}), rev); if (s(at(done, "messageType")) != "command_result") std::fprintf(stderr, "facility build: %s\n", cli::dump_json(done).c_str()); check(s(at(done, "messageType")) == "command_result" && rev == b0 + 2, "facility ordered"); } else { std::printf("(facility quote: %s)\n", s(at(q, "code")).c_str()); } const J q2 = session.ui_command(cmd("request:e7", "quote.request", O{{"kind", "facility"}, {"facilityId", "facility:comfort"}, {"increment", 1}}), rev); if (s(at(q2, "messageType")) == "command_result") { const J declined = session.ui_command(cmd("request:e8", "stadium.commit", O{{"quoteId", at(quote_of(), "id")}, {"accept", false}}), rev); check(s(at(declined, "messageType")) == "command_result" && std::holds_alternative(quote_of().value), "facility offer declined, the stadium closed"); } } } // session.advance: three kickoffs, each one revision, the date moves on { const std::string date_before = s(at(at(session.ui_read(O{{"kind", "desktop"}}, rev), "meta"), "date")); for (int k = 0; k < 3; ++k) { const uint64_t before = rev; const J done = session.ui_command(cmd("request:a" + std::to_string(k), "session.advance", O{}), rev); if (s(at(done, "messageType")) != "command_result") std::fprintf(stderr, "advance: %s\n", cli::dump_json(done).c_str()); check(s(at(done, "messageType")) == "command_result" && rev == before + 1, "advance accepted"); } const std::string date_after = s(at(at(session.ui_read(O{{"kind", "desktop"}}, rev), "meta"), "date")); check(date_after > date_before, "the date moved on"); } // a season of kickoffs: running-out contracts stop the run with decision_pending and the // player; the advance is sent again with the answer (here: release) { O expiry; int decisions = 0, advances = 0; for (int k = 0; k < 200 && advances < 120; ++k) { const uint64_t before = rev; const J done = session.ui_command(cmd("request:s" + std::to_string(k), "session.advance", O{{"contractExpiry", expiry}}), rev); if (s(at(done, "messageType")) == "command_result") { ++advances; continue; } const std::string code = s(at(done, "code")); const std::string player = s(at(at(at(done, "message"), "args"), "playerId")); check(code == "decision_pending" && !player.empty() && rev == before, "a pending contract names the player, nothing changed"); if (code != "decision_pending" || player.empty() || expiry.count(player)) break; expiry[player] = O{{"action", "release"}}; ++decisions; } check(advances == 120, "two seasons of kickoffs with answered contract decisions"); check(decisions > 0, "running-out contracts were asked for"); std::printf("(date now %s)\n", s(at(at(session.ui_read(O{{"kind", "desktop"}}, rev), "meta"), "date")).c_str()); std::printf("(%d contract decisions answered)\n", decisions); } // almanac view after the kickoffs: index, calendar, day, match { const J index = session.read_almanac(O{{"kind", "index"}}); const auto* years = at(index, "years").array(); check(truth(at(index, "ok")) && years && !years->empty() && *at(index, "match_count").integer() > 0, "almanac index"); const J cal = years && !years->empty() ? session.read_almanac(O{{"kind", "calendar"}, {"year", (*years)[0]}}) : J{}; const auto* days = at(cal, "days").array(); check(days && !days->empty(), "almanac calendar"); const J day = days && !days->empty() ? session.read_almanac(O{{"kind", "day"}, {"date", at((*days)[0], "date")}}) : J{}; const auto* matches = at(day, "matches").array(); check(matches && !matches->empty(), "almanac day"); if (matches && !matches->empty()) { const J& m = (*matches)[0]; const auto* final_score = at(at(m, "result"), "final").array(); check(final_score && final_score->size() == 2 && at(at(m, "home"), "id").string() && at(m, "events").array(), "almanac match form"); const J one = session.read_almanac(O{{"kind", "match"}, {"id", at(m, "id")}}); check(truth(at(one, "ok")) && s(at(at(one, "match"), "id")) == s(at(m, "id")), "almanac match by id"); } check(s(at(session.read_almanac(O{{"kind", "match"}, {"id", "match:0-0"}}), "error")) == "almanac_match_not_found", "unknown match"); // the statistics screen: real data (fictional false), unrecorded views say so // (the club views need a club desk: on an international day the manager sits at the national one) const J minutes = session.read_statistics_screen(O{{"section", 8}}); const bool club_desk = !std::holds_alternative(at(minutes, "club").value); check(truth(at(minutes, "ok")) && !truth(at(minutes, "fictional")) && (!club_desk || (at(minutes, "rows").array() && at(minutes, "rows").array()->size() == 4)), "minute statistics"); const J transfers = session.read_statistics_screen(O{{"section", 0}}); check(truth(at(transfers, "ok")) && !truth(at(transfers, "available")) && s(at(transfers, "reason")) == "not_recorded", "title chances not recorded"); check(s(at(session.read_statistics_screen(O{{"section", 9}}), "error")) == "invalid_statistics_filter", "bad section"); const J curves = session.read_statistics_screen(O{{"section", 2}}); check(!club_desk || (at(curves, "series").array() && at(curves, "series").array()->size() == 6), "the six curves of the original"); } } catch (const std::exception& ex) { std::fprintf(stderr, "FAIL: %s\n", ex.what()); return 1; } if (failures == 0) std::printf("modern ui contract tests passed\n"); return failures == 0 ? 0 : 1; }