Leahnaya/pokeemerald
1
0
Fork 0
mirror of https://github.com/pret/pokeemerald.git synced 2026-04-25 15:57:29 -05:00
Code Issues Actions Packages Projects Releases Wiki Activity

Adds EXPECT_FAIL macro to test system to allow for testing of conditions correctly triggering failures (#8553)

Browse Source
This commit is contained in:
grintoul 2025-12-28 10:21:02 +00:00 committed by GitHub
parent 0bdc20b102
commit 6e9f8998b4
No known key found for this signature in database
GPG Key ID: B5690EEEBB952194
7 changed files with 354 additions and 116 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

15
include/test/test.h
View File

@ -37,6 +37,16 @@ enum TestFilterMode
TEST_FILTER_MODE_FILENAME_EXACT,
};
enum ExpectFailState
{
NO_EXPECT_FAIL,
EXPECT_FAIL_OPEN,
EXPECT_FAIL_TURN_OPEN,
EXPECT_FAIL_SCENE_OPEN,
EXPECT_FAIL_SUCCESS,
EXPECT_FAIL_CLOSED
};
struct TestRunnerState
{
u8 state;
@ -53,6 +63,8 @@ struct TestRunnerState
bool8 inBenchmark:1;
bool8 tearDown:1;
u32 timeoutSeconds;
s32 expectedFailLine;
enum ExpectFailState expectedFailState;
};
struct PersistentTestRunnerState
@ -94,6 +106,7 @@ void CB2_TestRunner(void);
void Test_ExpectedResult(enum TestResult);
void Test_ExpectLeaks(bool32);
void Test_ExpectCrash(bool32);
void Test_ExpectFail(u32 failLine);
u32 SourceLine(u32 sourceLineOffset);
u32 SourceLineOffset(u32 sourceLine);
void SetupRiggedRng(u32 sourceLine, enum RandomTag randomTag, u32 value);
@ -242,6 +255,8 @@ static inline struct Benchmark BenchmarkStop(void)
#define KNOWN_CRASHING \
Test_ExpectCrash(TRUE)
#define EXPECT_FAIL for (u32 _expect_fail = (Test_ExpectFail(-1), 1); _expect_fail; Test_ExpectFail(__LINE__), _expect_fail = 0)
#define PARAMETRIZE if (gFunctionTestRunnerState->parameters++ == gFunctionTestRunnerState->runParameter)
#define PARAMETRIZE_LABEL(f, label) if (gFunctionTestRunnerState->parameters++ == gFunctionTestRunnerState->runParameter && (Test_MgbaPrintf(":N%s: " f " (%d/%d)", gTestRunnerState.test->name, label, gFunctionTestRunnerState->runParameter + 1, gFunctionTestRunnerState->parameters), 1))

3
test/battle/move_effect/revival_blessing.c
View File

@ -49,8 +49,7 @@ SINGLE_BATTLE_TEST("Revival Blessing fails if no party members are fainted")
}
}
// Can only be tested through AI test, else test fails due to trying to force illegal action
AI_MULTI_BATTLE_TEST("Revival Blessing cannot revive a partner's party member")
AI_MULTI_BATTLE_TEST("AI will not revive a partner's party member with Revival Blessing")
{
struct BattlePokemon *user = NULL;
u32 move1, move2, move3;

107
test/battle/move_effect/substitute.c
View File

@ -69,111 +69,4 @@ SINGLE_BATTLE_TEST("Substitute's HP cost doesn't trigger effects that trigger on
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT")
{
GIVEN {
PLAYER(SPECIES_WOBBUFFET);
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player);
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT, break TRUE")
{
GIVEN {
PLAYER(SPECIES_WOBBUFFET) { Level(1); }
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player, subBreak: TRUE);
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT, break FALSE")
{
GIVEN {
PLAYER(SPECIES_WOBBUFFET) { Level(100); }
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player, subBreak: FALSE);
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT, records damage")
{
u16 damage;
GIVEN {
PLAYER(SPECIES_WOBBUFFET);
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player, captureDamage: &damage);
} THEN {
EXPECT_GT(damage, 0);
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT, records damage, break FALSE")
{
u16 damage;
GIVEN {
PLAYER(SPECIES_WOBBUFFET);
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player, captureDamage: &damage, subBreak: FALSE);
} THEN {
EXPECT_GT(damage, 0);
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT, records damage, break TRUE")
{
u16 damage;
GIVEN {
PLAYER(SPECIES_WOBBUFFET) { Level(1); }
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player, captureDamage: &damage, subBreak: TRUE);
} THEN {
EXPECT_GT(damage, 0);
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT, break TRUE, failing")
{
KNOWN_FAILING; // For testing purposes
GIVEN {
PLAYER(SPECIES_WOBBUFFET) { Level(100); }
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player, subBreak: TRUE);
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT, break FALSE, failing")
{
KNOWN_FAILING; // For testing purposes
GIVEN {
PLAYER(SPECIES_WOBBUFFET) { Level(1); }
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player, subBreak: FALSE);
}
}
TO_DO_BATTLE_TEST("Baton Pass passes Substitutes");

112
test/test_runner.c
View File

@ -161,6 +161,9 @@ void TestRunner_CheckMemory(void)
{
Test_MgbaPrintf("%s: %d bytes not freed", location, block->size);
gTestRunnerState.result = TEST_RESULT_FAIL;
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SUCCESS;
break;
}
}
@ -169,6 +172,9 @@ void TestRunner_CheckMemory(void)
{
Test_MgbaPrintf("<unknown>: %d bytes not freed", block->size);
gTestRunnerState.result = TEST_RESULT_FAIL;
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SUCCESS;
}
}
block = block->next;
@ -181,6 +187,9 @@ void TestRunner_CheckMemory(void)
{
Test_MgbaPrintf(":L%s:%d - %p: task not freed", gTestRunnerState.test->filename, SourceLine(0), gTasks[i].func);
gTestRunnerState.result = TEST_RESULT_FAIL;
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SUCCESS;
}
}
}
@ -248,6 +257,9 @@ top:
if (gPersistentTestRunnerState.expectCrash)
gTestRunnerState.expectedResult = TEST_RESULT_CRASH;
gTestRunnerState.expectedFailLine = 0;
gTestRunnerState.expectedFailState = NO_EXPECT_FAIL;
}
else
{
@ -286,6 +298,8 @@ top:
gTestRunnerState.result = TEST_RESULT_PASS;
gTestRunnerState.expectedResult = TEST_RESULT_PASS;
gTestRunnerState.expectLeaks = FALSE;
gTestRunnerState.expectedFailLine = 0;
gTestRunnerState.expectedFailState = NO_EXPECT_FAIL;
if (gTestRunnerHeadless)
gTestRunnerState.timeoutSeconds = TIMEOUT_SECONDS;
else
@ -356,8 +370,23 @@ top:
{
const char *color;
const char *result;
bool32 expectedFailOnCorrectLine = FALSE;
if (gTestRunnerState.result == gTestRunnerState.expectedResult
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_SUCCESS)
{
// Failed within expected block; pass
expectedFailOnCorrectLine = TRUE;
color = "\e[32m";
Test_MgbaPrintf(":N%s", gTestRunnerState.test->name);
}
else if (gTestRunnerState.expectedFailState == EXPECT_FAIL_CLOSED
&& gTestRunnerState.result == TEST_RESULT_FAIL)
{
// Failed outside expected block; fail
gTestRunnerState.exitCode = 1;
color = "\e[31m";
}
else if (gTestRunnerState.result == gTestRunnerState.expectedResult
|| (gTestRunnerState.result == TEST_RESULT_FAIL
&& gTestRunnerState.expectedResult == TEST_RESULT_KNOWN_FAIL))
{
@ -382,14 +411,29 @@ top:
result = "KNOWN_FAILING";
color = "\e[33m";
}
else if (expectedFailOnCorrectLine)
{
color = "\e[32m";
result = "EXPECTED_FAIL";
}
else if (gTestRunnerState.expectedResult == TEST_RESULT_FAIL
&& gTestRunnerState.expectedFailState != EXPECT_FAIL_SUCCESS)
{
// Failed on wrong line
result = "UNEXPECTED_FAIL_LINE";
}
else
{
result = "FAIL";
}
break;
case TEST_RESULT_PASS:
if (gTestRunnerState.result != gTestRunnerState.expectedResult)
if (gTestRunnerState.result != gTestRunnerState.expectedResult
&& gTestRunnerState.expectedFailLine == 0)
result = "KNOWN_FAILING_PASS";
else if (gTestRunnerState.result != gTestRunnerState.expectedResult
&& gTestRunnerState.expectedFailLine != 0)
result = "EXPECTED_FAIL_PASS";
else
result = "PASS";
break;
@ -423,25 +467,39 @@ top:
if (gTestRunnerState.result != gTestRunnerState.expectedResult)
{
Test_MgbaPrintf(":L%s:%d", gTestRunnerState.test->filename, SourceLine(0));
Test_MgbaPrintf(":U%s%s\e[0m", color, result);
if (gTestRunnerState.expectedFailLine == 0)
Test_MgbaPrintf(":U%s%s\e[0m", color, result);
else
Test_MgbaPrintf(":V%s%s\e[0m", color, result);
}
else
{
Test_MgbaPrintf(":P%s%s\e[0m", color, result);
}
}
else if (expectedFailOnCorrectLine)
Test_MgbaPrintf(":E%s%s\e[0m", color, result);
else if (gTestRunnerState.result == TEST_RESULT_ASSUMPTION_FAIL)
Test_MgbaPrintf(":A%s%s\e[0m", color, result);
else if (gTestRunnerState.result == TEST_RESULT_TODO)
Test_MgbaPrintf(":T%s%s\e[0m", color, result);
else if (gTestRunnerState.expectedResult == gTestRunnerState.result
&& gTestRunnerState.result == TEST_RESULT_CRASH)
Test_MgbaPrintf(":E%s%s\e[0m", color, result);
else if (gTestRunnerState.expectedResult == gTestRunnerState.result
&& gTestRunnerState.result == TEST_RESULT_FAIL
&& gTestRunnerState.expectedFailLine == 0)
Test_MgbaPrintf(":K%s%s\e[0m", color, result);
else if ((gTestRunnerState.expectedResult == gTestRunnerState.result
&& gTestRunnerState.expectedFailState == NO_EXPECT_FAIL)
|| (gTestRunnerState.result == TEST_RESULT_FAIL
&& gTestRunnerState.expectedResult == TEST_RESULT_KNOWN_FAIL))
Test_MgbaPrintf(":K%s%s\e[0m", color, result);
else
Test_MgbaPrintf(":F%s%s\e[0m", color, result);
}
gTestRunnerState.expectedFailLine = 0;
gTestRunnerState.expectedFailState = NO_EXPECT_FAIL;
break;
case STATE_NEXT_TEST:
@ -480,6 +538,26 @@ void Test_ExpectCrash(bool32 expectCrash)
Test_ExpectedResult(TEST_RESULT_CRASH);
}
void Test_ExpectFail(u32 failLine)
{
// If expecting a fail and fail has not already been encountered
if ((gTestRunnerState.expectedFailState != EXPECT_FAIL_SUCCESS)
&& (gTestRunnerState.expectedFailState != EXPECT_FAIL_TURN_OPEN)
&& (gTestRunnerState.expectedFailState != EXPECT_FAIL_SCENE_OPEN))
{
if (failLine == -1)
{
Test_ExpectedResult(TEST_RESULT_FAIL);
gTestRunnerState.expectedFailState = EXPECT_FAIL_OPEN;
}
else
{
gTestRunnerState.expectedFailLine = failLine;
gTestRunnerState.expectedFailState = EXPECT_FAIL_CLOSED;
}
}
}
static void FunctionTest_SetUp(void *data)
{
(void)data;
@ -658,6 +736,32 @@ void Test_ExitWithResult_(enum TestResult result, u32 stopLine, const void *retu
{
gTestRunnerState.result = result;
gTestRunnerState.failedAssumptionsBlockLine = stopLine;
if (result == TEST_RESULT_FAIL)
{
switch (gTestRunnerState.expectedFailState)
{
case EXPECT_FAIL_OPEN:
case EXPECT_FAIL_TURN_OPEN:
gTestRunnerState.expectedFailState = EXPECT_FAIL_SUCCESS;
break;
case EXPECT_FAIL_SCENE_OPEN: // EXPECT_FAIL_SUCCESS set in individual Queue functions
gTestRunnerState.expectedFailState = EXPECT_FAIL_CLOSED;
break;
default:
break;
}
}
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_CLOSED
&& gTestRunnerState.expectedResult == TEST_RESULT_FAIL
&& result == TEST_RESULT_FAIL)
{
Test_MgbaPrintf(":L%s:%d: Expected failure in block from line %d, but failed on line %d",
gTestRunnerState.test->filename, stopLine,
gTestRunnerState.expectedFailLine, stopLine);
}
ReinitCallbacks();
if (gTestRunnerState.state == STATE_REPORT_RESULT
&& gTestRunnerState.result != gTestRunnerState.expectedResult)

48
test/test_runner_battle.c
View File

@ -843,6 +843,8 @@ void TestRunner_Battle_RecordAbilityPopUp(u32 battlerId, enum Ability ability)
{
const char *filename = gTestRunnerState.test->filename;
u32 line = SourceLine(DATA.queuedEvents[match].sourceLineOffset);
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_SCENE_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SUCCESS;
Test_ExitWithResult(TEST_RESULT_FAIL, line, ":L%s:%d: Matched ABILITY_POPUP", filename, line);
}
@ -906,6 +908,8 @@ void TestRunner_Battle_RecordAnimation(u32 animType, u32 animId)
{
const char *filename = gTestRunnerState.test->filename;
u32 line = SourceLine(DATA.queuedEvents[match].sourceLineOffset);
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_SCENE_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SUCCESS;
Test_ExitWithResult(TEST_RESULT_FAIL, line, ":L%s:%d: Matched ANIMATION", filename, line);
}
@ -996,6 +1000,8 @@ void TestRunner_Battle_RecordHP(u32 battlerId, u32 oldHP, u32 newHP)
{
const char *filename = gTestRunnerState.test->filename;
u32 line = SourceLine(DATA.queuedEvents[match].sourceLineOffset);
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_SCENE_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SUCCESS;
Test_ExitWithResult(TEST_RESULT_FAIL, line, ":L%s:%d: Matched HP_BAR", filename, line);
}
@ -1075,6 +1081,8 @@ void TestRunner_Battle_RecordSubHit(u32 battlerId, u32 damage, bool32 broke)
{
const char *filename = gTestRunnerState.test->filename;
u32 line = SourceLine(DATA.queuedEvents[match].sourceLineOffset);
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_SCENE_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SUCCESS;
Test_ExitWithResult(TEST_RESULT_FAIL, line, ":L%s:%d: Matched SUB_HIT", filename, line);
}
@ -1473,6 +1481,8 @@ void TestRunner_Battle_RecordExp(u32 battlerId, u32 oldExp, u32 newExp)
{
const char *filename = gTestRunnerState.test->filename;
u32 line = SourceLine(DATA.queuedEvents[match].sourceLineOffset);
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_SCENE_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SUCCESS;
Test_ExitWithResult(TEST_RESULT_FAIL, line, ":L%s:%d: Matched EXPERIENCE_BAR", filename, line);
}
@ -1563,6 +1573,8 @@ void TestRunner_Battle_RecordMessage(const u8 *string)
{
const char *filename = gTestRunnerState.test->filename;
u32 line = SourceLine(DATA.queuedEvents[match].sourceLineOffset);
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_SCENE_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SUCCESS;
Test_ExitWithResult(TEST_RESULT_FAIL, line, ":L%s:%d: Matched MESSAGE", filename, line);
}
@ -1628,6 +1640,8 @@ void TestRunner_Battle_RecordStatus1(u32 battlerId, u32 status1)
{
const char *filename = gTestRunnerState.test->filename;
u32 line = SourceLine(DATA.queuedEvents[match].sourceLineOffset);
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_SCENE_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SUCCESS;
Test_ExitWithResult(TEST_RESULT_FAIL, line, ":L%s:%d: Matched STATUS_ICON", filename, line);
}
@ -1677,6 +1691,8 @@ void TestRunner_Battle_AfterLastTurn(void)
const char *filename = gTestRunnerState.test->filename;
u32 line = SourceLine(DATA.queuedEvents[DATA.trial.queuedEvent].sourceLineOffset);
const char *macro = sEventTypeMacros[DATA.queuedEvents[DATA.trial.queuedEvent].type];
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_SCENE_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SUCCESS;
Test_ExitWithResult(TEST_RESULT_FAIL, line, ":L%s:%d: Unmatched %s", filename, line, macro);
}
@ -1704,6 +1720,7 @@ static void TearDownBattle(void)
FreeBattleSpritesData();
FreeBattleResources();
FreeAllWindowBuffers();
gMain.inBattle = FALSE; // Necessary else some tests report incorrect results when running in same thread as an EXPECT_FAIL test
}
static void CB2_BattleTest_NextParameter(void)
@ -2789,6 +2806,9 @@ static void TryMarkExpectMove(u32 sourceLine, struct BattlePokemon *battler, str
DATA.actionBattlers |= 1 << battlerId;
DATA.moveBattlers |= 1 << battlerId;
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_TURN_OPEN;
}
void ExpectMove(u32 sourceLine, struct BattlePokemon *battler, struct MoveContext ctx)
@ -2828,6 +2848,9 @@ void ExpectSendOut(u32 sourceLine, struct BattlePokemon *battler, u32 partyIndex
DATA.expectedAiActions[battlerId][id].sourceLine = sourceLine;
DATA.expectedAiActions[battlerId][id].actionSet = TRUE;
DATA.expectedAiActionIndex[battlerId]++;
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_TURN_OPEN;
}
s32 GetAiMoveTargetForScoreCompare(u32 battlerId, u32 moveId, struct MoveContext *ctx, u32 sourceLine)
@ -2959,6 +2982,9 @@ void ExpectSwitch(u32 sourceLine, struct BattlePokemon *battler, u32 partyIndex)
DATA.expectedAiActions[battlerId][id].sourceLine = sourceLine;
DATA.expectedAiActions[battlerId][id].actionSet = TRUE;
DATA.expectedAiActionIndex[battlerId]++;
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_TURN_OPEN;
}
void SkipTurn(u32 sourceLine, struct BattlePokemon *battler)
@ -3065,6 +3091,10 @@ void CloseQueueGroup(u32 sourceLine)
void QueueAbility(u32 sourceLine, struct BattlePokemon *battler, struct AbilityEventContext ctx)
{
s32 battlerId = battler - gBattleMons;
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SCENE_OPEN;
INVALID_IF(!STATE->runScene, "ABILITY_POPUP outside of SCENE");
if (DATA.queuedEventsCount == MAX_QUEUED_EVENTS)
Test_ExitWithResult(TEST_RESULT_ERROR, sourceLine, ":L%s:%d: ABILITY exceeds MAX_QUEUED_EVENTS", gTestRunnerState.test->filename, sourceLine);
@ -3084,6 +3114,9 @@ void QueueAnimation(u32 sourceLine, u32 type, u32 id, struct AnimationEventConte
{
s32 attackerId, targetId;
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SCENE_OPEN;
INVALID_IF(!STATE->runScene, "ANIMATION outside of SCENE");
if (DATA.queuedEventsCount == MAX_QUEUED_EVENTS)
Test_ExitWithResult(TEST_RESULT_ERROR, sourceLine, ":L%s:%d: ANIMATION exceeds MAX_QUEUED_EVENTS", gTestRunnerState.test->filename, sourceLine);
@ -3119,6 +3152,9 @@ void QueueHP(u32 sourceLine, struct BattlePokemon *battler, struct HPEventContex
u32 type;
uintptr_t address;
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SCENE_OPEN;
INVALID_IF(!STATE->runScene, "HP_BAR outside of SCENE");
if (DATA.queuedEventsCount == MAX_QUEUED_EVENTS)
Test_ExitWithResult(TEST_RESULT_ERROR, sourceLine, ":L%s:%d: HP_BAR exceeds MAX_QUEUED_EVENTS", gTestRunnerState.test->filename, sourceLine);
@ -3173,6 +3209,9 @@ void QueueSubHit(u32 sourceLine, struct BattlePokemon *battler, struct SubHitEve
bool32 checkBreak = FALSE;
uintptr_t address;
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SCENE_OPEN;
INVALID_IF(!STATE->runScene, "SUB_HIT outside of SCENE");
if (DATA.queuedEventsCount == MAX_QUEUED_EVENTS)
Test_ExitWithResult(TEST_RESULT_ERROR, sourceLine, ":L%s:%d: SUB_HIT exceeds MAX_QUEUED_EVENTS", gTestRunnerState.test->filename, sourceLine);
@ -3212,6 +3251,9 @@ void QueueExp(u32 sourceLine, struct BattlePokemon *battler, struct ExpEventCont
u32 type;
uintptr_t address;
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SCENE_OPEN;
INVALID_IF(!STATE->runScene, "EXPERIENCE_BAR outside of SCENE");
if (DATA.queuedEventsCount == MAX_QUEUED_EVENTS)
Test_ExitWithResult(TEST_RESULT_ERROR, sourceLine, ":L%s:%d: EXPERIENCE_BAR exceeds MAX_QUEUED_EVENTS", gTestRunnerState.test->filename, sourceLine);
@ -3249,6 +3291,9 @@ void QueueExp(u32 sourceLine, struct BattlePokemon *battler, struct ExpEventCont
void QueueMessage(u32 sourceLine, const u8 *pattern)
{
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SCENE_OPEN;
INVALID_IF(!STATE->runScene, "MESSAGE outside of SCENE");
if (DATA.queuedEventsCount == MAX_QUEUED_EVENTS)
Test_ExitWithResult(TEST_RESULT_ERROR, sourceLine, ":L%s:%d: MESSAGE exceeds MAX_QUEUED_EVENTS", gTestRunnerState.test->filename, sourceLine);
@ -3268,6 +3313,9 @@ void QueueStatus(u32 sourceLine, struct BattlePokemon *battler, struct StatusEve
s32 battlerId = battler - gBattleMons;
u32 mask;
if (gTestRunnerState.expectedFailState == EXPECT_FAIL_OPEN)
gTestRunnerState.expectedFailState = EXPECT_FAIL_SCENE_OPEN;
INVALID_IF(!STATE->runScene, "STATUS_ICON outside of SCENE");
if (DATA.queuedEventsCount == MAX_QUEUED_EVENTS)
Test_ExitWithResult(TEST_RESULT_ERROR, sourceLine, ":L%s:%d: STATUS_ICON exceeds MAX_QUEUED_EVENTS", gTestRunnerState.test->filename, sourceLine);

145
test/test_test_runner.c
View File

@ -1,4 +1,5 @@
#include "global.h"
#include "test/battle.h"
#include "test/test.h"
TEST("Tests resume after CRASH")
@ -7,3 +8,147 @@ TEST("Tests resume after CRASH")
void (*f)(void) = NULL;
f();
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT")
{
GIVEN {
PLAYER(SPECIES_WOBBUFFET);
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player);
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT, break TRUE")
{
GIVEN {
PLAYER(SPECIES_WOBBUFFET) { Level(1); }
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player, subBreak: TRUE);
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT, break FALSE")
{
GIVEN {
PLAYER(SPECIES_WOBBUFFET) { Level(100); }
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player, subBreak: FALSE);
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT, records damage")
{
u16 damage;
GIVEN {
PLAYER(SPECIES_WOBBUFFET);
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player, captureDamage: &damage);
} THEN {
EXPECT_GT(damage, 0);
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT, records damage, break FALSE")
{
u16 damage;
GIVEN {
PLAYER(SPECIES_WOBBUFFET);
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player, captureDamage: &damage, subBreak: FALSE);
} THEN {
EXPECT_GT(damage, 0);
}
}
SINGLE_BATTLE_TEST("Substitute hits are detected by SUB_HIT, records damage, break TRUE")
{
u16 damage;
GIVEN {
PLAYER(SPECIES_WOBBUFFET) { Level(1); }
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} SCENE {
SUB_HIT(player, captureDamage: &damage, subBreak: TRUE);
} THEN {
EXPECT_GT(damage, 0);
}
}
TEST("EXPECT_FAIL allows expected failing tests to pass")
{
EXPECT_FAIL {
// Test should fail but be considered a pass
EXPECT_EQ(1, 2);
}
}
AI_SINGLE_BATTLE_TEST("EXPECT_FAIL detects failures caused by EXPECT_MOVE")
{
GIVEN {
PLAYER(SPECIES_WOBBUFFET);
OPPONENT(SPECIES_WOBBUFFET) { Item(ITEM_CHOICE_SCARF); Moves(MOVE_FAKE_OUT, MOVE_BODY_SLAM); }
} WHEN {
TURN { EXPECT_MOVE(opponent, MOVE_FAKE_OUT); }
EXPECT_FAIL {
TURN { EXPECT_MOVE(opponent, MOVE_BODY_SLAM); }
}
}
}
AI_SINGLE_BATTLE_TEST("EXPECT_FAIL detects failures caused by EXPECT_SWITCH")
{
GIVEN {
PLAYER(SPECIES_WOBBUFFET);
OPPONENT(SPECIES_WOBBUFFET) { Item(ITEM_CHOICE_SCARF); Moves(MOVE_FAKE_OUT, MOVE_BODY_SLAM); }
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { EXPECT_MOVE(opponent, MOVE_FAKE_OUT); }
EXPECT_FAIL {
TURN { EXPECT_SWITCH(opponent, 1); }
}
}
}
SINGLE_BATTLE_TEST("EXPECT_FAIL: Incorrect use of SUB_HIT results in test failure, break TRUE")
{
GIVEN {
PLAYER(SPECIES_WOBBUFFET) { Level(100); }
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} EXPECT_FAIL {
SCENE {
SUB_HIT(player, subBreak: TRUE);
}
}
}
SINGLE_BATTLE_TEST("EXPECT_FAIL: Incorrect use of SUB_HIT results in test failure, break FALSE")
{
GIVEN {
PLAYER(SPECIES_WOBBUFFET) { Level(1); }
OPPONENT(SPECIES_WOBBUFFET);
} WHEN {
TURN { MOVE(player, MOVE_SUBSTITUTE); MOVE(opponent, MOVE_SCRATCH); }
} EXPECT_FAIL {
SCENE {
SUB_HIT(player, subBreak: FALSE);
}
}
}

40
tools/mgba-rom-test-hydra/main.c
View File

@ -11,9 +11,9 @@
* L: Sets the filename to the remainder of the line.
* R: Sets the result to the remainder of the line, and flushes any
* output buffered since the previous R.
* P/K/F/A: Sets the result to the remaining of the line, flushes any
* output since the previous P/K/F/A and increment the number of
* passes/known fails/assumption fails/fails.
* P/E/K/F/A: Sets the result to the remaining of the line, flushes any
* output since the previous P/E/K/F/A and increment the number of
* passes/expected fails/known fails/assumption fails/fails.
*/
#include <fcntl.h>
#include <math.h>
@ -59,6 +59,8 @@ struct Runner
int passes;
int knownFails;
int knownFailsPassing;
int expectedFails;
int expectedFailsPassing;
int todos;
int assumptionFails;
int fails;
@ -67,6 +69,8 @@ struct Runner
char failed_TestFilenameLine[MAX_SUMMARY_TESTS_TO_LIST][MAX_TEST_LIST_BUFFER_LENGTH];
char knownFailingPassed_TestNames[MAX_SUMMARY_TESTS_TO_LIST][MAX_TEST_LIST_BUFFER_LENGTH];
char knownFailingPassed_FilenameLine[MAX_SUMMARY_TESTS_TO_LIST][MAX_TEST_LIST_BUFFER_LENGTH];
char expectedFailingPassed_TestNames[MAX_SUMMARY_TESTS_TO_LIST][MAX_TEST_LIST_BUFFER_LENGTH];
char expectedFailingPassed_FilenameLine[MAX_SUMMARY_TESTS_TO_LIST][MAX_TEST_LIST_BUFFER_LENGTH];
char assumeFailed_TestNames[MAX_SUMMARY_TESTS_TO_LIST][MAX_TEST_LIST_BUFFER_LENGTH];
char assumeFailed_FilenameLine[MAX_SUMMARY_TESTS_TO_LIST][MAX_TEST_LIST_BUFFER_LENGTH];
};
@ -241,6 +245,9 @@ static void handle_read(int i, struct Runner *runner)
case 'P':
runner->passes++;
goto add_to_results;
case 'E':
runner->expectedFails++;
goto add_to_results;
case 'K':
runner->knownFails++;
goto add_to_results;
@ -252,6 +259,14 @@ static void handle_read(int i, struct Runner *runner)
}
runner->knownFailsPassing++;
goto add_to_results;
case 'V':
if (runner->expectedFailsPassing < MAX_SUMMARY_TESTS_TO_LIST)
{
strcpy(runner->expectedFailingPassed_TestNames[runner->expectedFailsPassing], runner->test_name);
strcpy(runner->expectedFailingPassed_FilenameLine[runner->expectedFailsPassing], runner->filename_line);
}
runner->expectedFailsPassing++;
goto add_to_results;
case 'T':
runner->todos++;
goto add_to_results;
@ -737,6 +752,8 @@ int main(int argc, char *argv[])
// Reap test runners and collate exit codes.
int exit_code = 0;
int passes = 0;
int expectedFails = 0;
int expectedFailsPassing = 0;
int knownFails = 0;
int knownFailsPassing = 0;
int todos = 0;
@ -750,6 +767,9 @@ int main(int argc, char *argv[])
char knownFailingPassed_TestNames[MAX_SUMMARY_TESTS_TO_LIST * MAX_PROCESSES][MAX_TEST_LIST_BUFFER_LENGTH];
char knownFailingPassed_FilenameLine[MAX_SUMMARY_TESTS_TO_LIST * MAX_PROCESSES][MAX_TEST_LIST_BUFFER_LENGTH];
char expectedFailingPassed_TestNames[MAX_SUMMARY_TESTS_TO_LIST * MAX_PROCESSES][MAX_TEST_LIST_BUFFER_LENGTH];
char expectedFailingPassed_FilenameLine[MAX_SUMMARY_TESTS_TO_LIST * MAX_PROCESSES][MAX_TEST_LIST_BUFFER_LENGTH];
char assumeFailed_TestNames[MAX_SUMMARY_TESTS_TO_LIST * MAX_PROCESSES][MAX_TEST_LIST_BUFFER_LENGTH];
char assumeFailed_FilenameLine[MAX_SUMMARY_TESTS_TO_LIST * MAX_PROCESSES][MAX_TEST_LIST_BUFFER_LENGTH];
@ -766,6 +786,7 @@ int main(int argc, char *argv[])
if (WIFEXITED(wstatus) && WEXITSTATUS(wstatus) > exit_code)
exit_code = WEXITSTATUS(wstatus);
passes += runners[i].passes;
expectedFails += runners[i].expectedFails;
knownFails += runners[i].knownFails;
for (int j = 0; j < runners[i].knownFailsPassing; j++)
{
@ -776,6 +797,15 @@ int main(int argc, char *argv[])
}
knownFailsPassing++;
}
for (int j = 0; j < runners[i].expectedFailsPassing; j++)
{
if (j < MAX_SUMMARY_TESTS_TO_LIST)
{
strcpy(expectedFailingPassed_TestNames[expectedFailsPassing], runners[i].expectedFailingPassed_TestNames[j]);
strcpy(expectedFailingPassed_FilenameLine[expectedFailsPassing], runners[i].expectedFailingPassed_FilenameLine[j]);
}
expectedFailsPassing++;
}
todos += runners[i].todos;
for (int j = 0; j < runners[i].assumptionFails; j++)
{
@ -855,12 +885,16 @@ int main(int argc, char *argv[])
fprintf(stdout, "\n");
if (fails > 0)
fprintf(stdout, "- Tests \e[31mFAILED\e[0m : %d Add TESTS='X' to run tests with the defined prefix.\n", fails);
if (expectedFails > 0)
fprintf(stdout, "- Tests \e[32mEXPECT_FAILING\e[0m: %d\n", expectedFails);
if (knownFails > 0)
fprintf(stdout, "- Tests \e[33mKNOWN_FAILING\e[0m: %d\n", knownFails);
if (assumptionFails > 0)
fprintf(stdout, "- \e[33mASSUMPTIONS_FAILED\e[0m: %d\n", assumptionFails);
if (todos > 0)
fprintf(stdout, "- Tests \e[33mTO_DO\e[0m: %d\n", todos);
if (expectedFailsPassing > 0)
fprintf(stdout, "- \e[31mEXPECTED_FAIL_PASSING\e[0m: %d\n", expectedFailsPassing);
if (knownFailsPassing > 0)
fprintf(stdout, "- \e[32mKNOWN_FAILING_PASSING\e[0m: %d \e[33mPlease remove KNOWN_FAILING if these tests intentionally PASS\e[0m\n", knownFailsPassing);
fprintf(stdout, "- Tests \e[32mPASSED\e[0m: %d\n", passes);