iris/kaizen
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
00cc9309cb3a9e41afe5def8dcb9bf5b089b9a21
kaizen/external/SDL/test/testautomation_rect.c
T
iris 00cc9309cb Squashed 'external/ircolib/' changes from ce3cd726c..de6e324bd 
de6e324bd separate emu thread
10d3daf86 Roms List improvements
95d202f37 Let's make the rom list process on a separate thread so the emulator doesnt take ages to load.
fc306967f Wow the ROM Header was just completely busted. Game list view works now
bad1691ee fuck this shit
2b59e5f46 game list in progress
d26417b83 remappable inputs in progress
ac4af8106 input
e72abc240 update readme
430139dc9 Qt6 frontend
3080d4d45 Fix this small bug too
08cd13b85 Cop0 unused functions do not actually pose a threat (as per manual). They don't do anything, so shall we.
61bb4fb44 make idle loop detection a little more specific with where the load goes
b037de4c3 SAZDFsdff
12e81e73e need to figure out why n64-systemtest loops indefinitely at some address that appears to be valid (i think it's me not invalidating the cache properly)
204f0e13b idle skipping seems to work!
cb8bb634a sdkfjlasdf
58e5c89c1 Fix compilation issue on my machine (no idea)
24fb2898e attempting more serious idle skipping
214719577 Place rsp.Step inside cached interpreter. Gains about 3 more fps
bb97dcc23 mmmmm
920b77d38 wjkhasdfjhkasdf
430ccdab4 it's a start...
4f42a673a Cached interpreter plays Mario 64. Start looking into RSP as well
c9a030787 idle skipping works!
5fbda03ce new idea
366637aba Idle skipping... maybe?
609fa2fb0 Cache instructions implemented but broken lmao. Commented out for now
e140a6d12 - Stop using inheritance for CPU, instead use composition. - Introduce KAIZEN_JIT_ENABLED optional define instead of relying on __aarch64__ and the like. - More cache work
68e613057 prep cache impl
811b4d809 fix clang format
fda755f7d idk
d5024ebbf small MI refactor in preparation of (eventually) implementing the RDRAM interface properly
694b45341 Merge commit '206dcdedf195fb320913584180edb12c7731e396' as 'external/SDL'
206dcdedf Squashed 'external/SDL/' content from commit 4d17b99d0a
4d16e1cb4 need to update sdl
848b19920 Fix compilation error
db61b5299 Merge commit 'e94a94559f28e49678fbcf72199a5258137b0fe9' as 'external/imgui'
e94a94559 Squashed 'external/imgui/' content from commit 02e9b8cac
52edb3757 need to update imgui
c1a705e86 Emulate weird JALR behaviour
4b4c32f4b Fix exception for "unusable COP1" in 4 instructions i missed accidentally (again)
df5828142 Bug putting 0s in the log everywhere
f8b580048 Make isviewer a sink to file
8241e9735 Fix exception for "unusable COP1" in 4 instructions i missed accidentally
b29715f20 small changes
d9a620bc1 make use of my new small utility library
0d1aa938e Add 'external/ircolib/' from commit 'ce3cd726c8df8388d554abf8bb55d55020eb4450'
e64eb40b3 Fuck git

git-subtree-dir: external/ircolib
git-subtree-split: de6e324bde
2026-06-15 11:56:38 +02:00

2421 lines
92 KiB
C
Raw Blame History

/**
* Original code: automated SDL rect test written by Edgar Simo "bobbens"
* New/updated tests: aschiffler at ferzkopp dot net
*/
#include <limits.h>
#include <SDL3/SDL.h>
#include <SDL3/SDL_test.h>
#include "testautomation_suites.h"
/* ================= Test Case Implementation ================== */
/* Helper functions */
/**
* Private helper to check SDL_GetRectAndLineIntersectionFloat results
*/
static bool IsFRectEqual(const SDL_FRect *r1, const SDL_FRect *r2) {
static const float MAX_DELTA = 1e-5f;
SDL_FRect delta;
delta.x = r1->x - r2->x;
delta.y = r1->y - r2->y;
delta.w = r1->w - r2->w;
delta.h = r1->h - r2->h;
return -MAX_DELTA <= delta.x && delta.x <= MAX_DELTA
&& -MAX_DELTA <= delta.y && delta.y <= MAX_DELTA
&& -MAX_DELTA <= delta.w && delta.w <= MAX_DELTA
&& -MAX_DELTA <= delta.w && delta.h <= MAX_DELTA;
}
/* !
* \brief Private helper to check SDL_FPoint equality
*/
static bool IsFPointEqual(const SDL_FPoint *p1, const SDL_FPoint *p2) {
static const float MAX_DELTA = 1e-5f;
SDL_FPoint delta;
delta.x = p1->x - p2->x;
delta.y = p1->y - p2->y;
return -MAX_DELTA <= delta.x && delta.x <= MAX_DELTA
&& -MAX_DELTA <= delta.y && delta.y <= MAX_DELTA;
}
static void validateIntersectRectAndLineFloatResults(
bool intersection, bool expectedIntersection,
SDL_FRect *rect,
float x1, float y1, float x2, float y2,
float x1Ref, float y1Ref, float x2Ref, float y2Ref)
{
SDLTest_AssertCheck(intersection == expectedIntersection,
"Check for correct intersection result: expected %s, got %s intersecting rect (%.2f,%.2f,%.2f,%.2f) with line (%.2f,%.2f - %.2f,%.2f)",
(expectedIntersection == true) ? "true" : "false",
(intersection == true) ? "true" : "false",
rect->x, rect->y, rect->w, rect->h,
x1Ref, y1Ref, x2Ref, y2Ref);
SDLTest_AssertCheck(x1 == x1Ref && y1 == y1Ref && x2 == x2Ref && y2 == y2Ref,
"Check if line was incorrectly clipped or modified: got (%.2f,%.2f - %.2f,%.2f) expected (%.2f,%.2f - %.2f,%.2f)",
x1, y1, x2, y2,
x1Ref, y1Ref, x2Ref, y2Ref);
}
/**
* Private helper to check SDL_GetRectAndLineIntersection results
*/
static void validateIntersectRectAndLineResults(
bool intersection, bool expectedIntersection,
SDL_Rect *rect, SDL_Rect *refRect,
int x1, int y1, int x2, int y2,
int x1Ref, int y1Ref, int x2Ref, int y2Ref)
{
SDLTest_AssertCheck(intersection == expectedIntersection,
"Check for correct intersection result: expected %s, got %s intersecting rect (%d,%d,%d,%d) with line (%d,%d - %d,%d)",
(expectedIntersection == true) ? "true" : "false",
(intersection == true) ? "true" : "false",
refRect->x, refRect->y, refRect->w, refRect->h,
x1Ref, y1Ref, x2Ref, y2Ref);
SDLTest_AssertCheck(rect->x == refRect->x && rect->y == refRect->y && rect->w == refRect->w && rect->h == refRect->h,
"Check that source rectangle was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
rect->x, rect->y, rect->w, rect->h,
refRect->x, refRect->y, refRect->w, refRect->h);
SDLTest_AssertCheck(x1 == x1Ref && y1 == y1Ref && x2 == x2Ref && y2 == y2Ref,
"Check if line was incorrectly clipped or modified: got (%d,%d - %d,%d) expected (%d,%d - %d,%d)",
x1, y1, x2, y2,
x1Ref, y1Ref, x2Ref, y2Ref);
}
/* Test case functions */
/**
* Tests SDL_GetRectAndLineIntersectionFloat() clipping cases
*
* \sa SDL_GetRectAndLineIntersectionFloat
*/
static int SDLCALL rect_testIntersectRectAndLineFloat(void *arg)
{
SDL_FRect rect;
float x1, y1;
float x2, y2;
bool intersected;
x1 = 5.0f;
y1 = 6.0f;
x2 = 23.0f;
y2 = 6.0f;
rect.x = 2.5f;
rect.y = 1.5f;
rect.w = 15.25f;
rect.h = 12.0f;
intersected = SDL_GetRectAndLineIntersectionFloat(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineFloatResults(intersected, true, &rect, x1, y1, x2, y2, 5.0f, 6.0f, 17.75f, 6.0f);
x1 = 0.0f;
y1 = 6.0f;
x2 = 23.0f;
y2 = 6.0f;
rect.x = 2.5f;
rect.y = 1.5f;
rect.w = 0.25f;
rect.h = 12.0f;
intersected = SDL_GetRectAndLineIntersectionFloat(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineFloatResults(intersected, true, &rect, x1, y1, x2, y2, 2.5f, 6.0f, 2.75f, 6.0f);
x1 = 456.0f;
y1 = 592.0f;
x2 = 160.0f;
y2 = 670.0f;
rect.x = 300.0f;
rect.y = 592.0f;
rect.w = 64.0f;
rect.h = 64.0f;
intersected = SDL_GetRectAndLineIntersectionFloat(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineFloatResults(intersected, true, &rect, x1, y1, x2, y2, 364.0f, 616.243225f, 300.0f, 633.108093f);
return TEST_COMPLETED;
}
/**
* Tests SDL_GetRectAndLineIntersection() clipping cases
*
* \sa SDL_GetRectAndLineIntersection
*/
static int SDLCALL rect_testIntersectRectAndLine(void *arg)
{
SDL_Rect refRect = { 0, 0, 32, 32 };
SDL_Rect rect;
int x1, y1;
int x2, y2;
bool intersected;
int xLeft = -SDLTest_RandomIntegerInRange(1, refRect.w);
int xRight = refRect.w + SDLTest_RandomIntegerInRange(1, refRect.w);
int yTop = -SDLTest_RandomIntegerInRange(1, refRect.h);
int yBottom = refRect.h + SDLTest_RandomIntegerInRange(1, refRect.h);
x1 = xLeft;
y1 = 15;
x2 = xRight;
y2 = 15;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, true, &rect, &refRect, x1, y1, x2, y2, 0, 15, 31, 15);
x1 = 15;
y1 = yTop;
x2 = 15;
y2 = yBottom;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, true, &rect, &refRect, x1, y1, x2, y2, 15, 0, 15, 31);
x1 = -refRect.w;
y1 = -refRect.h;
x2 = 2 * refRect.w;
y2 = 2 * refRect.h;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, true, &rect, &refRect, x1, y1, x2, y2, 0, 0, 31, 31);
x1 = 2 * refRect.w;
y1 = 2 * refRect.h;
x2 = -refRect.w;
y2 = -refRect.h;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, true, &rect, &refRect, x1, y1, x2, y2, 31, 31, 0, 0);
x1 = -1;
y1 = 32;
x2 = 32;
y2 = -1;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, true, &rect, &refRect, x1, y1, x2, y2, 0, 31, 31, 0);
x1 = 32;
y1 = -1;
x2 = -1;
y2 = 32;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, true, &rect, &refRect, x1, y1, x2, y2, 31, 0, 0, 31);
/* Test some overflow cases */
refRect.x = INT_MAX - 4;
refRect.y = INT_MAX - 4;
x1 = INT_MAX;
y1 = INT_MIN;
x2 = INT_MIN;
y2 = INT_MAX;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, false, &rect, &refRect, x1, y1, x2, y2, x1, y1, x2, y2);
return TEST_COMPLETED;
}
/**
* Tests SDL_GetRectAndLineIntersection() non-clipping case line inside
*
* \sa SDL_GetRectAndLineIntersection
*/
static int SDLCALL rect_testIntersectRectAndLineInside(void *arg)
{
SDL_Rect refRect = { 0, 0, 32, 32 };
SDL_Rect rect;
int x1, y1;
int x2, y2;
bool intersected;
int xmin = refRect.x;
int xmax = refRect.x + refRect.w - 1;
int ymin = refRect.y;
int ymax = refRect.y + refRect.h - 1;
int x1Ref = SDLTest_RandomIntegerInRange(xmin + 1, xmax - 1);
int y1Ref = SDLTest_RandomIntegerInRange(ymin + 1, ymax - 1);
int x2Ref = SDLTest_RandomIntegerInRange(xmin + 1, xmax - 1);
int y2Ref = SDLTest_RandomIntegerInRange(ymin + 1, ymax - 1);
x1 = x1Ref;
y1 = y1Ref;
x2 = x2Ref;
y2 = y2Ref;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, true, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, x2Ref, y2Ref);
x1 = x1Ref;
y1 = y1Ref;
x2 = xmax;
y2 = ymax;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, true, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, xmax, ymax);
x1 = xmin;
y1 = ymin;
x2 = x2Ref;
y2 = y2Ref;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, true, &rect, &refRect, x1, y1, x2, y2, xmin, ymin, x2Ref, y2Ref);
x1 = xmin;
y1 = ymin;
x2 = xmax;
y2 = ymax;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, true, &rect, &refRect, x1, y1, x2, y2, xmin, ymin, xmax, ymax);
x1 = xmin;
y1 = ymax;
x2 = xmax;
y2 = ymin;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, true, &rect, &refRect, x1, y1, x2, y2, xmin, ymax, xmax, ymin);
return TEST_COMPLETED;
}
/**
* Tests SDL_GetRectAndLineIntersection() non-clipping cases outside
*
* \sa SDL_GetRectAndLineIntersection
*/
static int SDLCALL rect_testIntersectRectAndLineOutside(void *arg)
{
SDL_Rect refRect = { 0, 0, 32, 32 };
SDL_Rect rect;
int x1, y1;
int x2, y2;
bool intersected;
int xLeft = -SDLTest_RandomIntegerInRange(1, refRect.w);
int xRight = refRect.w + SDLTest_RandomIntegerInRange(1, refRect.w);
int yTop = -SDLTest_RandomIntegerInRange(1, refRect.h);
int yBottom = refRect.h + SDLTest_RandomIntegerInRange(1, refRect.h);
x1 = xLeft;
y1 = 0;
x2 = xLeft;
y2 = 31;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, false, &rect, &refRect, x1, y1, x2, y2, xLeft, 0, xLeft, 31);
x1 = xRight;
y1 = 0;
x2 = xRight;
y2 = 31;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, false, &rect, &refRect, x1, y1, x2, y2, xRight, 0, xRight, 31);
x1 = 0;
y1 = yTop;
x2 = 31;
y2 = yTop;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, false, &rect, &refRect, x1, y1, x2, y2, 0, yTop, 31, yTop);
x1 = 0;
y1 = yBottom;
x2 = 31;
y2 = yBottom;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, false, &rect, &refRect, x1, y1, x2, y2, 0, yBottom, 31, yBottom);
return TEST_COMPLETED;
}
/**
* Tests SDL_GetRectAndLineIntersection() with empty rectangle
*
* \sa SDL_GetRectAndLineIntersection
*/
static int SDLCALL rect_testIntersectRectAndLineEmpty(void *arg)
{
SDL_Rect refRect;
SDL_Rect rect;
int x1, y1, x1Ref, y1Ref;
int x2, y2, x2Ref, y2Ref;
bool intersected;
refRect.x = SDLTest_RandomIntegerInRange(1, 1024);
refRect.y = SDLTest_RandomIntegerInRange(1, 1024);
refRect.w = 0;
refRect.h = 0;
x1Ref = refRect.x;
y1Ref = refRect.y;
x2Ref = SDLTest_RandomIntegerInRange(1, 1024);
y2Ref = SDLTest_RandomIntegerInRange(1, 1024);
x1 = x1Ref;
y1 = y1Ref;
x2 = x2Ref;
y2 = y2Ref;
rect = refRect;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
validateIntersectRectAndLineResults(intersected, false, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, x2Ref, y2Ref);
return TEST_COMPLETED;
}
/**
* Negative tests against SDL_GetRectAndLineIntersection() with invalid parameters
*
* \sa SDL_GetRectAndLineIntersection
*/
static int SDLCALL rect_testIntersectRectAndLineParam(void *arg)
{
SDL_Rect rect = { 0, 0, 32, 32 };
int x1 = rect.w / 2;
int y1 = rect.h / 2;
int x2 = x1;
int y2 = 2 * rect.h;
bool intersected;
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
SDLTest_AssertCheck(intersected == true, "Check that intersection result was true");
intersected = SDL_GetRectAndLineIntersection((SDL_Rect *)NULL, &x1, &y1, &x2, &y2);
SDLTest_AssertCheck(intersected == false, "Check that function returns false when 1st parameter is NULL");
intersected = SDL_GetRectAndLineIntersection(&rect, (int *)NULL, &y1, &x2, &y2);
SDLTest_AssertCheck(intersected == false, "Check that function returns false when 2nd parameter is NULL");
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, (int *)NULL, &x2, &y2);
SDLTest_AssertCheck(intersected == false, "Check that function returns false when 3rd parameter is NULL");
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, (int *)NULL, &y2);
SDLTest_AssertCheck(intersected == false, "Check that function returns false when 4th parameter is NULL");
intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, (int *)NULL);
SDLTest_AssertCheck(intersected == false, "Check that function returns false when 5th parameter is NULL");
intersected = SDL_GetRectAndLineIntersection((SDL_Rect *)NULL, (int *)NULL, (int *)NULL, (int *)NULL, (int *)NULL);
SDLTest_AssertCheck(intersected == false, "Check that function returns false when all parameters are NULL");
return TEST_COMPLETED;
}
/**
* Private helper to check SDL_HasRectIntersectionFloat results
*/
static void validateHasIntersectionFloatResults(
bool intersection, bool expectedIntersection,
SDL_FRect *rectA, SDL_FRect *rectB)
{
SDLTest_AssertCheck(intersection == expectedIntersection,
"Check intersection result: expected %s, got %s intersecting A (%.2f,%.2f,%.2f,%.2f) with B (%.2f,%.2f,%.2f,%.2f)",
(expectedIntersection == true) ? "true" : "false",
(intersection == true) ? "true" : "false",
rectA->x, rectA->y, rectA->w, rectA->h,
rectB->x, rectB->y, rectB->w, rectB->h);
}
/**
* Private helper to check SDL_HasRectIntersection results
*/
static void validateHasIntersectionResults(
bool intersection, bool expectedIntersection,
SDL_Rect *rectA, SDL_Rect *rectB, SDL_Rect *refRectA, SDL_Rect *refRectB)
{
SDLTest_AssertCheck(intersection == expectedIntersection,
"Check intersection result: expected %s, got %s intersecting A (%d,%d,%d,%d) with B (%d,%d,%d,%d)",
(expectedIntersection == true) ? "true" : "false",
(intersection == true) ? "true" : "false",
rectA->x, rectA->y, rectA->w, rectA->h,
rectB->x, rectB->y, rectB->w, rectB->h);
SDLTest_AssertCheck(rectA->x == refRectA->x && rectA->y == refRectA->y && rectA->w == refRectA->w && rectA->h == refRectA->h,
"Check that source rectangle A was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
rectA->x, rectA->y, rectA->w, rectA->h,
refRectA->x, refRectA->y, refRectA->w, refRectA->h);
SDLTest_AssertCheck(rectB->x == refRectB->x && rectB->y == refRectB->y && rectB->w == refRectB->w && rectB->h == refRectB->h,
"Check that source rectangle B was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
rectB->x, rectB->y, rectB->w, rectB->h,
refRectB->x, refRectB->y, refRectB->w, refRectB->h);
}
/**
* Private helper to check SDL_GetRectIntersection results
*/
static void validateIntersectRectFloatResults(
bool intersection, bool expectedIntersection,
SDL_FRect *rectA, SDL_FRect *rectB,
SDL_FRect *result, SDL_FRect *expectedResult)
{
validateHasIntersectionFloatResults(intersection, expectedIntersection, rectA, rectB);
if (result && expectedResult) {
SDLTest_AssertCheck(result->x == expectedResult->x && result->y == expectedResult->y && result->w == expectedResult->w && result->h == expectedResult->h,
"Check that intersection of rectangles A (%.2f,%.2f, %.2fx%.2f) and B (%.2f,%.2f %.2fx%.2f) was correctly calculated, got (%.2f,%.2f %.2fx%.2f) expected (%.2f,%.2f,%.2f,%.2f)",
rectA->x, rectA->y, rectA->w, rectA->h,
rectB->x, rectB->y, rectB->w, rectB->h,
result->x, result->y, result->w, result->h,
expectedResult->x, expectedResult->y, expectedResult->w, expectedResult->h);
}
SDLTest_AssertCheck(intersection == SDL_HasRectIntersectionFloat(rectA, rectB),
"Check that intersection (%s) matches SDL_HasRectIntersectionFloat() result (%s)",
intersection ? "true" : "false",
SDL_HasRectIntersectionFloat(rectA, rectB) ? "true" : "false");
}
/**
* Private helper to check SDL_GetRectIntersection results
*/
static void validateIntersectRectResults(
bool intersection, bool expectedIntersection,
SDL_Rect *rectA, SDL_Rect *rectB, SDL_Rect *refRectA, SDL_Rect *refRectB,
SDL_Rect *result, SDL_Rect *expectedResult)
{
validateHasIntersectionResults(intersection, expectedIntersection, rectA, rectB, refRectA, refRectB);
if (result && expectedResult) {
SDLTest_AssertCheck(result->x == expectedResult->x && result->y == expectedResult->y && result->w == expectedResult->w && result->h == expectedResult->h,
"Check that intersection of rectangles A (%d,%d,%d,%d) and B (%d,%d,%d,%d) was correctly calculated, got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
rectA->x, rectA->y, rectA->w, rectA->h,
rectB->x, rectB->y, rectB->w, rectB->h,
result->x, result->y, result->w, result->h,
expectedResult->x, expectedResult->y, expectedResult->w, expectedResult->h);
}
}
/**
* Private helper to check SDL_GetRectUnion results
*/
static void validateUnionRectResults(
SDL_Rect *rectA, SDL_Rect *rectB, SDL_Rect *refRectA, SDL_Rect *refRectB,
SDL_Rect *result, SDL_Rect *expectedResult)
{
SDLTest_AssertCheck(rectA->x == refRectA->x && rectA->y == refRectA->y && rectA->w == refRectA->w && rectA->h == refRectA->h,
"Check that source rectangle A was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
rectA->x, rectA->y, rectA->w, rectA->h,
refRectA->x, refRectA->y, refRectA->w, refRectA->h);
SDLTest_AssertCheck(rectB->x == refRectB->x && rectB->y == refRectB->y && rectB->w == refRectB->w && rectB->h == refRectB->h,
"Check that source rectangle B was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
rectB->x, rectB->y, rectB->w, rectB->h,
refRectB->x, refRectB->y, refRectB->w, refRectB->h);
SDLTest_AssertCheck(result->x == expectedResult->x && result->y == expectedResult->y && result->w == expectedResult->w && result->h == expectedResult->h,
"Check that union of rectangles A (%d,%d,%d,%d) and B (%d,%d,%d,%d) was correctly calculated, got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
rectA->x, rectA->y, rectA->w, rectA->h,
rectB->x, rectB->y, rectB->w, rectB->h,
result->x, result->y, result->w, result->h,
expectedResult->x, expectedResult->y, expectedResult->w, expectedResult->h);
}
/**
* Private helper to check SDL_RectEmptyFloat results
*/
static void validateRectEmptyFloatResults(
bool empty, bool expectedEmpty,
SDL_FRect *rect)
{
SDLTest_AssertCheck(empty == expectedEmpty,
"Check for correct empty result: expected %s, got %s testing (%.2f,%.2f,%.2f,%.2f)",
(expectedEmpty == true) ? "true" : "false",
(empty == true) ? "true" : "false",
rect->x, rect->y, rect->w, rect->h);
}
/**
* Private helper to check SDL_RectEmpty results
*/
static void validateRectEmptyResults(
bool empty, bool expectedEmpty,
SDL_Rect *rect, SDL_Rect *refRect)
{
SDLTest_AssertCheck(empty == expectedEmpty,
"Check for correct empty result: expected %s, got %s testing (%d,%d,%d,%d)",
(expectedEmpty == true) ? "true" : "false",
(empty == true) ? "true" : "false",
rect->x, rect->y, rect->w, rect->h);
SDLTest_AssertCheck(rect->x == refRect->x && rect->y == refRect->y && rect->w == refRect->w && rect->h == refRect->h,
"Check that source rectangle was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
rect->x, rect->y, rect->w, rect->h,
refRect->x, refRect->y, refRect->w, refRect->h);
}
/**
* Private helper to check SDL_RectsEqual results
*/
static void validateRectEqualsResults(
bool equals, bool expectedEquals,
SDL_Rect *rectA, SDL_Rect *rectB, SDL_Rect *refRectA, SDL_Rect *refRectB)
{
SDLTest_AssertCheck(equals == expectedEquals,
"Check for correct equals result: expected %s, got %s testing (%d,%d,%d,%d) and (%d,%d,%d,%d)",
(expectedEquals == true) ? "true" : "false",
(equals == true) ? "true" : "false",
rectA->x, rectA->y, rectA->w, rectA->h,
rectB->x, rectB->y, rectB->w, rectB->h);
SDLTest_AssertCheck(rectA->x == refRectA->x && rectA->y == refRectA->y && rectA->w == refRectA->w && rectA->h == refRectA->h,
"Check that source rectangle A was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
rectA->x, rectA->y, rectA->w, rectA->h,
refRectA->x, refRectA->y, refRectA->w, refRectA->h);
SDLTest_AssertCheck(rectB->x == refRectB->x && rectB->y == refRectB->y && rectB->w == refRectB->w && rectB->h == refRectB->h,
"Check that source rectangle B was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
rectB->x, rectB->y, rectB->w, rectB->h,
refRectB->x, refRectB->y, refRectB->w, refRectB->h);
}
/**
* Private helper to check SDL_RectsEqualFloat results
*/
static void validateFRectEqualsResults(
bool equals, bool expectedEquals,
SDL_FRect *rectA, SDL_FRect *rectB, SDL_FRect *refRectA, SDL_FRect *refRectB)
{
int cmpRes;
SDLTest_AssertCheck(equals == expectedEquals,
"Check for correct equals result: expected %s, got %s testing (%f,%f,%f,%f) and (%f,%f,%f,%f)",
(expectedEquals == true) ? "true" : "false",
(equals == true) ? "true" : "false",
rectA->x, rectA->y, rectA->w, rectA->h,
rectB->x, rectB->y, rectB->w, rectB->h);
cmpRes = SDL_memcmp(rectA, refRectA, sizeof(*rectA));
SDLTest_AssertCheck(cmpRes == 0,
"Check that source rectangle A was not modified: got (%f,%f,%f,%f) expected (%f,%f,%f,%f)",
rectA->x, rectA->y, rectA->w, rectA->h,
refRectA->x, refRectA->y, refRectA->w, refRectA->h);
cmpRes = SDL_memcmp(rectB, refRectB, sizeof(*rectB));
SDLTest_AssertCheck(cmpRes == 0,
"Check that source rectangle B was not modified: got (%f,%f,%f,%f) expected (%f,%f,%f,%f)",
rectB->x, rectB->y, rectB->w, rectB->h,
refRectB->x, refRectB->y, refRectB->w, refRectB->h);
}
/**
* Tests SDL_GetRectIntersectionFloat()
*
* \sa SDL_GetRectIntersectionFloat
*/
static int SDLCALL rect_testIntersectRectFloat(void *arg)
{
SDL_FRect rectA;
SDL_FRect rectB;
SDL_FRect result;
SDL_FRect expectedResult;
bool intersection;
rectA.x = 0.0f;
rectA.y = 0.0f;
rectA.w = 1.0f;
rectA.h = 1.0f;
rectB.x = 0.0f;
rectB.y = 0.0f;
rectB.w = 1.0f;
rectB.h = 1.0f;
expectedResult = rectA;
intersection = SDL_GetRectIntersectionFloat(&rectA, &rectB, &result);
validateIntersectRectFloatResults(intersection, true, &rectA, &rectB, &result, &expectedResult);
rectA.x = 0.0f;
rectA.y = 0.0f;
rectA.w = 1.0f;
rectA.h = 1.0f;
rectB.x = 1.0f;
rectB.y = 0.0f;
rectB.w = 1.0f;
rectB.h = 1.0f;
expectedResult = rectB;
expectedResult.w = 0.0f;
intersection = SDL_GetRectIntersectionFloat(&rectA, &rectB, &result);
validateIntersectRectFloatResults(intersection, true, &rectA, &rectB, &result, &expectedResult);
rectA.x = 0.0f;
rectA.y = 0.0f;
rectA.w = 1.0f;
rectA.h = 1.0f;
rectB.x = 1.0f;
rectB.y = 1.0f;
rectB.w = 1.0f;
rectB.h = 1.0f;
expectedResult = rectB;
expectedResult.w = 0.0f;
expectedResult.h = 0.0f;
intersection = SDL_GetRectIntersectionFloat(&rectA, &rectB, &result);
validateIntersectRectFloatResults(intersection, true, &rectA, &rectB, &result, &expectedResult);
rectA.x = 0.0f;
rectA.y = 0.0f;
rectA.w = 1.0f;
rectA.h = 1.0f;
rectB.x = 2.0f;
rectB.y = 0.0f;
rectB.w = 1.0f;
rectB.h = 1.0f;
expectedResult = rectB;
expectedResult.w = -1.0f;
intersection = SDL_GetRectIntersectionFloat(&rectA, &rectB, &result);
validateIntersectRectFloatResults(intersection, false, &rectA, &rectB, &result, &expectedResult);
return TEST_COMPLETED;
}
/**
* Tests SDL_GetRectIntersection() with B fully inside A
*
* \sa SDL_GetRectIntersection
*/
static int SDLCALL rect_testIntersectRectInside(void *arg)
{
SDL_Rect refRectA = { 0, 0, 32, 32 };
SDL_Rect refRectB;
SDL_Rect rectA;
SDL_Rect rectB;
SDL_Rect result;
bool intersection;
/* rectB fully contained in rectA */
refRectB.x = 0;
refRectB.y = 0;
refRectB.w = SDLTest_RandomIntegerInRange(refRectA.x + 1, refRectA.x + refRectA.w - 1);
refRectB.h = SDLTest_RandomIntegerInRange(refRectA.y + 1, refRectA.y + refRectA.h - 1);
rectA = refRectA;
rectB = refRectB;
intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
validateIntersectRectResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB, &result, &refRectB);
return TEST_COMPLETED;
}
/**
* Tests SDL_GetRectIntersection() with B fully outside A
*
* \sa SDL_GetRectIntersection
*/
static int SDLCALL rect_testIntersectRectOutside(void *arg)
{
SDL_Rect refRectA = { 0, 0, 32, 32 };
SDL_Rect refRectB;
SDL_Rect rectA;
SDL_Rect rectB;
SDL_Rect result;
bool intersection;
/* rectB fully outside of rectA */
refRectB.x = refRectA.x + refRectA.w + SDLTest_RandomIntegerInRange(1, 10);
refRectB.y = refRectA.y + refRectA.h + SDLTest_RandomIntegerInRange(1, 10);
refRectB.w = refRectA.w;
refRectB.h = refRectA.h;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
validateIntersectRectResults(intersection, false, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
return TEST_COMPLETED;
}
/**
* Tests SDL_GetRectIntersection() with B partially intersecting A
*
* \sa SDL_GetRectIntersection
*/
static int SDLCALL rect_testIntersectRectPartial(void *arg)
{
SDL_Rect refRectA = { 0, 0, 32, 32 };
SDL_Rect refRectB;
SDL_Rect rectA;
SDL_Rect rectB;
SDL_Rect result;
SDL_Rect expectedResult;
bool intersection;
/* rectB partially contained in rectA */
refRectB.x = SDLTest_RandomIntegerInRange(refRectA.x + 1, refRectA.x + refRectA.w - 1);
refRectB.y = SDLTest_RandomIntegerInRange(refRectA.y + 1, refRectA.y + refRectA.h - 1);
refRectB.w = refRectA.w;
refRectB.h = refRectA.h;
rectA = refRectA;
rectB = refRectB;
expectedResult.x = refRectB.x;
expectedResult.y = refRectB.y;
expectedResult.w = refRectA.w - refRectB.x;
expectedResult.h = refRectA.h - refRectB.y;
intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
validateIntersectRectResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
/* rectB right edge */
refRectB.x = rectA.w - 1;
refRectB.y = rectA.y;
refRectB.w = SDLTest_RandomIntegerInRange(1, refRectA.w - 1);
refRectB.h = SDLTest_RandomIntegerInRange(1, refRectA.h - 1);
rectA = refRectA;
rectB = refRectB;
expectedResult.x = refRectB.x;
expectedResult.y = refRectB.y;
expectedResult.w = 1;
expectedResult.h = refRectB.h;
intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
validateIntersectRectResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
/* rectB left edge */
refRectB.x = 1 - rectA.w;
refRectB.y = rectA.y;
refRectB.w = refRectA.w;
refRectB.h = SDLTest_RandomIntegerInRange(1, refRectA.h - 1);
rectA = refRectA;
rectB = refRectB;
expectedResult.x = 0;
expectedResult.y = refRectB.y;
expectedResult.w = 1;
expectedResult.h = refRectB.h;
intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
validateIntersectRectResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
/* rectB bottom edge */
refRectB.x = rectA.x;
refRectB.y = rectA.h - 1;
refRectB.w = SDLTest_RandomIntegerInRange(1, refRectA.w - 1);
refRectB.h = SDLTest_RandomIntegerInRange(1, refRectA.h - 1);
rectA = refRectA;
rectB = refRectB;
expectedResult.x = refRectB.x;
expectedResult.y = refRectB.y;
expectedResult.w = refRectB.w;
expectedResult.h = 1;
intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
validateIntersectRectResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
/* rectB top edge */
refRectB.x = rectA.x;
refRectB.y = 1 - rectA.h;
refRectB.w = SDLTest_RandomIntegerInRange(1, refRectA.w - 1);
refRectB.h = rectA.h;
rectA = refRectA;
rectB = refRectB;
expectedResult.x = refRectB.x;
expectedResult.y = 0;
expectedResult.w = refRectB.w;
expectedResult.h = 1;
intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
validateIntersectRectResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
return TEST_COMPLETED;
}
/**
* Tests SDL_GetRectIntersection() with 1x1 pixel sized rectangles
*
* \sa SDL_GetRectIntersection
*/
static int SDLCALL rect_testIntersectRectPoint(void *arg)
{
SDL_Rect refRectA = { 0, 0, 1, 1 };
SDL_Rect refRectB = { 0, 0, 1, 1 };
SDL_Rect rectA;
SDL_Rect rectB;
SDL_Rect result;
bool intersection;
int offsetX, offsetY;
/* intersecting pixels */
refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
refRectB.x = refRectA.x;
refRectB.y = refRectA.y;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
validateIntersectRectResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB, &result, &refRectA);
/* non-intersecting pixels cases */
for (offsetX = -1; offsetX <= 1; offsetX++) {
for (offsetY = -1; offsetY <= 1; offsetY++) {
if (offsetX != 0 || offsetY != 0) {
refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
refRectB.x = refRectA.x;
refRectB.y = refRectA.y;
refRectB.x += offsetX;
refRectB.y += offsetY;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
validateIntersectRectResults(intersection, false, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
}
}
}
return TEST_COMPLETED;
}
/**
* Tests SDL_GetRectIntersection() with empty rectangles
*
* \sa SDL_GetRectIntersection
*/
static int SDLCALL rect_testIntersectRectEmpty(void *arg)
{
SDL_Rect refRectA;
SDL_Rect refRectB;
SDL_Rect rectA;
SDL_Rect rectB;
SDL_Rect result;
bool intersection;
bool empty;
/* Rect A empty */
result.w = SDLTest_RandomIntegerInRange(1, 100);
result.h = SDLTest_RandomIntegerInRange(1, 100);
refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
refRectA.w = SDLTest_RandomIntegerInRange(1, 100);
refRectA.h = SDLTest_RandomIntegerInRange(1, 100);
refRectB = refRectA;
refRectA.w = 0;
refRectA.h = 0;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
validateIntersectRectResults(intersection, false, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
empty = SDL_RectEmpty(&result);
SDLTest_AssertCheck(empty == true, "Validate result is empty Rect; got: %s", (empty == true) ? "true" : "false");
/* Rect B empty */
result.w = SDLTest_RandomIntegerInRange(1, 100);
result.h = SDLTest_RandomIntegerInRange(1, 100);
refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
refRectA.w = SDLTest_RandomIntegerInRange(1, 100);
refRectA.h = SDLTest_RandomIntegerInRange(1, 100);
refRectB = refRectA;
refRectB.w = 0;
refRectB.h = 0;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
validateIntersectRectResults(intersection, false, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
empty = SDL_RectEmpty(&result);
SDLTest_AssertCheck(empty == true, "Validate result is empty Rect; got: %s", (empty == true) ? "true" : "false");
/* Rect A and B empty */
result.w = SDLTest_RandomIntegerInRange(1, 100);
result.h = SDLTest_RandomIntegerInRange(1, 100);
refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
refRectA.w = SDLTest_RandomIntegerInRange(1, 100);
refRectA.h = SDLTest_RandomIntegerInRange(1, 100);
refRectB = refRectA;
refRectA.w = 0;
refRectA.h = 0;
refRectB.w = 0;
refRectB.h = 0;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
validateIntersectRectResults(intersection, false, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
empty = SDL_RectEmpty(&result);
SDLTest_AssertCheck(empty == true, "Validate result is empty Rect; got: %s", (empty == true) ? "true" : "false");
return TEST_COMPLETED;
}
/**
* Negative tests against SDL_GetRectIntersection() with invalid parameters
*
* \sa SDL_GetRectIntersection
*/
static int SDLCALL rect_testIntersectRectParam(void *arg)
{
SDL_Rect rectA = { 0 };
SDL_Rect rectB = { 0 };
SDL_Rect result;
bool intersection;
/* invalid parameter combinations */
intersection = SDL_GetRectIntersection((SDL_Rect *)NULL, &rectB, &result);
SDLTest_AssertCheck(intersection == false, "Check that function returns false when 1st parameter is NULL");
intersection = SDL_GetRectIntersection(&rectA, (SDL_Rect *)NULL, &result);
SDLTest_AssertCheck(intersection == false, "Check that function returns false when 2nd parameter is NULL");
intersection = SDL_GetRectIntersection(&rectA, &rectB, (SDL_Rect *)NULL);
SDLTest_AssertCheck(intersection == false, "Check that function returns false when 3rd parameter is NULL");
intersection = SDL_GetRectIntersection((SDL_Rect *)NULL, (SDL_Rect *)NULL, &result);
SDLTest_AssertCheck(intersection == false, "Check that function returns false when 1st and 2nd parameters are NULL");
intersection = SDL_GetRectIntersection((SDL_Rect *)NULL, &rectB, (SDL_Rect *)NULL);
SDLTest_AssertCheck(intersection == false, "Check that function returns false when 1st and 3rd parameters are NULL ");
intersection = SDL_GetRectIntersection((SDL_Rect *)NULL, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
SDLTest_AssertCheck(intersection == false, "Check that function returns false when all parameters are NULL");
return TEST_COMPLETED;
}
/**
* Tests SDL_HasRectIntersection() with B fully inside A
*
* \sa SDL_HasRectIntersection
*/
static int SDLCALL rect_testHasIntersectionInside(void *arg)
{
SDL_Rect refRectA = { 0, 0, 32, 32 };
SDL_Rect refRectB;
SDL_Rect rectA;
SDL_Rect rectB;
bool intersection;
/* rectB fully contained in rectA */
refRectB.x = 0;
refRectB.y = 0;
refRectB.w = SDLTest_RandomIntegerInRange(refRectA.x + 1, refRectA.x + refRectA.w - 1);
refRectB.h = SDLTest_RandomIntegerInRange(refRectA.y + 1, refRectA.y + refRectA.h - 1);
rectA = refRectA;
rectB = refRectB;
intersection = SDL_HasRectIntersection(&rectA, &rectB);
validateHasIntersectionResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB);
return TEST_COMPLETED;
}
/**
* Tests SDL_HasRectIntersection() with B fully outside A
*
* \sa SDL_HasRectIntersection
*/
static int SDLCALL rect_testHasIntersectionOutside(void *arg)
{
SDL_Rect refRectA = { 0, 0, 32, 32 };
SDL_Rect refRectB;
SDL_Rect rectA;
SDL_Rect rectB;
bool intersection;
/* rectB fully outside of rectA */
refRectB.x = refRectA.x + refRectA.w + SDLTest_RandomIntegerInRange(1, 10);
refRectB.y = refRectA.y + refRectA.h + SDLTest_RandomIntegerInRange(1, 10);
refRectB.w = refRectA.w;
refRectB.h = refRectA.h;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_HasRectIntersection(&rectA, &rectB);
validateHasIntersectionResults(intersection, false, &rectA, &rectB, &refRectA, &refRectB);
return TEST_COMPLETED;
}
/**
* Tests SDL_HasRectIntersection() with B partially intersecting A
*
* \sa SDL_HasRectIntersection
*/
static int SDLCALL rect_testHasIntersectionPartial(void *arg)
{
SDL_Rect refRectA = { 0, 0, 32, 32 };
SDL_Rect refRectB;
SDL_Rect rectA;
SDL_Rect rectB;
bool intersection;
/* rectB partially contained in rectA */
refRectB.x = SDLTest_RandomIntegerInRange(refRectA.x + 1, refRectA.x + refRectA.w - 1);
refRectB.y = SDLTest_RandomIntegerInRange(refRectA.y + 1, refRectA.y + refRectA.h - 1);
refRectB.w = refRectA.w;
refRectB.h = refRectA.h;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_HasRectIntersection(&rectA, &rectB);
validateHasIntersectionResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB);
/* rectB right edge */
refRectB.x = rectA.w - 1;
refRectB.y = rectA.y;
refRectB.w = SDLTest_RandomIntegerInRange(1, refRectA.w - 1);
refRectB.h = SDLTest_RandomIntegerInRange(1, refRectA.h - 1);
rectA = refRectA;
rectB = refRectB;
intersection = SDL_HasRectIntersection(&rectA, &rectB);
validateHasIntersectionResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB);
/* rectB left edge */
refRectB.x = 1 - rectA.w;
refRectB.y = rectA.y;
refRectB.w = refRectA.w;
refRectB.h = SDLTest_RandomIntegerInRange(1, refRectA.h - 1);
rectA = refRectA;
rectB = refRectB;
intersection = SDL_HasRectIntersection(&rectA, &rectB);
validateHasIntersectionResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB);
/* rectB bottom edge */
refRectB.x = rectA.x;
refRectB.y = rectA.h - 1;
refRectB.w = SDLTest_RandomIntegerInRange(1, refRectA.w - 1);
refRectB.h = SDLTest_RandomIntegerInRange(1, refRectA.h - 1);
rectA = refRectA;
rectB = refRectB;
intersection = SDL_HasRectIntersection(&rectA, &rectB);
validateHasIntersectionResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB);
/* rectB top edge */
refRectB.x = rectA.x;
refRectB.y = 1 - rectA.h;
refRectB.w = SDLTest_RandomIntegerInRange(1, refRectA.w - 1);
refRectB.h = rectA.h;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_HasRectIntersection(&rectA, &rectB);
validateHasIntersectionResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB);
return TEST_COMPLETED;
}
/**
* Tests SDL_HasRectIntersection() with 1x1 pixel sized rectangles
*
* \sa SDL_HasRectIntersection
*/
static int SDLCALL rect_testHasIntersectionPoint(void *arg)
{
SDL_Rect refRectA = { 0, 0, 1, 1 };
SDL_Rect refRectB = { 0, 0, 1, 1 };
SDL_Rect rectA;
SDL_Rect rectB;
bool intersection;
int offsetX, offsetY;
/* intersecting pixels */
refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
refRectB.x = refRectA.x;
refRectB.y = refRectA.y;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_HasRectIntersection(&rectA, &rectB);
validateHasIntersectionResults(intersection, true, &rectA, &rectB, &refRectA, &refRectB);
/* non-intersecting pixels cases */
for (offsetX = -1; offsetX <= 1; offsetX++) {
for (offsetY = -1; offsetY <= 1; offsetY++) {
if (offsetX != 0 || offsetY != 0) {
refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
refRectB.x = refRectA.x;
refRectB.y = refRectA.y;
refRectB.x += offsetX;
refRectB.y += offsetY;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_HasRectIntersection(&rectA, &rectB);
validateHasIntersectionResults(intersection, false, &rectA, &rectB, &refRectA, &refRectB);
}
}
}
return TEST_COMPLETED;
}
/**
* Tests SDL_HasRectIntersection() with empty rectangles
*
* \sa SDL_HasRectIntersection
*/
static int SDLCALL rect_testHasIntersectionEmpty(void *arg)
{
SDL_Rect refRectA;
SDL_Rect refRectB;
SDL_Rect rectA;
SDL_Rect rectB;
bool intersection;
/* Rect A empty */
refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
refRectA.w = SDLTest_RandomIntegerInRange(1, 100);
refRectA.h = SDLTest_RandomIntegerInRange(1, 100);
refRectB = refRectA;
refRectA.w = 0;
refRectA.h = 0;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_HasRectIntersection(&rectA, &rectB);
validateHasIntersectionResults(intersection, false, &rectA, &rectB, &refRectA, &refRectB);
/* Rect B empty */
refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
refRectA.w = SDLTest_RandomIntegerInRange(1, 100);
refRectA.h = SDLTest_RandomIntegerInRange(1, 100);
refRectB = refRectA;
refRectB.w = 0;
refRectB.h = 0;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_HasRectIntersection(&rectA, &rectB);
validateHasIntersectionResults(intersection, false, &rectA, &rectB, &refRectA, &refRectB);
/* Rect A and B empty */
refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
refRectA.w = SDLTest_RandomIntegerInRange(1, 100);
refRectA.h = SDLTest_RandomIntegerInRange(1, 100);
refRectB = refRectA;
refRectA.w = 0;
refRectA.h = 0;
refRectB.w = 0;
refRectB.h = 0;
rectA = refRectA;
rectB = refRectB;
intersection = SDL_HasRectIntersection(&rectA, &rectB);
validateHasIntersectionResults(intersection, false, &rectA, &rectB, &refRectA, &refRectB);
return TEST_COMPLETED;
}
/**
* Negative tests against SDL_HasRectIntersection() with invalid parameters
*
* \sa SDL_HasRectIntersection
*/
static int SDLCALL rect_testHasIntersectionParam(void *arg)
{
SDL_Rect rectA = { 0 };
SDL_Rect rectB = { 0 };
bool intersection;
/* invalid parameter combinations */
intersection = SDL_HasRectIntersection((SDL_Rect *)NULL, &rectB);
SDLTest_AssertCheck(intersection == false, "Check that function returns false when 1st parameter is NULL");
intersection = SDL_HasRectIntersection(&rectA, (SDL_Rect *)NULL);
SDLTest_AssertCheck(intersection == false, "Check that function returns false when 2nd parameter is NULL");
intersection = SDL_HasRectIntersection((SDL_Rect *)NULL, (SDL_Rect *)NULL);
SDLTest_AssertCheck(intersection == false, "Check that function returns false when all parameters are NULL");
return TEST_COMPLETED;
}
/**
* Test SDL_GetRectEnclosingPointsFloat()
*
* \sa SDL_GetRectEnclosingPointsFloat
*/
static int SDLCALL rect_testEnclosePointsFloat(void *arg)
{
SDL_FPoint fpts[3] = { { 1.25f, 2.5f }, { 1.75f, 3.75f }, { 3.5f, 3.0f } };
int i, count = 3;
SDL_FRect clip = { 0.0f, 1.0f, 4.0f, 4.0f };
SDL_FRect result;
SDL_GetRectEnclosingPointsFloat(fpts, count, &clip, &result);
SDLTest_AssertCheck(result.x == 1.25f && result.y == 2.5f && result.w == 2.25f && result.h == 1.25f,
"Resulting enclosing rectangle incorrect: expected (%.2f,%.2f - %.2fx%.2f), actual (%.2f,%.2f - %.2fx%.2f)",
1.25f, 2.5f, 2.25f, 1.25f, result.x, result.y, result.w, result.h);
for (i = 0; i != count; i++) {
bool inside;
inside = SDL_PointInRectFloat(&fpts[i], &clip);
SDLTest_AssertCheck(inside,
"Expected point (%.2f,%.2f) to be inside clip rect (%.2f,%.2f - %.2fx%.2f)",
fpts[i].x, fpts[i].y, clip.x, clip.y, clip.w, clip.h);
inside = SDL_PointInRectFloat(&fpts[i], &result);
SDLTest_AssertCheck(inside,
"Expected point (%.2f,%.2f) to be inside result rect (%.2f,%.2f - %.2fx%.2f)",
fpts[i].x, fpts[i].y, result.x, result.y, result.w, result.h);
}
return TEST_COMPLETED;
}
/**
* Test SDL_GetRectEnclosingPoints() without clipping
*
* \sa SDL_GetRectEnclosingPoints
*/
static int SDLCALL rect_testEnclosePoints(void *arg)
{
const int numPoints = 16;
SDL_Point refPoints[16];
SDL_Point points[16];
SDL_Rect result;
bool anyEnclosed;
bool anyEnclosedNoResult;
bool expectedEnclosed = true;
int newx, newy;
int minx = 0, maxx = 0, miny = 0, maxy = 0;
int i;
/* Create input data, tracking result */
for (i = 0; i < numPoints; i++) {
newx = SDLTest_RandomIntegerInRange(-1024, 1024);
newy = SDLTest_RandomIntegerInRange(-1024, 1024);
refPoints[i].x = newx;
refPoints[i].y = newy;
points[i].x = newx;
points[i].y = newy;
if (i == 0) {
minx = newx;
maxx = newx;
miny = newy;
maxy = newy;
} else {
if (newx < minx) {
minx = newx;
}
if (newx > maxx) {
maxx = newx;
}
if (newy < miny) {
miny = newy;
}
if (newy > maxy) {
maxy = newy;
}
}
}
/* Call function and validate - special case: no result requested */
anyEnclosedNoResult = SDL_GetRectEnclosingPoints(points, numPoints, NULL, (SDL_Rect *)NULL);
SDLTest_AssertCheck(expectedEnclosed == anyEnclosedNoResult,
"Check expected return value %s, got %s",
(expectedEnclosed == true) ? "true" : "false",
(anyEnclosedNoResult == true) ? "true" : "false");
for (i = 0; i < numPoints; i++) {
SDLTest_AssertCheck(refPoints[i].x == points[i].x && refPoints[i].y == points[i].y,
"Check that source point %i was not modified: expected (%i,%i) actual (%i,%i)",
i, refPoints[i].x, refPoints[i].y, points[i].x, points[i].y);
}
/* Call function and validate */
anyEnclosed = SDL_GetRectEnclosingPoints(points, numPoints, NULL, &result);
SDLTest_AssertCheck(expectedEnclosed == anyEnclosed,
"Check return value %s, got %s",
(expectedEnclosed == true) ? "true" : "false",
(anyEnclosed == true) ? "true" : "false");
for (i = 0; i < numPoints; i++) {
SDLTest_AssertCheck(refPoints[i].x == points[i].x && refPoints[i].y == points[i].y,
"Check that source point %i was not modified: expected (%i,%i) actual (%i,%i)",
i, refPoints[i].x, refPoints[i].y, points[i].x, points[i].y);
}
SDLTest_AssertCheck(result.x == minx && result.y == miny && result.w == (maxx - minx + 1) && result.h == (maxy - miny + 1),
"Resulting enclosing rectangle incorrect: expected (%i,%i - %i,%i), actual (%i,%i - %i,%i)",
minx, miny, maxx, maxy, result.x, result.y, result.x + result.w - 1, result.y + result.h - 1);
return TEST_COMPLETED;
}
/**
* Test SDL_GetRectEnclosingPoints() with repeated input points
*
* \sa SDL_GetRectEnclosingPoints
*/
static int SDLCALL rect_testEnclosePointsRepeatedInput(void *arg)
{
const int numPoints = 8;
const int halfPoints = 4;
SDL_Point refPoints[8];
SDL_Point points[8];
SDL_Rect result;
bool anyEnclosed;
bool anyEnclosedNoResult;
bool expectedEnclosed = true;
int newx, newy;
int minx = 0, maxx = 0, miny = 0, maxy = 0;
int i;
/* Create input data, tracking result */
for (i = 0; i < numPoints; i++) {
if (i < halfPoints) {
newx = SDLTest_RandomIntegerInRange(-1024, 1024);
newy = SDLTest_RandomIntegerInRange(-1024, 1024);
} else {
newx = refPoints[i - halfPoints].x;
newy = refPoints[i - halfPoints].y;
}
refPoints[i].x = newx;
refPoints[i].y = newy;
points[i].x = newx;
points[i].y = newy;
if (i == 0) {
minx = newx;
maxx = newx;
miny = newy;
maxy = newy;
} else {
if (newx < minx) {
minx = newx;
}
if (newx > maxx) {
maxx = newx;
}
if (newy < miny) {
miny = newy;
}
if (newy > maxy) {
maxy = newy;
}
}
}
/* Call function and validate - special case: no result requested */
anyEnclosedNoResult = SDL_GetRectEnclosingPoints(points, numPoints, NULL, (SDL_Rect *)NULL);
SDLTest_AssertCheck(expectedEnclosed == anyEnclosedNoResult,
"Check return value %s, got %s",
(expectedEnclosed == true) ? "true" : "false",
(anyEnclosedNoResult == true) ? "true" : "false");
for (i = 0; i < numPoints; i++) {
SDLTest_AssertCheck(refPoints[i].x == points[i].x && refPoints[i].y == points[i].y,
"Check that source point %i was not modified: expected (%i,%i) actual (%i,%i)",
i, refPoints[i].x, refPoints[i].y, points[i].x, points[i].y);
}
/* Call function and validate */
anyEnclosed = SDL_GetRectEnclosingPoints(points, numPoints, NULL, &result);
SDLTest_AssertCheck(expectedEnclosed == anyEnclosed,
"Check return value %s, got %s",
(expectedEnclosed == true) ? "true" : "false",
(anyEnclosed == true) ? "true" : "false");
for (i = 0; i < numPoints; i++) {
SDLTest_AssertCheck(refPoints[i].x == points[i].x && refPoints[i].y == points[i].y,
"Check that source point %i was not modified: expected (%i,%i) actual (%i,%i)",
i, refPoints[i].x, refPoints[i].y, points[i].x, points[i].y);
}
SDLTest_AssertCheck(result.x == minx && result.y == miny && result.w == (maxx - minx + 1) && result.h == (maxy - miny + 1),
"Check resulting enclosing rectangle: expected (%i,%i - %i,%i), actual (%i,%i - %i,%i)",
minx, miny, maxx, maxy, result.x, result.y, result.x + result.w - 1, result.y + result.h - 1);
return TEST_COMPLETED;
}
/**
* Test SDL_GetRectEnclosingPoints() with clipping
*
* \sa SDL_GetRectEnclosingPoints
*/
static int SDLCALL rect_testEnclosePointsWithClipping(void *arg)
{
const int numPoints = 16;
SDL_Point refPoints[16];
SDL_Point points[16];
SDL_Rect refClip;
SDL_Rect clip;
SDL_Rect result;
bool anyEnclosed;
bool anyEnclosedNoResult;
bool expectedEnclosed = false;
int newx, newy;
int minx = 0, maxx = 0, miny = 0, maxy = 0;
int i;
/* Setup clipping rectangle */
refClip.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refClip.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refClip.w = SDLTest_RandomIntegerInRange(1, 1024);
refClip.h = SDLTest_RandomIntegerInRange(1, 1024);
/* Create input data, tracking result */
for (i = 0; i < numPoints; i++) {
newx = SDLTest_RandomIntegerInRange(-1024, 1024);
newy = SDLTest_RandomIntegerInRange(-1024, 1024);
refPoints[i].x = newx;
refPoints[i].y = newy;
points[i].x = newx;
points[i].y = newy;
if ((newx >= refClip.x) && (newx < (refClip.x + refClip.w)) &&
(newy >= refClip.y) && (newy < (refClip.y + refClip.h))) {
if (expectedEnclosed == false) {
minx = newx;
maxx = newx;
miny = newy;
maxy = newy;
} else {
if (newx < minx) {
minx = newx;
}
if (newx > maxx) {
maxx = newx;
}
if (newy < miny) {
miny = newy;
}
if (newy > maxy) {
maxy = newy;
}
}
expectedEnclosed = true;
}
}
/* Call function and validate - special case: no result requested */
clip = refClip;
anyEnclosedNoResult = SDL_GetRectEnclosingPoints(points, numPoints, &clip, NULL);
SDLTest_AssertCheck(expectedEnclosed == anyEnclosedNoResult,
"Expected return value %s, got %s",
(expectedEnclosed == true) ? "true" : "false",
(anyEnclosedNoResult == true) ? "true" : "false");
for (i = 0; i < numPoints; i++) {
SDLTest_AssertCheck(refPoints[i].x == points[i].x && refPoints[i].y == points[i].y,
"Check that source point %i was not modified: expected (%i,%i) actual (%i,%i)",
i, refPoints[i].x, refPoints[i].y, points[i].x, points[i].y);
}
SDLTest_AssertCheck(refClip.x == clip.x && refClip.y == clip.y && refClip.w == clip.w && refClip.h == clip.h,
"Check that source clipping rectangle was not modified");
/* Call function and validate */
anyEnclosed = SDL_GetRectEnclosingPoints(points, numPoints, &clip, &result);
SDLTest_AssertCheck(expectedEnclosed == anyEnclosed,
"Check return value %s, got %s",
(expectedEnclosed == true) ? "true" : "false",
(anyEnclosed == true) ? "true" : "false");
for (i = 0; i < numPoints; i++) {
SDLTest_AssertCheck(refPoints[i].x == points[i].x && refPoints[i].y == points[i].y,
"Check that source point %i was not modified: expected (%i,%i) actual (%i,%i)",
i, refPoints[i].x, refPoints[i].y, points[i].x, points[i].y);
}
SDLTest_AssertCheck(refClip.x == clip.x && refClip.y == clip.y && refClip.w == clip.w && refClip.h == clip.h,
"Check that source clipping rectangle was not modified");
if (expectedEnclosed == true) {
SDLTest_AssertCheck(result.x == minx && result.y == miny && result.w == (maxx - minx + 1) && result.h == (maxy - miny + 1),
"Check resulting enclosing rectangle: expected (%i,%i - %i,%i), actual (%i,%i - %i,%i)",
minx, miny, maxx, maxy, result.x, result.y, result.x + result.w - 1, result.y + result.h - 1);
}
/* Empty clipping rectangle */
clip.w = 0;
clip.h = 0;
expectedEnclosed = false;
anyEnclosed = SDL_GetRectEnclosingPoints(points, numPoints, &clip, &result);
SDLTest_AssertCheck(expectedEnclosed == anyEnclosed,
"Check return value %s, got %s",
(expectedEnclosed == true) ? "true" : "false",
(anyEnclosed == true) ? "true" : "false");
return TEST_COMPLETED;
}
/**
* Negative tests against SDL_GetRectEnclosingPoints() with invalid parameters
*
* \sa SDL_GetRectEnclosingPoints
*/
static int SDLCALL rect_testEnclosePointsParam(void *arg)
{
SDL_Point points[1];
int count;
SDL_Rect clip = { 0 };
SDL_Rect result;
bool anyEnclosed;
/* invalid parameter combinations */
anyEnclosed = SDL_GetRectEnclosingPoints((SDL_Point *)NULL, 1, &clip, &result);
SDLTest_AssertCheck(anyEnclosed == false, "Check that functions returns false when 1st parameter is NULL");
anyEnclosed = SDL_GetRectEnclosingPoints(points, 0, &clip, &result);
SDLTest_AssertCheck(anyEnclosed == false, "Check that functions returns false when 2nd parameter is 0");
count = SDLTest_RandomIntegerInRange(-100, -1);
anyEnclosed = SDL_GetRectEnclosingPoints(points, count, &clip, &result);
SDLTest_AssertCheck(anyEnclosed == false, "Check that functions returns false when 2nd parameter is %i (negative)", count);
anyEnclosed = SDL_GetRectEnclosingPoints((SDL_Point *)NULL, 0, &clip, &result);
SDLTest_AssertCheck(anyEnclosed == false, "Check that functions returns false when 1st parameter is NULL and 2nd parameter was 0");
return TEST_COMPLETED;
}
/**
* Tests SDL_GetRectUnion() where rect B is outside rect A
*
* \sa SDL_GetRectUnion
*/
static int SDLCALL rect_testUnionRectOutside(void *arg)
{
SDL_Rect refRectA, refRectB;
SDL_Rect rectA, rectB;
SDL_Rect expectedResult;
SDL_Rect result;
int minx, maxx, miny, maxy;
int dx, dy;
/* Union 1x1 outside */
for (dx = -1; dx < 2; dx++) {
for (dy = -1; dy < 2; dy++) {
if ((dx != 0) || (dy != 0)) {
refRectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.w = 1;
refRectA.h = 1;
refRectB.x = SDLTest_RandomIntegerInRange(-1024, 1024) + dx * 2048;
refRectB.y = SDLTest_RandomIntegerInRange(-1024, 1024) + dx * 2048;
refRectB.w = 1;
refRectB.h = 1;
minx = (refRectA.x < refRectB.x) ? refRectA.x : refRectB.x;
maxx = (refRectA.x > refRectB.x) ? refRectA.x : refRectB.x;
miny = (refRectA.y < refRectB.y) ? refRectA.y : refRectB.y;
maxy = (refRectA.y > refRectB.y) ? refRectA.y : refRectB.y;
expectedResult.x = minx;
expectedResult.y = miny;
expectedResult.w = maxx - minx + 1;
expectedResult.h = maxy - miny + 1;
rectA = refRectA;
rectB = refRectB;
SDL_GetRectUnion(&rectA, &rectB, &result);
validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
}
}
}
/* Union outside overlap */
for (dx = -1; dx < 2; dx++) {
for (dy = -1; dy < 2; dy++) {
if ((dx != 0) || (dy != 0)) {
refRectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.w = SDLTest_RandomIntegerInRange(256, 512);
refRectA.h = SDLTest_RandomIntegerInRange(256, 512);
refRectB.x = refRectA.x + 1 + dx * 2;
refRectB.y = refRectA.y + 1 + dy * 2;
refRectB.w = refRectA.w - 2;
refRectB.h = refRectA.h - 2;
expectedResult = refRectA;
if (dx == -1) {
expectedResult.x--;
}
if (dy == -1) {
expectedResult.y--;
}
if ((dx == 1) || (dx == -1)) {
expectedResult.w++;
}
if ((dy == 1) || (dy == -1)) {
expectedResult.h++;
}
rectA = refRectA;
rectB = refRectB;
SDL_GetRectUnion(&rectA, &rectB, &result);
validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
}
}
}
return TEST_COMPLETED;
}
/**
* Tests SDL_GetRectUnion() where rect A or rect B are empty
*
* \sa SDL_GetRectUnion
*/
static int SDLCALL rect_testUnionRectEmpty(void *arg)
{
SDL_Rect refRectA, refRectB;
SDL_Rect rectA, rectB;
SDL_Rect expectedResult;
SDL_Rect result;
/* A empty */
refRectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.w = 0;
refRectA.h = 0;
refRectB.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectB.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectB.w = SDLTest_RandomIntegerInRange(1, 1024);
refRectB.h = SDLTest_RandomIntegerInRange(1, 1024);
expectedResult = refRectB;
rectA = refRectA;
rectB = refRectB;
SDL_GetRectUnion(&rectA, &rectB, &result);
validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
/* B empty */
refRectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.w = SDLTest_RandomIntegerInRange(1, 1024);
refRectA.h = SDLTest_RandomIntegerInRange(1, 1024);
refRectB.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectB.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectB.w = 0;
refRectB.h = 0;
expectedResult = refRectA;
rectA = refRectA;
rectB = refRectB;
SDL_GetRectUnion(&rectA, &rectB, &result);
validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
/* A and B empty */
refRectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.w = 0;
refRectA.h = 0;
refRectB.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectB.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectB.w = 0;
refRectB.h = 0;
result.x = 0;
result.y = 0;
result.w = 0;
result.h = 0;
expectedResult = result;
rectA = refRectA;
rectB = refRectB;
SDL_GetRectUnion(&rectA, &rectB, &result);
validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
return TEST_COMPLETED;
}
/**
* Tests SDL_GetRectUnion() where rect B is inside rect A
*
* \sa SDL_GetRectUnion
*/
static int SDLCALL rect_testUnionRectInside(void *arg)
{
SDL_Rect refRectA, refRectB;
SDL_Rect rectA, rectB;
SDL_Rect expectedResult;
SDL_Rect result;
int dx, dy;
/* Union 1x1 with itself */
refRectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.w = 1;
refRectA.h = 1;
expectedResult = refRectA;
rectA = refRectA;
SDL_GetRectUnion(&rectA, &rectA, &result);
validateUnionRectResults(&rectA, &rectA, &refRectA, &refRectA, &result, &expectedResult);
/* Union 1x1 somewhere inside */
refRectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.w = SDLTest_RandomIntegerInRange(256, 1024);
refRectA.h = SDLTest_RandomIntegerInRange(256, 1024);
refRectB.x = refRectA.x + 1 + SDLTest_RandomIntegerInRange(1, refRectA.w - 2);
refRectB.y = refRectA.y + 1 + SDLTest_RandomIntegerInRange(1, refRectA.h - 2);
refRectB.w = 1;
refRectB.h = 1;
expectedResult = refRectA;
rectA = refRectA;
rectB = refRectB;
SDL_GetRectUnion(&rectA, &rectB, &result);
validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
/* Union inside with edges modified */
for (dx = -1; dx < 2; dx++) {
for (dy = -1; dy < 2; dy++) {
if ((dx != 0) || (dy != 0)) {
refRectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.w = SDLTest_RandomIntegerInRange(256, 1024);
refRectA.h = SDLTest_RandomIntegerInRange(256, 1024);
refRectB = refRectA;
if (dx == -1) {
refRectB.x++;
}
if ((dx == 1) || (dx == -1)) {
refRectB.w--;
}
if (dy == -1) {
refRectB.y++;
}
if ((dy == 1) || (dy == -1)) {
refRectB.h--;
}
expectedResult = refRectA;
rectA = refRectA;
rectB = refRectB;
SDL_GetRectUnion(&rectA, &rectB, &result);
validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
}
}
}
return TEST_COMPLETED;
}
/**
* Negative tests against SDL_GetRectUnion() with invalid parameters
*
* \sa SDL_GetRectUnion
*/
static int SDLCALL rect_testUnionRectParam(void *arg)
{
SDL_Rect rectA = { 0 }, rectB = { 0 };
SDL_Rect result;
/* invalid parameter combinations */
SDL_GetRectUnion((SDL_Rect *)NULL, &rectB, &result);
SDLTest_AssertPass("Check that function returns when 1st parameter is NULL");
SDL_GetRectUnion(&rectA, (SDL_Rect *)NULL, &result);
SDLTest_AssertPass("Check that function returns when 2nd parameter is NULL");
SDL_GetRectUnion(&rectA, &rectB, (SDL_Rect *)NULL);
SDLTest_AssertPass("Check that function returns when 3rd parameter is NULL");
SDL_GetRectUnion((SDL_Rect *)NULL, &rectB, (SDL_Rect *)NULL);
SDLTest_AssertPass("Check that function returns when 1st and 3rd parameter are NULL");
SDL_GetRectUnion(&rectA, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
SDLTest_AssertPass("Check that function returns when 2nd and 3rd parameter are NULL");
SDL_GetRectUnion((SDL_Rect *)NULL, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
SDLTest_AssertPass("Check that function returns when all parameters are NULL");
return TEST_COMPLETED;
}
/**
* Tests SDL_RectEmptyFloat() with various inputs
*
* \sa SDL_RectEmptyFloat
*/
static int SDLCALL rect_testRectEmptyFloat(void *arg)
{
SDL_FRect rect;
bool result;
rect.x = 0.0f;
rect.y = 0.0f;
rect.w = 1.0f;
rect.h = 1.0f;
result = SDL_RectEmptyFloat(&rect);
validateRectEmptyFloatResults(result, false, &rect);
rect.x = 0.0f;
rect.y = 0.0f;
rect.w = 0.0f;
rect.h = 0.0f;
result = SDL_RectEmptyFloat(&rect);
validateRectEmptyFloatResults(result, false, &rect);
rect.x = 0.0f;
rect.y = 0.0f;
rect.w = -1.0f;
rect.h = 1.0f;
result = SDL_RectEmptyFloat(&rect);
validateRectEmptyFloatResults(result, true, &rect);
rect.x = 0.0f;
rect.y = 0.0f;
rect.w = 1.0f;
rect.h = -1.0f;
result = SDL_RectEmptyFloat(&rect);
validateRectEmptyFloatResults(result, true, &rect);
return TEST_COMPLETED;
}
/**
* Tests SDL_RectEmpty() with various inputs
*
* \sa SDL_RectEmpty
*/
static int SDLCALL rect_testRectEmpty(void *arg)
{
SDL_Rect refRect;
SDL_Rect rect;
bool expectedResult;
bool result;
int w, h;
/* Non-empty case */
refRect.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRect.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRect.w = SDLTest_RandomIntegerInRange(256, 1024);
refRect.h = SDLTest_RandomIntegerInRange(256, 1024);
expectedResult = false;
rect = refRect;
result = SDL_RectEmpty(&rect);
validateRectEmptyResults(result, expectedResult, &rect, &refRect);
/* Empty case */
for (w = -1; w < 2; w++) {
for (h = -1; h < 2; h++) {
if ((w != 1) || (h != 1)) {
refRect.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRect.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRect.w = w;
refRect.h = h;
expectedResult = true;
rect = refRect;
result = SDL_RectEmpty(&rect);
validateRectEmptyResults(result, expectedResult, &rect, &refRect);
}
}
}
return TEST_COMPLETED;
}
/**
* Negative tests against SDL_RectEmpty() with invalid parameters
*
* \sa SDL_RectEmpty
*/
static int SDLCALL rect_testRectEmptyParam(void *arg)
{
bool result;
/* invalid parameter combinations */
result = SDL_RectEmpty(NULL);
SDLTest_AssertCheck(result == true, "Check that function returns TRUE when 1st parameter is NULL");
return TEST_COMPLETED;
}
/**
* Tests SDL_RectsEqual() with various inputs
*
* \sa SDL_RectsEqual
*/
static int SDLCALL rect_testRectEquals(void *arg)
{
SDL_Rect refRectA;
SDL_Rect refRectB;
SDL_Rect rectA;
SDL_Rect rectB;
bool expectedResult;
bool result;
/* Equals */
refRectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.y = SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.w = SDLTest_RandomIntegerInRange(1, 1024);
refRectA.h = SDLTest_RandomIntegerInRange(1, 1024);
refRectB = refRectA;
expectedResult = true;
rectA = refRectA;
rectB = refRectB;
result = SDL_RectsEqual(&rectA, &rectB);
validateRectEqualsResults(result, expectedResult, &rectA, &rectB, &refRectA, &refRectB);
return TEST_COMPLETED;
}
/**
* Negative tests against SDL_RectsEqual() with invalid parameters
*
* \sa SDL_RectsEqual
*/
static int SDLCALL rect_testRectEqualsParam(void *arg)
{
SDL_Rect rectA;
SDL_Rect rectB;
bool result;
/* data setup */
rectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
rectA.y = SDLTest_RandomIntegerInRange(-1024, 1024);
rectA.w = SDLTest_RandomIntegerInRange(1, 1024);
rectA.h = SDLTest_RandomIntegerInRange(1, 1024);
rectB.x = SDLTest_RandomIntegerInRange(-1024, 1024);
rectB.y = SDLTest_RandomIntegerInRange(-1024, 1024);
rectB.w = SDLTest_RandomIntegerInRange(1, 1024);
rectB.h = SDLTest_RandomIntegerInRange(1, 1024);
/* invalid parameter combinations */
result = SDL_RectsEqual(NULL, &rectB);
SDLTest_AssertCheck(result == false, "Check that function returns false when 1st parameter is NULL");
result = SDL_RectsEqual(&rectA, NULL);
SDLTest_AssertCheck(result == false, "Check that function returns false when 2nd parameter is NULL");
result = SDL_RectsEqual(NULL, NULL);
SDLTest_AssertCheck(result == false, "Check that function returns false when 1st and 2nd parameter are NULL");
return TEST_COMPLETED;
}
/**
* Tests SDL_RectsEqualFloat() with various inputs
*
* \sa SDL_RectsEqualFloat
*/
static int SDLCALL rect_testFRectEquals(void *arg)
{
SDL_FRect refRectA;
SDL_FRect refRectB;
SDL_FRect rectA;
SDL_FRect rectB;
bool expectedResult;
bool result;
/* Equals */
refRectA.x = (float)SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.y = (float)SDLTest_RandomIntegerInRange(-1024, 1024);
refRectA.w = (float)SDLTest_RandomIntegerInRange(1, 1024);
refRectA.h = (float)SDLTest_RandomIntegerInRange(1, 1024);
refRectB = refRectA;
expectedResult = true;
rectA = refRectA;
rectB = refRectB;
result = SDL_RectsEqualFloat(&rectA, &rectB);
validateFRectEqualsResults(result, expectedResult, &rectA, &rectB, &refRectA, &refRectB);
return TEST_COMPLETED;
}
/**
* Negative tests against SDL_RectsEqualFloat() with invalid parameters
*
* \sa SDL_RectsEqualFloat
*/
static int SDLCALL rect_testFRectEqualsParam(void *arg)
{
SDL_FRect rectA;
SDL_FRect rectB;
bool result;
/* data setup -- For the purpose of this test, the values don't matter. */
rectA.x = SDLTest_RandomFloat();
rectA.y = SDLTest_RandomFloat();
rectA.w = SDLTest_RandomFloat();
rectA.h = SDLTest_RandomFloat();
rectB.x = SDLTest_RandomFloat();
rectB.y = SDLTest_RandomFloat();
rectB.w = SDLTest_RandomFloat();
rectB.h = SDLTest_RandomFloat();
/* invalid parameter combinations */
result = SDL_RectsEqualFloat(NULL, &rectB);
SDLTest_AssertCheck(result == false, "Check that function returns false when 1st parameter is NULL");
result = SDL_RectsEqualFloat(&rectA, NULL);
SDLTest_AssertCheck(result == false, "Check that function returns false when 2nd parameter is NULL");
result = SDL_RectsEqualFloat(NULL, NULL);
SDLTest_AssertCheck(result == false, "Check that function returns false when 1st and 2nd parameter are NULL");
return TEST_COMPLETED;
}
/* !
* \brief Test SDL_HasRectIntersectionFloat
*
* \sa
* http://wiki.libsdl.org/SDL3/SDL_HasRectIntersectionFloat
*/
static int SDLCALL rect_testHasIntersectionFloat(void *arg)
{
const struct {
SDL_FRect r1;
SDL_FRect r2;
bool expected;
} cases[] = {
{ { 0, 0, 0, 0 }, {0, 0, 0, 0}, true },
{ { 0, 0, -200, 200 }, {0, 0, -200, 200}, false },
{ { 0, 0, 10, 10 }, {-5, 5, 10, 2}, true },
{ { 0, 0, 10, 10 }, {-5, -5, 10, 2}, false },
{ { 0, 0, 10, 10 }, {-5, -5, 2, 10}, false },
{ { 0, 0, 10, 10 }, {-5, -5, 5, 5}, true },
{ { 0, 0, 10, 10 }, {-5, -5, 5.1f, 5.1f}, true },
{ { 0, 0, 10, 10 }, {-4.99f, -4.99f, 5, 5}, true },
};
size_t i;
for (i = 0; i < SDL_arraysize(cases); i++) {
bool result;
SDLTest_AssertPass("About to call SDL_HasRectIntersectionFloat(&{ %g, %g, %g, %g }, &{ %g, %g, %g, %g })",
cases[i].r1.x, cases[i].r1.y, cases[i].r1.w, cases[i].r1.h,
cases[i].r2.x, cases[i].r2.y, cases[i].r2.w, cases[i].r2.h
);
result = SDL_HasRectIntersectionFloat(&cases[i].r1, &cases[i].r2);
SDLTest_AssertCheck(result == cases[i].expected, "Got %d, expected %d", result, cases[i].expected);
}
return TEST_COMPLETED;
}
/* !
* \brief Test SDL_GetRectIntersectionFloat
*
* \sa
* http://wiki.libsdl.org/SDL3/SDL_GetRectIntersectionFloat
*/
static int SDLCALL rect_testGetRectIntersectionFloat(void *arg)
{
const struct {
SDL_FRect r1;
SDL_FRect r2;
bool result;
SDL_FRect intersect;
} cases[] = {
{ { 0, 0, 0, 0 }, { 0, 0, 0, 0 }, true },
{ { 0, 0, -200, 200 }, { 0, 0, -200, 200 }, false },
{ { 0, 0, 10, 10 }, { -5, 5, 9.9f, 2 }, true, { 0, 5, 4.9f, 2 } },
{ { 0, 0, 10, 10 }, { -5, -5, 10, 2 }, false},
{ { 0, 0, 10, 10 }, { -5, -5, 2, 10 }, false},
{ { 0, 0, 10, 10 }, { -5, -5, 5, 5 }, true},
{ { 0, 0, 10, 10 }, { -5, -5, 5.5f, 6 }, true, { 0, 0, 0.5f, 1 } }
};
size_t i;
for (i = 0; i < SDL_arraysize(cases); i++) {
bool result;
SDL_FRect intersect;
SDLTest_AssertPass("About to call SDL_GetRectIntersectionFloat(&{ %g, %g, %g, %g }, &{ %g, %g, %g, %g })",
cases[i].r1.x, cases[i].r1.y, cases[i].r1.w, cases[i].r1.h,
cases[i].r2.x, cases[i].r2.y, cases[i].r2.w, cases[i].r2.h
);
result = SDL_GetRectIntersectionFloat(&cases[i].r1, &cases[i].r2, &intersect);
SDLTest_AssertCheck(result == cases[i].result, "Got %d, expected %d", result, cases[i].result);
if (cases[i].result) {
SDLTest_AssertCheck(IsFRectEqual(&intersect, &cases[i].intersect),
"Got { %g, %g, %g, %g }, expected { %g, %g, %g, %g }",
intersect.x, intersect.y, intersect.w, intersect.h,
cases[i].intersect.x, cases[i].intersect.y, cases[i].intersect.w, cases[i].intersect.h);
}
}
return TEST_COMPLETED;
}
/* !
* \brief Test SDL_GetRectUnionFloat
*
* \sa
* http://wiki.libsdl.org/SDL3/SDL_GetRectUnionFloat
*/
static int SDLCALL rect_testGetRectUntionFloat(void *arg)
{
const struct {
SDL_FRect r1;
SDL_FRect r2;
SDL_FRect expected;
} cases[] = {
{ { 0, 0, 10, 10 }, { 19.9f, 20, 10, 10 }, { 0, 0, 29.9f, 30 } },
{ { 0, 0, 0, 0 }, { 20, 20.1f, 10.1f, 10 }, { 0, 0.f, 30.1f, 30.1f } },
{ { -200, -4.5f, 450, 33 }, { 20, 20, 10, 10 }, { -200, -4.5f, 450, 34.5f } },
{ { 0, 0, 15, 16.5f }, { 20, 20, 0, 0 }, { 0, 0, 20.f, 20.f } }
};
size_t i;
for (i = 0; i < SDL_arraysize(cases); i++) {
SDL_FRect result;
SDLTest_AssertPass("About to call SDL_GetRectUnionFloat(&{ %g, %g, %g, %g }, &{ %g, %g, %g, %g })",
cases[i].r1.x, cases[i].r1.y, cases[i].r1.w, cases[i].r1.h,
cases[i].r2.x, cases[i].r2.y, cases[i].r2.w, cases[i].r2.h
);
SDL_GetRectUnionFloat(&cases[i].r1, &cases[i].r2, &result);
SDLTest_AssertCheck(IsFRectEqual(&result, &cases[i].expected),
"Got { %g, %g, %g, %g }, expected { %g, %g, %g, %g }",
result.x, result.y, result.w, result.h,
cases[i].expected.x, cases[i].expected.y, cases[i].expected.w, cases[i].expected.h);
}
return TEST_COMPLETED;
}
/* !
* \brief Test SDL_EncloseFPointsUnionFRect
*
* \sa
* http://wiki.libsdl.org/SDL3/SDL_GetRectEnclosingPointsFloat
*/
static int SDLCALL rect_testGetRectEnclosingPointsFloat(void *arg)
{
const struct {
bool with_clip;
SDL_FRect clip;
bool result;
SDL_FRect enclosing;
} cases[] = {
{ true, { 0, 0, 10, 10 }, true, { 0.5f, 0.1f, 5, 7 }},
{ true, { 1.2f, 1, 10, 10 }, true, { 1.5f, 1.1f, 4, 6 }},
{ true, { -10, -10, 3, 3 }, false },
{ false, { 0 }, true, { 0.5f, 0.1f, 5, 7 }}
};
const SDL_FPoint points[] = {
{ 0.5f, 0.1f },
{ 5.5f, 7.1f },
{ 1.5f, 1.1f }
};
char points_str[256];
size_t i;
SDL_strlcpy(points_str, "{", sizeof(points_str));
for (i = 0; i < SDL_arraysize(points); i++) {
char point_str[32];
SDL_snprintf(point_str, sizeof(point_str), "{ %g, %g }, ", points[i].x, points[i].y);
SDL_strlcat(points_str, point_str, sizeof(points_str));
}
SDL_strlcat(points_str, "}", sizeof(points_str));
for (i = 0; i < SDL_arraysize(cases); i++) {
char clip_str[64];
bool result;
SDL_FRect enclosing;
const SDL_FRect* clip_ptr = NULL;
if (cases[i].with_clip) {
SDL_snprintf(clip_str, sizeof(clip_str), "&{ %g, %g, %g, %g }",
cases[i].clip.x, cases[i].clip.y, cases[i].clip.w, cases[i].clip.h);
clip_ptr = &cases[i].clip;
} else {
SDL_strlcpy(clip_str, "NULL", sizeof(clip_str));
}
SDLTest_AssertPass("About to call SDL_GetRectEnclosingPointsFloat(&%s, %d, %s)", points_str, (int)SDL_arraysize(points), clip_str);
result = SDL_GetRectEnclosingPointsFloat(points, SDL_arraysize(points), clip_ptr, &enclosing);
SDLTest_AssertCheck(result == cases[i].result, "Got %d, expected %d", result, cases[i].result);
if (cases[i].result) {
SDLTest_AssertCheck(IsFRectEqual(&enclosing, &cases[i].enclosing),
"Got { %g, %g, %g, %g }, expected { %g, %g, %g, %g }",
enclosing.x, enclosing.y, enclosing.w, enclosing.h,
cases[i].enclosing.x, cases[i].enclosing.y, cases[i].enclosing.w, cases[i].enclosing.h);
}
}
return TEST_COMPLETED;
}
/* !
* \brief Test SDL_GetRectAndLineIntersectionFloat
*
* \sa
* http://wiki.libsdl.org/SDL3/SDL_GetRectAndLineIntersectionFloat
*/
static int SDLCALL rect_testGetRectAndLineIntersectionFloat(void *arg)
{
const struct {
SDL_FRect rect;
SDL_FPoint p1;
SDL_FPoint p2;
bool result;
SDL_FPoint expected1;
SDL_FPoint expected2;
} cases[] = {
{ { 0, 0, 0, 0 }, { -4.8f, -4.8f }, { 5.2f, 5.2f}, true, { 0, 0 }, { 0, 0 } },
{ { 0, 0, 2, 2 }, { -1, -1 }, { 3.5f, 3.5f}, true, { 0, 0 }, { 2, 2 } },
{ { -4, -4, 14, 14 }, { 8, 22 }, { 8, 33}, false }
};
size_t i;
for (i = 0; i < SDL_arraysize(cases); i++) {
bool result;
SDL_FPoint p1 = cases[i].p1;
SDL_FPoint p2 = cases[i].p2;
SDLTest_AssertPass("About to call SDL_GetRectAndLineIntersectionFloat(&{%g, %g, %g, %g}, &%g, &%g, &%g, &%g)",
cases[i].rect.x, cases[i].rect.y, cases[i].rect.w, cases[i].rect.h,
p1.x, p1.y, p2.x, p2.y);
result = SDL_GetRectAndLineIntersectionFloat(&cases[i].rect, &p1.x, &p1.y, &p2.x, &p2.y);
SDLTest_AssertCheck(result == cases[i].result, "Got %d, expected %d", result, cases[i].result);
if (cases[i].result) {
SDLTest_AssertCheck(IsFPointEqual(&p1, &cases[i].expected1),
"Got p1={ %g, %g }, expected p1={ %g, %g }",
p1.x, p1.y,
cases[i].expected1.x, cases[i].expected1.y);
SDLTest_AssertCheck(IsFPointEqual(&p2, &cases[i].expected2),
"Got p2={ %g, %g }, expected p2={ %g, %g }",
p2.x, p2.y,
cases[i].expected2.x, cases[i].expected2.y);
}
}
return TEST_COMPLETED;
}
/* ================= Test References ================== */
/* Rect test cases */
/* SDL_GetRectAndLineIntersectionFloat */
static const SDLTest_TestCaseReference rectTestIntersectRectAndLineFloat = {
rect_testIntersectRectAndLineFloat, "rect_testIntersectRectAndLineFloat", "Tests SDL_GetRectAndLineIntersectionFloat", TEST_ENABLED
};
/* SDL_GetRectAndLineIntersection */
static const SDLTest_TestCaseReference rectTestIntersectRectAndLine = {
rect_testIntersectRectAndLine, "rect_testIntersectRectAndLine", "Tests SDL_GetRectAndLineIntersection clipping cases", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestIntersectRectAndLineInside = {
rect_testIntersectRectAndLineInside, "rect_testIntersectRectAndLineInside", "Tests SDL_GetRectAndLineIntersection with line fully contained in rect", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestIntersectRectAndLineOutside = {
rect_testIntersectRectAndLineOutside, "rect_testIntersectRectAndLineOutside", "Tests SDL_GetRectAndLineIntersection with line fully outside of rect", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestIntersectRectAndLineEmpty = {
rect_testIntersectRectAndLineEmpty, "rect_testIntersectRectAndLineEmpty", "Tests SDL_GetRectAndLineIntersection with empty rectangle ", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestIntersectRectAndLineParam = {
rect_testIntersectRectAndLineParam, "rect_testIntersectRectAndLineParam", "Negative tests against SDL_GetRectAndLineIntersection with invalid parameters", TEST_ENABLED
};
/* SDL_GetRectIntersectionFloat */
static const SDLTest_TestCaseReference rectTestIntersectRectFloat = {
rect_testIntersectRectFloat, "rect_testIntersectRectFloat", "Tests SDL_GetRectIntersectionFloat", TEST_ENABLED
};
/* SDL_GetRectIntersection */
static const SDLTest_TestCaseReference rectTestIntersectRectInside = {
rect_testIntersectRectInside, "rect_testIntersectRectInside", "Tests SDL_GetRectIntersection with B fully contained in A", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestIntersectRectOutside = {
rect_testIntersectRectOutside, "rect_testIntersectRectOutside", "Tests SDL_GetRectIntersection with B fully outside of A", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestIntersectRectPartial = {
rect_testIntersectRectPartial, "rect_testIntersectRectPartial", "Tests SDL_GetRectIntersection with B partially intersecting A", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestIntersectRectPoint = {
rect_testIntersectRectPoint, "rect_testIntersectRectPoint", "Tests SDL_GetRectIntersection with 1x1 sized rectangles", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestIntersectRectEmpty = {
rect_testIntersectRectEmpty, "rect_testIntersectRectEmpty", "Tests SDL_GetRectIntersection with empty rectangles", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestIntersectRectParam = {
rect_testIntersectRectParam, "rect_testIntersectRectParam", "Negative tests against SDL_GetRectIntersection with invalid parameters", TEST_ENABLED
};
/* SDL_HasRectIntersection */
static const SDLTest_TestCaseReference rectTestHasIntersectionInside = {
rect_testHasIntersectionInside, "rect_testHasIntersectionInside", "Tests SDL_HasRectIntersection with B fully contained in A", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestHasIntersectionOutside = {
rect_testHasIntersectionOutside, "rect_testHasIntersectionOutside", "Tests SDL_HasRectIntersection with B fully outside of A", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestHasIntersectionPartial = {
rect_testHasIntersectionPartial, "rect_testHasIntersectionPartial", "Tests SDL_HasRectIntersection with B partially intersecting A", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestHasIntersectionPoint = {
rect_testHasIntersectionPoint, "rect_testHasIntersectionPoint", "Tests SDL_HasRectIntersection with 1x1 sized rectangles", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestHasIntersectionEmpty = {
rect_testHasIntersectionEmpty, "rect_testHasIntersectionEmpty", "Tests SDL_HasRectIntersection with empty rectangles", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestHasIntersectionParam = {
rect_testHasIntersectionParam, "rect_testHasIntersectionParam", "Negative tests against SDL_HasRectIntersection with invalid parameters", TEST_ENABLED
};
/* SDL_GetRectEnclosingPointsFloat */
static const SDLTest_TestCaseReference rectTestEnclosePointsFloat = {
rect_testEnclosePointsFloat, "rect_testEnclosePointsFloat", "Tests SDL_GetRectEnclosingPointsFloat", TEST_ENABLED
};
/* SDL_GetRectEnclosingPoints */
static const SDLTest_TestCaseReference rectTestEnclosePoints = {
rect_testEnclosePoints, "rect_testEnclosePoints", "Tests SDL_GetRectEnclosingPoints without clipping", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestEnclosePointsWithClipping = {
rect_testEnclosePointsWithClipping, "rect_testEnclosePointsWithClipping", "Tests SDL_GetRectEnclosingPoints with clipping", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestEnclosePointsRepeatedInput = {
rect_testEnclosePointsRepeatedInput, "rect_testEnclosePointsRepeatedInput", "Tests SDL_GetRectEnclosingPoints with repeated input", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestEnclosePointsParam = {
rect_testEnclosePointsParam, "rect_testEnclosePointsParam", "Negative tests against SDL_GetRectEnclosingPoints with invalid parameters", TEST_ENABLED
};
/* SDL_GetRectUnion */
static const SDLTest_TestCaseReference rectTestUnionRectInside = {
rect_testUnionRectInside, "rect_testUnionRectInside", "Tests SDL_GetRectUnion where rect B is inside rect A", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestUnionRectOutside = {
rect_testUnionRectOutside, "rect_testUnionRectOutside", "Tests SDL_GetRectUnion where rect B is outside rect A", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestUnionRectEmpty = {
rect_testUnionRectEmpty, "rect_testUnionRectEmpty", "Tests SDL_GetRectUnion where rect A or rect B are empty", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestUnionRectParam = {
rect_testUnionRectParam, "rect_testUnionRectParam", "Negative tests against SDL_GetRectUnion with invalid parameters", TEST_ENABLED
};
/* SDL_RectEmptyFloat */
static const SDLTest_TestCaseReference rectTestRectEmptyFloat = {
rect_testRectEmptyFloat, "rect_testRectEmptyFloat", "Tests SDL_RectEmptyFloat with various inputs", TEST_ENABLED
};
/* SDL_RectEmpty */
static const SDLTest_TestCaseReference rectTestRectEmpty = {
rect_testRectEmpty, "rect_testRectEmpty", "Tests SDL_RectEmpty with various inputs", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestRectEmptyParam = {
rect_testRectEmptyParam, "rect_testRectEmptyParam", "Negative tests against SDL_RectEmpty with invalid parameters", TEST_ENABLED
};
/* SDL_RectsEqual */
static const SDLTest_TestCaseReference rectTestRectEquals = {
rect_testRectEquals, "rect_testRectEquals", "Tests SDL_RectsEqual with various inputs", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestRectEqualsParam = {
rect_testRectEqualsParam, "rect_testRectEqualsParam", "Negative tests against SDL_RectsEqual with invalid parameters", TEST_ENABLED
};
/* SDL_RectsEqualFloat */
static const SDLTest_TestCaseReference rectTestFRectEquals = {
rect_testFRectEquals, "rect_testFRectEquals", "Tests SDL_RectsEqualFloat with various inputs", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestFRectEqualsParam = {
rect_testFRectEqualsParam, "rect_testFRectEqualsParam", "Negative tests against SDL_RectsEqualFloat with invalid parameters", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestHasIntersectionFloat = {
rect_testHasIntersectionFloat, "rect_testHasIntersectionFloat", "Tests SDL_HasRectIntersectionFloat", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestGetRectIntersectionFloat = {
rect_testGetRectIntersectionFloat, "rect_testGetRectIntersectionFloat", "Tests SDL_GetRectIntersectionFloat", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestGetRectUntionFloat = {
rect_testGetRectUntionFloat, "rect_testGetRectUntionFloat", "Tests SDL_GetRectUnionFloat", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestGetRectEnclosingPointsFloat = {
rect_testGetRectEnclosingPointsFloat, "rect_testGetRectEnclosingPointsFloat", "Tests SDL_GetRectEnclosingPointsFloat", TEST_ENABLED
};
static const SDLTest_TestCaseReference rectTestGetRectAndLineIntersectionFloat = {
rect_testGetRectAndLineIntersectionFloat, "rect_testGetRectAndLineIntersectionFloat", "Tests SDL_GetRectAndLineIntersectionFloat", TEST_ENABLED
};
/**
* Sequence of Rect test cases; functions that handle simple rectangles including overlaps and merges.
*/
static const SDLTest_TestCaseReference *rectTests[] = {
&rectTestIntersectRectAndLineFloat,
&rectTestIntersectRectAndLine,
&rectTestIntersectRectAndLineInside,
&rectTestIntersectRectAndLineOutside,
&rectTestIntersectRectAndLineEmpty,
&rectTestIntersectRectAndLineParam,
&rectTestIntersectRectFloat,
&rectTestIntersectRectInside,
&rectTestIntersectRectOutside,
&rectTestIntersectRectPartial,
&rectTestIntersectRectPoint,
&rectTestIntersectRectEmpty,
&rectTestIntersectRectParam,
&rectTestHasIntersectionInside,
&rectTestHasIntersectionOutside,
&rectTestHasIntersectionPartial,
&rectTestHasIntersectionPoint,
&rectTestHasIntersectionEmpty,
&rectTestHasIntersectionParam,
&rectTestEnclosePointsFloat,
&rectTestEnclosePoints,
&rectTestEnclosePointsWithClipping,
&rectTestEnclosePointsRepeatedInput,
&rectTestEnclosePointsParam,
&rectTestUnionRectInside,
&rectTestUnionRectOutside,
&rectTestUnionRectEmpty,
&rectTestUnionRectParam,
&rectTestRectEmptyFloat,
&rectTestRectEmpty,
&rectTestRectEmptyParam,
&rectTestRectEquals,
&rectTestRectEqualsParam,
&rectTestFRectEquals,
&rectTestFRectEqualsParam,
&rectTestHasIntersectionFloat,
&rectTestGetRectIntersectionFloat,
&rectTestGetRectUntionFloat,
&rectTestGetRectEnclosingPointsFloat,
&rectTestGetRectAndLineIntersectionFloat,
NULL
};
/* Rect test suite (global) */
SDLTest_TestSuiteReference rectTestSuite = {
"Rect",
NULL,
rectTests,
NULL
};
Reference in New Issue View Git Blame Copy Permalink