libsdl-org-mirror/test/testautomation_rect.c

/**
 * 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;
    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;
    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, 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
};