/**

 * Original code: automated SDL rect test written by Edgar Simo "bobbens"

 * New/updated tests: aschiffler at ferzkopp dot net

 */

#include <stdio.h>

#include "SDL.h"

#include "SDL_test.h"

/* ================= Test Case Implementation ================== */

/* Helper functions */

/*!

 * \brief Private helper to check SDL_IntersectRectAndLine results

 */

void _validateIntersectRectAndLineResults(

    SDL_bool intersection, SDL_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 == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",

        (intersection == SDL_TRUE) ? "SDL_TRUE" : "SDL_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 */

/*!

 * \brief Tests SDL_IntersectRectAndLine() clipping cases

 *

 * \sa

 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine

 */

int

rect_testIntersectRectAndLine (void *arg)

{

    SDL_Rect refRect = { 0, 0, 32, 32 };

    SDL_Rect rect;

    int x1, y1;

    int x2, y2;

    SDL_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_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 0, 15, 31, 15);

    x1 = 15;

    y1 = yTop;

    x2 = 15;

    y2 = yBottom;

    rect = refRect;

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_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_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

     _validateIntersectRectAndLineResults(intersected, SDL_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_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 31, 31, 0, 0);

    x1 = -1;

    y1 = 32;

    x2 = 32;

    y2 = -1;

    rect = refRect;

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 0, 31, 31, 0);

    x1 = 32;

    y1 = -1;

    x2 = -1;

    y2 = 32;

    rect = refRect;

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 31, 0, 0, 31);

    return TEST_COMPLETED;

}

/*!

 * \brief Tests SDL_IntersectRectAndLine() non-clipping case line inside

 *

 * \sa

 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine

 */

int

rect_testIntersectRectAndLineInside (void *arg)

{

    SDL_Rect refRect = { 0, 0, 32, 32 };

    SDL_Rect rect;

    int x1, y1;

    int x2, y2;

    SDL_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_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, x2Ref, y2Ref);

    x1 = x1Ref;

    y1 = y1Ref;

    x2 = xmax;

    y2 = ymax;

    rect = refRect;

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, xmax, ymax);

    x1 = xmin;

    y1 = ymin;

    x2 = x2Ref;

    y2 = y2Ref;

    rect = refRect;

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, xmin, ymin, x2Ref, y2Ref);

    x1 = xmin;

    y1 = ymin;

    x2 = xmax;

    y2 = ymax;

    rect = refRect;

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, xmin, ymin, xmax, ymax);

    x1 = xmin;

    y1 = ymax;

    x2 = xmax;

    y2 = ymin;

    rect = refRect;

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, xmin, ymax, xmax, ymin);

    return TEST_COMPLETED;

}

/*!

 * \brief Tests SDL_IntersectRectAndLine() non-clipping cases outside

 *

 * \sa

 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine

 */

int

rect_testIntersectRectAndLineOutside (void *arg)

{

    SDL_Rect refRect = { 0, 0, 32, 32 };

    SDL_Rect rect;

    int x1, y1;

    int x2, y2;

    SDL_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_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, xLeft, 0, xLeft, 31);

    x1 = xRight;

    y1 = 0;

    x2 = xRight;

    y2 = 31;

    rect = refRect;

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, xRight, 0, xRight, 31);

    x1 = 0;

    y1 = yTop;

    x2 = 31;

    y2 = yTop;

    rect = refRect;

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, 0, yTop, 31, yTop);

    x1 = 0;

    y1 = yBottom;

    x2 = 31;

    y2 = yBottom;

    rect = refRect;

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, 0, yBottom, 31, yBottom);

    return TEST_COMPLETED;

}

/*!

 * \brief Tests SDL_IntersectRectAndLine() with empty rectangle

 *

 * \sa

 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine

 */

int

rect_testIntersectRectAndLineEmpty (void *arg)

{

    SDL_Rect refRect;

    SDL_Rect rect;

    int x1, y1, x1Ref, y1Ref;

    int x2, y2, x2Ref, y2Ref;

    SDL_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_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, x2Ref, y2Ref);

    return TEST_COMPLETED;

}

/*!

 * \brief Negative tests against SDL_IntersectRectAndLine() with invalid parameters

 *

 * \sa

 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine

 */

int

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;

    SDL_bool intersected;

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);

    SDLTest_AssertCheck(intersected == SDL_TRUE, "Check that intersection result was SDL_TRUE");

    intersected = SDL_IntersectRectAndLine((SDL_Rect *)NULL, &x1, &y1, &x2, &y2);

    SDLTest_AssertCheck(intersected == SDL_FALSE, "Check that function returns SDL_FALSE when 1st parameter is NULL");

    intersected = SDL_IntersectRectAndLine(&rect, (int *)NULL, &y1, &x2, &y2);

    SDLTest_AssertCheck(intersected == SDL_FALSE, "Check that function returns SDL_FALSE when 2nd parameter is NULL");

    intersected = SDL_IntersectRectAndLine(&rect, &x1, (int *)NULL, &x2, &y2);

    SDLTest_AssertCheck(intersected == SDL_FALSE, "Check that function returns SDL_FALSE when 3rd parameter is NULL");

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, (int *)NULL, &y2);

    SDLTest_AssertCheck(intersected == SDL_FALSE, "Check that function returns SDL_FALSE when 4th parameter is NULL");

    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, (int *)NULL);

    SDLTest_AssertCheck(intersected == SDL_FALSE, "Check that function returns SDL_FALSE when 5th parameter is NULL");

    intersected = SDL_IntersectRectAndLine((SDL_Rect *)NULL, (int *)NULL, (int *)NULL, (int *)NULL, (int *)NULL);

    SDLTest_AssertCheck(intersected == SDL_FALSE, "Check that function returns SDL_FALSE when all parameters are NULL");

    return TEST_COMPLETED;

}

/*!

 * \brief Private helper to check SDL_HasIntersection results

 */

void _validateHasIntersectionResults(

    SDL_bool intersection, SDL_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 == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",

        (intersection == SDL_TRUE) ? "SDL_TRUE" : "SDL_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);

}

/*!

 * \brief Private helper to check SDL_IntersectRect results

 */

void _validateIntersectRectResults(

    SDL_bool intersection, SDL_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);

    }

}

/*!

 * \brief Private helper to check SDL_UnionRect results

 */

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);

}

/*!

 * \brief Private helper to check SDL_RectEmpty results

 */

void _validateRectEmptyResults(

    SDL_bool empty, SDL_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 == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",

        (empty == SDL_TRUE) ? "SDL_TRUE" : "SDL_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);

}

/*!

 * \brief Private helper to check SDL_RectEquals results

 */

void _validateRectEqualsResults(

    SDL_bool equals, SDL_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 == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",

        (equals == SDL_TRUE) ? "SDL_TRUE" : "SDL_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);

}

/*!

 * \brief Tests SDL_IntersectRect() with B fully inside A

 *

 * \sa

 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect

 */

int rect_testIntersectRectInside (void *arg)

{

    SDL_Rect refRectA = { 0, 0, 32, 32 };

    SDL_Rect refRectB;

    SDL_Rect rectA;

    SDL_Rect rectB;

    SDL_Rect result;

    SDL_bool intersection;

    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_IntersectRect(&rectA, &rectB, &result);

    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &refRectB);

    return TEST_COMPLETED;

}

/*!

 * \brief Tests SDL_IntersectRect() with B fully outside A

 *

 * \sa

 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect

 */

int rect_testIntersectRectOutside (void *arg)

{

    SDL_Rect refRectA = { 0, 0, 32, 32 };

    SDL_Rect refRectB;

    SDL_Rect rectA;

    SDL_Rect rectB;

    SDL_Rect result;

    SDL_bool intersection;

    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_IntersectRect(&rectA, &rectB, &result);

    _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);

    return TEST_COMPLETED;

}

/*!

 * \brief Tests SDL_IntersectRect() with B partially intersecting A

 *

 * \sa

 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect

 */

int 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;

    SDL_bool intersection;

    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_IntersectRect(&rectA, &rectB, &result);

    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);

    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_IntersectRect(&rectA, &rectB, &result);

    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);

    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;