247 lines
10 KiB
C++
247 lines
10 KiB
C++
// Smoke test de la FSM de sala (RoomFsm) extreta de GameScene. Cobreix:
|
|
// T1 loadConfig — fitxer real → tots els camps llegits.
|
|
// T2 loadConfig — fitxer absent → fallbacks compilats; corbes default
|
|
// resoltes per UiConfig::curveByName.
|
|
// T3 loadConfig — claus parcials → camps absents conserven fallback.
|
|
// T4 advance — ROOM_INTRO consumeix les 5 sub-fases en ordre.
|
|
// T5 advance — ROOM_INTRO desemboca a PLAYING quan acaba l'última fase.
|
|
// T6 advance — PLAYING és sumidor: no avança res ni canvia d'estat.
|
|
// T7 advance — ROOM_OUTRO consumeix les 4 sub-fases i recau a ROOM_INTRO.
|
|
// T8 advance — un delta gran salta més d'una sub-fase en un sol pas.
|
|
// T9 formatIntroPyramidLine / formatIntroRoomLine — substitució amb Locale.
|
|
// T10 formatIntroPyramidLine / formatIntroRoomLine — fallback sense Locale.
|
|
// T11 stateName — strings esperats per a cada State.
|
|
//
|
|
// El render no es testeja: la FSM és pura i no pinta res. Les regles de
|
|
// gating d'input dels jugadors viuen a `GameScene::update` i estan
|
|
// cobertes pel smoke run del binari (xvfb-run) — la part testable és
|
|
// que `advance` retorna l'estat correcte, que és el senyal que activa
|
|
// el gating al callsite.
|
|
//
|
|
// Execució:
|
|
// make build && cd build && ctest --output-on-failure
|
|
// O bé:
|
|
// ./build/test_game_fsm
|
|
|
|
#include <cstdio>
|
|
#include <filesystem>
|
|
#include <fstream>
|
|
#include <iostream>
|
|
#include <string>
|
|
|
|
#include "core/locale/locale.hpp"
|
|
#include "core/ui/ui_config.hpp"
|
|
#include "game/scenes/room_fsm.hpp"
|
|
|
|
namespace {
|
|
|
|
int g_failures = 0;
|
|
|
|
void check(bool cond, const char* msg, const char* file, int line) {
|
|
if (!cond) {
|
|
std::cerr << " FAIL: " << msg << " (" << file << ":" << line << ")\n";
|
|
++g_failures;
|
|
}
|
|
}
|
|
|
|
#define CHECK(cond) check((cond), #cond, __FILE__, __LINE__)
|
|
|
|
auto writeTemp(const std::string& path, const std::string& content) -> std::string {
|
|
std::ofstream file(path);
|
|
file << content;
|
|
return path;
|
|
}
|
|
|
|
void testLoadConfigFull() {
|
|
std::cout << "T1 loadConfig — fitxer real complet\n";
|
|
const auto PATH = (std::filesystem::temp_directory_path() / "aee_test_full.yaml").string();
|
|
writeTemp(PATH,
|
|
"room_intro:\n"
|
|
" fade_in_ms: 100\n"
|
|
" text_delay_ms: 200\n"
|
|
" text_enter_ms: 300\n"
|
|
" text_hold_ms: 400\n"
|
|
" text_exit_ms: 500\n"
|
|
"room_outro:\n"
|
|
" text_enter_ms: 600\n"
|
|
" text_hold_ms: 700\n"
|
|
" text_exit_ms: 800\n"
|
|
" fade_out_ms: 900\n"
|
|
"text:\n"
|
|
" enter_curve: outQuad\n"
|
|
" exit_curve: inQuad\n");
|
|
const auto CFG = RoomFsm::loadConfig(PATH);
|
|
CHECK(CFG.intro_fade_in_ms == 100);
|
|
CHECK(CFG.intro_text_delay_ms == 200);
|
|
CHECK(CFG.intro_text_enter_ms == 300);
|
|
CHECK(CFG.intro_text_hold_ms == 400);
|
|
CHECK(CFG.intro_text_exit_ms == 500);
|
|
CHECK(CFG.outro_text_enter_ms == 600);
|
|
CHECK(CFG.outro_text_hold_ms == 700);
|
|
CHECK(CFG.outro_text_exit_ms == 800);
|
|
CHECK(CFG.outro_fade_out_ms == 900);
|
|
CHECK(CFG.text_enter_curve == UiConfig::curveByName("outQuad"));
|
|
CHECK(CFG.text_exit_curve == UiConfig::curveByName("inQuad"));
|
|
std::filesystem::remove(PATH);
|
|
}
|
|
|
|
void testLoadConfigMissing() {
|
|
std::cout << "T2 loadConfig — fitxer absent (fallbacks)\n";
|
|
const auto CFG = RoomFsm::loadConfig("/tmp/aee_arcade_does_not_exist.yaml");
|
|
CHECK(CFG.intro_fade_in_ms == 500);
|
|
CHECK(CFG.intro_text_delay_ms == 500);
|
|
CHECK(CFG.intro_text_enter_ms == 500);
|
|
CHECK(CFG.intro_text_hold_ms == 1000);
|
|
CHECK(CFG.intro_text_exit_ms == 500);
|
|
CHECK(CFG.outro_text_enter_ms == 500);
|
|
CHECK(CFG.outro_text_hold_ms == 1000);
|
|
CHECK(CFG.outro_text_exit_ms == 500);
|
|
CHECK(CFG.outro_fade_out_ms == 500);
|
|
CHECK(CFG.text_enter_curve != nullptr);
|
|
CHECK(CFG.text_exit_curve != nullptr);
|
|
}
|
|
|
|
void testLoadConfigPartial() {
|
|
std::cout << "T3 loadConfig — claus parcials (mantenir fallback)\n";
|
|
const auto PATH = (std::filesystem::temp_directory_path() / "aee_test_partial.yaml").string();
|
|
writeTemp(PATH,
|
|
"room_intro:\n"
|
|
" fade_in_ms: 42\n");
|
|
const auto CFG = RoomFsm::loadConfig(PATH);
|
|
CHECK(CFG.intro_fade_in_ms == 42);
|
|
CHECK(CFG.intro_text_delay_ms == 500); // fallback
|
|
CHECK(CFG.outro_fade_out_ms == 500); // fallback
|
|
std::filesystem::remove(PATH);
|
|
}
|
|
|
|
auto makeShortConfig() -> RoomFsm::Config {
|
|
// Durades curtes per fer els tests d'`advance` deterministes i
|
|
// independents dels valors per defecte.
|
|
RoomFsm::Config cfg{};
|
|
cfg.intro_fade_in_ms = 10;
|
|
cfg.intro_text_delay_ms = 20;
|
|
cfg.intro_text_enter_ms = 30;
|
|
cfg.intro_text_hold_ms = 40;
|
|
cfg.intro_text_exit_ms = 50;
|
|
cfg.outro_text_enter_ms = 11;
|
|
cfg.outro_text_hold_ms = 22;
|
|
cfg.outro_text_exit_ms = 33;
|
|
cfg.outro_fade_out_ms = 44;
|
|
return cfg;
|
|
}
|
|
|
|
void testAdvanceIntroPhases() {
|
|
std::cout << "T4 advance — ROOM_INTRO consumeix sub-fases en ordre\n";
|
|
const auto CFG = makeShortConfig();
|
|
RoomFsm::Transition t{};
|
|
auto s = RoomFsm::State::ROOM_INTRO;
|
|
|
|
s = RoomFsm::advance(s, t, CFG, 5); // dins fase 0
|
|
CHECK(s == RoomFsm::State::ROOM_INTRO && t.phase == 0 && t.elapsed_ms == 5);
|
|
|
|
s = RoomFsm::advance(s, t, CFG, 10); // surt de fase 0, entra a fase 1 (5 ms dins)
|
|
CHECK(s == RoomFsm::State::ROOM_INTRO && t.phase == 1 && t.elapsed_ms == 5);
|
|
|
|
s = RoomFsm::advance(s, t, CFG, 20); // surt de fase 1 (15 dins), entra a fase 2 amb 5 ms (5+20-20=5)
|
|
CHECK(s == RoomFsm::State::ROOM_INTRO && t.phase == 2 && t.elapsed_ms == 5);
|
|
}
|
|
|
|
void testAdvanceIntroToPlaying() {
|
|
std::cout << "T5 advance — ROOM_INTRO acaba a PLAYING\n";
|
|
const auto CFG = makeShortConfig();
|
|
RoomFsm::Transition t{};
|
|
const int TOTAL = CFG.intro_fade_in_ms + CFG.intro_text_delay_ms +
|
|
CFG.intro_text_enter_ms + CFG.intro_text_hold_ms +
|
|
CFG.intro_text_exit_ms;
|
|
const auto S = RoomFsm::advance(RoomFsm::State::ROOM_INTRO, t, CFG, TOTAL);
|
|
CHECK(S == RoomFsm::State::PLAYING);
|
|
}
|
|
|
|
void testAdvancePlayingNoOp() {
|
|
std::cout << "T6 advance — PLAYING és sumidor\n";
|
|
const auto CFG = makeShortConfig();
|
|
RoomFsm::Transition t{42, 999};
|
|
const auto S = RoomFsm::advance(RoomFsm::State::PLAYING, t, CFG, 1000);
|
|
CHECK(S == RoomFsm::State::PLAYING);
|
|
CHECK(t.phase == 42); // intacte
|
|
CHECK(t.elapsed_ms == 999);
|
|
}
|
|
|
|
void testAdvanceOutroToIntro() {
|
|
std::cout << "T7 advance — ROOM_OUTRO recau a ROOM_INTRO\n";
|
|
const auto CFG = makeShortConfig();
|
|
RoomFsm::Transition t{};
|
|
const int TOTAL = CFG.outro_text_enter_ms + CFG.outro_text_hold_ms +
|
|
CFG.outro_text_exit_ms + CFG.outro_fade_out_ms;
|
|
const auto S = RoomFsm::advance(RoomFsm::State::ROOM_OUTRO, t, CFG, TOTAL);
|
|
CHECK(S == RoomFsm::State::ROOM_INTRO);
|
|
}
|
|
|
|
void testAdvanceLargeDeltaJumps() {
|
|
std::cout << "T8 advance — un delta gran salta múltiples sub-fases\n";
|
|
const auto CFG = makeShortConfig();
|
|
RoomFsm::Transition t{};
|
|
// 10+20+5 = 35 ms → consumeix fase 0 i 1, queda a fase 2 amb 5 ms.
|
|
const auto S = RoomFsm::advance(RoomFsm::State::ROOM_INTRO, t, CFG, 35);
|
|
CHECK(S == RoomFsm::State::ROOM_INTRO);
|
|
CHECK(t.phase == 2);
|
|
CHECK(t.elapsed_ms == 5);
|
|
}
|
|
|
|
void testFormatRoomTitleWithLocale() {
|
|
std::cout << "T9 formatIntroPyramidLine / formatIntroRoomLine — substitució amb Locale\n";
|
|
const auto PATH = (std::filesystem::temp_directory_path() / "aee_test_locale.yaml").string();
|
|
writeTemp(PATH,
|
|
"game:\n"
|
|
" room_intro_pyramid: \"Piramide {p}\"\n"
|
|
" room_intro_room: \"Sala {r}\"\n");
|
|
Locale::get().load(PATH);
|
|
CHECK(RoomFsm::formatIntroPyramidLine(1) == "Piramide 1");
|
|
CHECK(RoomFsm::formatIntroPyramidLine(5) == "Piramide 5");
|
|
CHECK(RoomFsm::formatIntroRoomLine(1) == "Sala 1");
|
|
CHECK(RoomFsm::formatIntroRoomLine(7) == "Sala 7");
|
|
std::filesystem::remove(PATH);
|
|
}
|
|
|
|
void testFormatRoomTitleNoLocale() {
|
|
std::cout << "T10 formatIntroPyramidLine / formatIntroRoomLine — fallback sense traducció\n";
|
|
const auto PATH = (std::filesystem::temp_directory_path() / "aee_test_locale_empty.yaml").string();
|
|
writeTemp(PATH, "other: foo\n");
|
|
Locale::get().load(PATH);
|
|
// Sense les claus, Locale retorna la pròpia clau i com que no
|
|
// porten `{p}`/`{r}`, la substitució no canvia res.
|
|
CHECK(RoomFsm::formatIntroPyramidLine(3) == "game.room_intro_pyramid");
|
|
CHECK(RoomFsm::formatIntroRoomLine(2) == "game.room_intro_room");
|
|
std::filesystem::remove(PATH);
|
|
}
|
|
|
|
void testStateName() {
|
|
std::cout << "T11 stateName — strings esperats\n";
|
|
CHECK(std::string(RoomFsm::stateName(RoomFsm::State::ROOM_INTRO)) == "ROOM_INTRO");
|
|
CHECK(std::string(RoomFsm::stateName(RoomFsm::State::PLAYING)) == "PLAYING");
|
|
CHECK(std::string(RoomFsm::stateName(RoomFsm::State::ROOM_OUTRO)) == "ROOM_OUTRO");
|
|
}
|
|
|
|
} // namespace
|
|
|
|
auto main() -> int {
|
|
testLoadConfigFull();
|
|
testLoadConfigMissing();
|
|
testLoadConfigPartial();
|
|
testAdvanceIntroPhases();
|
|
testAdvanceIntroToPlaying();
|
|
testAdvancePlayingNoOp();
|
|
testAdvanceOutroToIntro();
|
|
testAdvanceLargeDeltaJumps();
|
|
testFormatRoomTitleWithLocale();
|
|
testFormatRoomTitleNoLocale();
|
|
testStateName();
|
|
|
|
if (g_failures == 0) {
|
|
std::cout << "OK: tots els tests de RoomFsm passen\n";
|
|
return 0;
|
|
}
|
|
std::cerr << g_failures << " tests han fallat\n";
|
|
return 1;
|
|
}
|