/** * Original code: automated SDL rect test written by Edgar Simo "bobbens" * New/updated tests: aschiffler at ferzkopp dot net */ #include #include /* ================= 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/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/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/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/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/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 Private helper to check SDL_FRectEquals results */ void _validateFRectEqualsResults( SDL_bool equals, SDL_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 == 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); 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); } /* ! * \brief Tests SDL_IntersectRect() with B fully inside A * * \sa * http://wiki.libsdl.org/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; /* 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_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/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; /* 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_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/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; /* 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_IntersectRect(&rectA, &rectB, &result); _validateIntersectRectResults(intersection, SDL_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_IntersectRect(&rectA, &rectB, &result); _validateIntersectRectResults(intersection, SDL_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_IntersectRect(&rectA, &rectB, &result); _validateIntersectRectResults(intersection, SDL_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_IntersectRect(&rectA, &rectB, &result); _validateIntersectRectResults(intersection, SDL_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_IntersectRect(&rectA, &rectB, &result); _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult); return TEST_COMPLETED; } /* ! * \brief Tests SDL_IntersectRect() with 1x1 pixel sized rectangles * * \sa * http://wiki.libsdl.org/SDL_IntersectRect */ int 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; SDL_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_IntersectRect(&rectA, &rectB, &result); _validateIntersectRectResults(intersection, SDL_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_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 empty rectangles * * \sa * http://wiki.libsdl.org/SDL_IntersectRect */ int rect_testIntersectRectEmpty (void *arg) { SDL_Rect refRectA; SDL_Rect refRectB; SDL_Rect rectA; SDL_Rect rectB; SDL_Rect result; SDL_bool intersection; SDL_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_IntersectRect(&rectA, &rectB, &result); _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL); empty = (SDL_bool)SDL_RectEmpty(&result); SDLTest_AssertCheck(empty == SDL_TRUE, "Validate result is empty Rect; got: %s", (empty == SDL_TRUE) ? "SDL_TRUE" : "SDL_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_IntersectRect(&rectA, &rectB, &result); _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL); empty = (SDL_bool)SDL_RectEmpty(&result); SDLTest_AssertCheck(empty == SDL_TRUE, "Validate result is empty Rect; got: %s", (empty == SDL_TRUE) ? "SDL_TRUE" : "SDL_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_IntersectRect(&rectA, &rectB, &result); _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL); empty = (SDL_bool)SDL_RectEmpty(&result); SDLTest_AssertCheck(empty == SDL_TRUE, "Validate result is empty Rect; got: %s", (empty == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE"); return TEST_COMPLETED; } /* ! * \brief Negative tests against SDL_IntersectRect() with invalid parameters * * \sa * http://wiki.libsdl.org/SDL_IntersectRect */ int rect_testIntersectRectParam(void *arg) { SDL_Rect rectA; SDL_Rect rectB = {0}; SDL_Rect result; SDL_bool intersection; /* invalid parameter combinations */ intersection = SDL_IntersectRect((SDL_Rect *)NULL, &rectB, &result); SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 1st parameter is NULL"); intersection = SDL_IntersectRect(&rectA, (SDL_Rect *)NULL, &result); SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 2st parameter is NULL"); intersection = SDL_IntersectRect(&rectA, &rectB, (SDL_Rect *)NULL); SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 3st parameter is NULL"); intersection = SDL_IntersectRect((SDL_Rect *)NULL, (SDL_Rect *)NULL, &result); SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 1st and 2nd parameters are NULL"); intersection = SDL_IntersectRect((SDL_Rect *)NULL, &rectB, (SDL_Rect *)NULL); SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 1st and 3rd parameters are NULL "); intersection = SDL_IntersectRect((SDL_Rect *)NULL, (SDL_Rect *)NULL, (SDL_Rect *)NULL); SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when all parameters are NULL"); return TEST_COMPLETED; } /* ! * \brief Tests SDL_HasIntersection() with B fully inside A * * \sa * http://wiki.libsdl.org/SDL_HasIntersection */ int rect_testHasIntersectionInside (void *arg) { SDL_Rect refRectA = { 0, 0, 32, 32 }; SDL_Rect refRectB; SDL_Rect rectA; SDL_Rect rectB; SDL_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_HasIntersection(&rectA, &rectB); _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB); return TEST_COMPLETED; } /* ! * \brief Tests SDL_HasIntersection() with B fully outside A * * \sa * http://wiki.libsdl.org/SDL_HasIntersection */ int rect_testHasIntersectionOutside (void *arg) { SDL_Rect refRectA = { 0, 0, 32, 32 }; SDL_Rect refRectB; SDL_Rect rectA; SDL_Rect rectB; SDL_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_HasIntersection(&rectA, &rectB); _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB); return TEST_COMPLETED; } /* ! * \brief Tests SDL_HasIntersection() with B partially intersecting A * * \sa * http://wiki.libsdl.org/SDL_HasIntersection */ int rect_testHasIntersectionPartial (void *arg) { SDL_Rect refRectA = { 0, 0, 32, 32 }; SDL_Rect refRectB; SDL_Rect rectA; SDL_Rect rectB; SDL_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_HasIntersection(&rectA, &rectB); _validateHasIntersectionResults(intersection, SDL_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_HasIntersection(&rectA, &rectB); _validateHasIntersectionResults(intersection, SDL_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_HasIntersection(&rectA, &rectB); _validateHasIntersectionResults(intersection, SDL_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_HasIntersection(&rectA, &rectB); _validateHasIntersectionResults(intersection, SDL_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_HasIntersection(&rectA, &rectB); _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB); return TEST_COMPLETED; } /* ! * \brief Tests SDL_HasIntersection() with 1x1 pixel sized rectangles * * \sa * http://wiki.libsdl.org/SDL_HasIntersection */ int rect_testHasIntersectionPoint (void *arg) { SDL_Rect refRectA = { 0, 0, 1, 1 }; SDL_Rect refRectB = { 0, 0, 1, 1 }; SDL_Rect rectA; SDL_Rect rectB; SDL_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_HasIntersection(&rectA, &rectB); _validateHasIntersectionResults(intersection, SDL_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_HasIntersection(&rectA, &rectB); _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB); } } } return TEST_COMPLETED; } /* ! * \brief Tests SDL_HasIntersection() with empty rectangles * * \sa * http://wiki.libsdl.org/SDL_HasIntersection */ int rect_testHasIntersectionEmpty (void *arg) { SDL_Rect refRectA; SDL_Rect refRectB; SDL_Rect rectA; SDL_Rect rectB; SDL_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_HasIntersection(&rectA, &rectB); _validateHasIntersectionResults(intersection, SDL_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_HasIntersection(&rectA, &rectB); _validateHasIntersectionResults(intersection, SDL_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_HasIntersection(&rectA, &rectB); _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB); return TEST_COMPLETED; } /* ! * \brief Negative tests against SDL_HasIntersection() with invalid parameters * * \sa * http://wiki.libsdl.org/SDL_HasIntersection */ int rect_testHasIntersectionParam(void *arg) { SDL_Rect rectA; SDL_Rect rectB = {0}; SDL_bool intersection; /* invalid parameter combinations */ intersection = SDL_HasIntersection((SDL_Rect *)NULL, &rectB); SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 1st parameter is NULL"); intersection = SDL_HasIntersection(&rectA, (SDL_Rect *)NULL); SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 2st parameter is NULL"); intersection = SDL_HasIntersection((SDL_Rect *)NULL, (SDL_Rect *)NULL); SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when all parameters are NULL"); return TEST_COMPLETED; } /* ! * \brief Test SDL_EnclosePoints() without clipping * * \sa * http://wiki.libsdl.org/SDL_EnclosePoints */ int rect_testEnclosePoints(void *arg) { const int numPoints = 16; SDL_Point refPoints[16]; SDL_Point points[16]; SDL_Rect result; SDL_bool anyEnclosed; SDL_bool anyEnclosedNoResult; SDL_bool expectedEnclosed = SDL_TRUE; int newx, newy; int minx = 0, maxx = 0, miny = 0, maxy = 0; int i; /* Create input data, tracking result */ for (i=0; i maxx) { maxx = newx; } if (newy < miny) { miny = newy; } if (newy > maxy) { maxy = newy; } } } /* Call function and validate - special case: no result requested */ anyEnclosedNoResult = SDL_EnclosePoints((const SDL_Point *)points, numPoints, (const SDL_Rect *)NULL, (SDL_Rect *)NULL); SDLTest_AssertCheck(expectedEnclosed==anyEnclosedNoResult, "Check expected return value %s, got %s", (expectedEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE", (anyEnclosedNoResult==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE"); for (i=0; i maxx) { maxx = newx; } if (newy < miny) { miny = newy; } if (newy > maxy) { maxy = newy; } } } /* Call function and validate - special case: no result requested */ anyEnclosedNoResult = SDL_EnclosePoints((const SDL_Point *)points, numPoints, (const SDL_Rect *)NULL, (SDL_Rect *)NULL); SDLTest_AssertCheck(expectedEnclosed==anyEnclosedNoResult, "Check return value %s, got %s", (expectedEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE", (anyEnclosedNoResult==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE"); for (i=0; i=refClip.x) && (newx<(refClip.x + refClip.w)) && (newy>=refClip.y) && (newy<(refClip.y + refClip.h))) { if (expectedEnclosed==SDL_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 = SDL_TRUE; } } /* Call function and validate - special case: no result requested */ clip = refClip; anyEnclosedNoResult = SDL_EnclosePoints((const SDL_Point *)points, numPoints, (const SDL_Rect *)&clip, (SDL_Rect *)NULL); SDLTest_AssertCheck(expectedEnclosed==anyEnclosedNoResult, "Expected return value %s, got %s", (expectedEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE", (anyEnclosedNoResult==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE"); for (i=0; irefRectB.x) ? refRectA.x : refRectB.x; miny = (refRectA.yrefRectB.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_UnionRect(&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_UnionRect(&rectA, &rectB, &result); _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult); } } } return TEST_COMPLETED; } /* ! * \brief Tests SDL_UnionRect() where rect A or rect B are empty * * \sa * http://wiki.libsdl.org/SDL_UnionRect */ int 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_UnionRect(&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_UnionRect(&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_UnionRect(&rectA, &rectB, &result); _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult); return TEST_COMPLETED; } /* ! * \brief Tests SDL_UnionRect() where rect B is inside rect A * * \sa * http://wiki.libsdl.org/SDL_UnionRect */ int 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_UnionRect(&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_UnionRect(&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_UnionRect(&rectA, &rectB, &result); _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult); } } } return TEST_COMPLETED; } /* ! * \brief Negative tests against SDL_UnionRect() with invalid parameters * * \sa * http://wiki.libsdl.org/SDL_UnionRect */ int rect_testUnionRectParam(void *arg) { SDL_Rect rectA, rectB = { 0 }; SDL_Rect result; /* invalid parameter combinations */ SDL_UnionRect((SDL_Rect *)NULL, &rectB, &result); SDLTest_AssertPass("Check that function returns when 1st parameter is NULL"); SDL_UnionRect(&rectA, (SDL_Rect *)NULL, &result); SDLTest_AssertPass("Check that function returns when 2nd parameter is NULL"); SDL_UnionRect(&rectA, &rectB, (SDL_Rect *)NULL); SDLTest_AssertPass("Check that function returns when 3rd parameter is NULL"); SDL_UnionRect((SDL_Rect *)NULL, &rectB, (SDL_Rect *)NULL); SDLTest_AssertPass("Check that function returns when 1st and 3rd parameter are NULL"); SDL_UnionRect(&rectA, (SDL_Rect *)NULL, (SDL_Rect *)NULL); SDLTest_AssertPass("Check that function returns when 2nd and 3rd parameter are NULL"); SDL_UnionRect((SDL_Rect *)NULL, (SDL_Rect *)NULL, (SDL_Rect *)NULL); SDLTest_AssertPass("Check that function returns when all parameters are NULL"); return TEST_COMPLETED; } /* ! * \brief Tests SDL_RectEmpty() with various inputs * * \sa * http://wiki.libsdl.org/SDL_RectEmpty */ int rect_testRectEmpty(void *arg) { SDL_Rect refRect; SDL_Rect rect; SDL_bool expectedResult; SDL_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 = SDL_FALSE; rect = refRect; result = (SDL_bool)SDL_RectEmpty((const SDL_Rect *)&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 = SDL_TRUE; rect = refRect; result = (SDL_bool)SDL_RectEmpty((const SDL_Rect *)&rect); _validateRectEmptyResults(result, expectedResult, &rect, &refRect); } } } return TEST_COMPLETED; } /* ! * \brief Negative tests against SDL_RectEmpty() with invalid parameters * * \sa * http://wiki.libsdl.org/SDL_RectEmpty */ int rect_testRectEmptyParam(void *arg) { SDL_bool result; /* invalid parameter combinations */ result = (SDL_bool)SDL_RectEmpty((const SDL_Rect *)NULL); SDLTest_AssertCheck(result == SDL_TRUE, "Check that function returns TRUE when 1st parameter is NULL"); return TEST_COMPLETED; } /* ! * \brief Tests SDL_RectEquals() with various inputs * * \sa * http://wiki.libsdl.org/SDL_RectEquals */ int rect_testRectEquals(void *arg) { SDL_Rect refRectA; SDL_Rect refRectB; SDL_Rect rectA; SDL_Rect rectB; SDL_bool expectedResult; SDL_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 = SDL_TRUE; rectA = refRectA; rectB = refRectB; result = (SDL_bool)SDL_RectEquals((const SDL_Rect *)&rectA, (const SDL_Rect *)&rectB); _validateRectEqualsResults(result, expectedResult, &rectA, &rectB, &refRectA, &refRectB); return TEST_COMPLETED; } /* ! * \brief Negative tests against SDL_RectEquals() with invalid parameters * * \sa * http://wiki.libsdl.org/SDL_RectEquals */ int rect_testRectEqualsParam(void *arg) { SDL_Rect rectA; SDL_Rect rectB; SDL_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_bool)SDL_RectEquals((const SDL_Rect *)NULL, (const SDL_Rect *)&rectB); SDLTest_AssertCheck(result == SDL_FALSE, "Check that function returns SDL_FALSE when 1st parameter is NULL"); result = (SDL_bool)SDL_RectEquals((const SDL_Rect *)&rectA, (const SDL_Rect *)NULL); SDLTest_AssertCheck(result == SDL_FALSE, "Check that function returns SDL_FALSE when 2nd parameter is NULL"); result = (SDL_bool)SDL_RectEquals((const SDL_Rect *)NULL, (const SDL_Rect *)NULL); SDLTest_AssertCheck(result == SDL_FALSE, "Check that function returns SDL_FALSE when 1st and 2nd parameter are NULL"); return TEST_COMPLETED; } /* ! * \brief Tests SDL_FRectEquals() with various inputs * * \sa * http://wiki.libsdl.org/SDL_FRectEquals */ int rect_testFRectEquals(void *arg) { SDL_FRect refRectA; SDL_FRect refRectB; SDL_FRect rectA; SDL_FRect rectB; SDL_bool expectedResult; SDL_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 = SDL_TRUE; rectA = refRectA; rectB = refRectB; result = (SDL_bool)SDL_FRectEquals((const SDL_FRect *)&rectA, (const SDL_FRect *)&rectB); _validateFRectEqualsResults(result, expectedResult, &rectA, &rectB, &refRectA, &refRectB); return TEST_COMPLETED; } /* ! * \brief Negative tests against SDL_FRectEquals() with invalid parameters * * \sa * http://wiki.libsdl.org/SDL_FRectEquals */ int rect_testFRectEqualsParam(void *arg) { SDL_FRect rectA; SDL_FRect rectB; SDL_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_bool)SDL_FRectEquals((const SDL_FRect *)NULL, (const SDL_FRect *)&rectB); SDLTest_AssertCheck(result == SDL_FALSE, "Check that function returns SDL_FALSE when 1st parameter is NULL"); result = (SDL_bool)SDL_FRectEquals((const SDL_FRect *)&rectA, (const SDL_FRect *)NULL); SDLTest_AssertCheck(result == SDL_FALSE, "Check that function returns SDL_FALSE when 2nd parameter is NULL"); result = (SDL_bool)SDL_FRectEquals((const SDL_FRect *)NULL, (const SDL_FRect *)NULL); SDLTest_AssertCheck(result == SDL_FALSE, "Check that function returns SDL_FALSE when 1st and 2nd parameter are NULL"); return TEST_COMPLETED; } /* ================= Test References ================== */ /* Rect test cases */ /* SDL_IntersectRectAndLine */ static const SDLTest_TestCaseReference rectTest1 = { (SDLTest_TestCaseFp)rect_testIntersectRectAndLine,"rect_testIntersectRectAndLine", "Tests SDL_IntersectRectAndLine clipping cases", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest2 = { (SDLTest_TestCaseFp)rect_testIntersectRectAndLineInside, "rect_testIntersectRectAndLineInside", "Tests SDL_IntersectRectAndLine with line fully contained in rect", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest3 = { (SDLTest_TestCaseFp)rect_testIntersectRectAndLineOutside, "rect_testIntersectRectAndLineOutside", "Tests SDL_IntersectRectAndLine with line fully outside of rect", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest4 = { (SDLTest_TestCaseFp)rect_testIntersectRectAndLineEmpty, "rect_testIntersectRectAndLineEmpty", "Tests SDL_IntersectRectAndLine with empty rectangle ", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest5 = { (SDLTest_TestCaseFp)rect_testIntersectRectAndLineParam, "rect_testIntersectRectAndLineParam", "Negative tests against SDL_IntersectRectAndLine with invalid parameters", TEST_ENABLED }; /* SDL_IntersectRect */ static const SDLTest_TestCaseReference rectTest6 = { (SDLTest_TestCaseFp)rect_testIntersectRectInside, "rect_testIntersectRectInside", "Tests SDL_IntersectRect with B fully contained in A", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest7 = { (SDLTest_TestCaseFp)rect_testIntersectRectOutside, "rect_testIntersectRectOutside", "Tests SDL_IntersectRect with B fully outside of A", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest8 = { (SDLTest_TestCaseFp)rect_testIntersectRectPartial, "rect_testIntersectRectPartial", "Tests SDL_IntersectRect with B partially intersecting A", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest9 = { (SDLTest_TestCaseFp)rect_testIntersectRectPoint, "rect_testIntersectRectPoint", "Tests SDL_IntersectRect with 1x1 sized rectangles", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest10 = { (SDLTest_TestCaseFp)rect_testIntersectRectEmpty, "rect_testIntersectRectEmpty", "Tests SDL_IntersectRect with empty rectangles", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest11 = { (SDLTest_TestCaseFp)rect_testIntersectRectParam, "rect_testIntersectRectParam", "Negative tests against SDL_IntersectRect with invalid parameters", TEST_ENABLED }; /* SDL_HasIntersection */ static const SDLTest_TestCaseReference rectTest12 = { (SDLTest_TestCaseFp)rect_testHasIntersectionInside, "rect_testHasIntersectionInside", "Tests SDL_HasIntersection with B fully contained in A", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest13 = { (SDLTest_TestCaseFp)rect_testHasIntersectionOutside, "rect_testHasIntersectionOutside", "Tests SDL_HasIntersection with B fully outside of A", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest14 = { (SDLTest_TestCaseFp)rect_testHasIntersectionPartial,"rect_testHasIntersectionPartial", "Tests SDL_HasIntersection with B partially intersecting A", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest15 = { (SDLTest_TestCaseFp)rect_testHasIntersectionPoint, "rect_testHasIntersectionPoint", "Tests SDL_HasIntersection with 1x1 sized rectangles", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest16 = { (SDLTest_TestCaseFp)rect_testHasIntersectionEmpty, "rect_testHasIntersectionEmpty", "Tests SDL_HasIntersection with empty rectangles", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest17 = { (SDLTest_TestCaseFp)rect_testHasIntersectionParam, "rect_testHasIntersectionParam", "Negative tests against SDL_HasIntersection with invalid parameters", TEST_ENABLED }; /* SDL_EnclosePoints */ static const SDLTest_TestCaseReference rectTest18 = { (SDLTest_TestCaseFp)rect_testEnclosePoints, "rect_testEnclosePoints", "Tests SDL_EnclosePoints without clipping", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest19 = { (SDLTest_TestCaseFp)rect_testEnclosePointsWithClipping, "rect_testEnclosePointsWithClipping", "Tests SDL_EnclosePoints with clipping", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest20 = { (SDLTest_TestCaseFp)rect_testEnclosePointsRepeatedInput, "rect_testEnclosePointsRepeatedInput", "Tests SDL_EnclosePoints with repeated input", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest21 = { (SDLTest_TestCaseFp)rect_testEnclosePointsParam, "rect_testEnclosePointsParam", "Negative tests against SDL_EnclosePoints with invalid parameters", TEST_ENABLED }; /* SDL_UnionRect */ static const SDLTest_TestCaseReference rectTest22 = { (SDLTest_TestCaseFp)rect_testUnionRectInside, "rect_testUnionRectInside", "Tests SDL_UnionRect where rect B is inside rect A", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest23 = { (SDLTest_TestCaseFp)rect_testUnionRectOutside, "rect_testUnionRectOutside", "Tests SDL_UnionRect where rect B is outside rect A", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest24 = { (SDLTest_TestCaseFp)rect_testUnionRectEmpty, "rect_testUnionRectEmpty", "Tests SDL_UnionRect where rect A or rect B are empty", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest25 = { (SDLTest_TestCaseFp)rect_testUnionRectParam, "rect_testUnionRectParam", "Negative tests against SDL_UnionRect with invalid parameters", TEST_ENABLED }; /* SDL_RectEmpty */ static const SDLTest_TestCaseReference rectTest26 = { (SDLTest_TestCaseFp)rect_testRectEmpty, "rect_testRectEmpty", "Tests SDL_RectEmpty with various inputs", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest27 = { (SDLTest_TestCaseFp)rect_testRectEmptyParam, "rect_testRectEmptyParam", "Negative tests against SDL_RectEmpty with invalid parameters", TEST_ENABLED }; /* SDL_RectEquals */ static const SDLTest_TestCaseReference rectTest28 = { (SDLTest_TestCaseFp)rect_testRectEquals, "rect_testRectEquals", "Tests SDL_RectEquals with various inputs", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest29 = { (SDLTest_TestCaseFp)rect_testRectEqualsParam, "rect_testRectEqualsParam", "Negative tests against SDL_RectEquals with invalid parameters", TEST_ENABLED }; /* SDL_FRectEquals */ static const SDLTest_TestCaseReference rectTest30 = { (SDLTest_TestCaseFp)rect_testFRectEquals, "rect_testFRectEquals", "Tests SDL_FRectEquals with various inputs", TEST_ENABLED }; static const SDLTest_TestCaseReference rectTest31 = { (SDLTest_TestCaseFp)rect_testFRectEqualsParam, "rect_testFRectEqualsParam", "Negative tests against SDL_FRectEquals with invalid parameters", TEST_ENABLED }; /* ! * \brief Sequence of Rect test cases; functions that handle simple rectangles including overlaps and merges. * * \sa * http://wiki.libsdl.org/CategoryRect */ static const SDLTest_TestCaseReference *rectTests[] = { &rectTest1, &rectTest2, &rectTest3, &rectTest4, &rectTest5, &rectTest6, &rectTest7, &rectTest8, &rectTest9, &rectTest10, &rectTest11, &rectTest12, &rectTest13, &rectTest14, &rectTest15, &rectTest16, &rectTest17, &rectTest18, &rectTest19, &rectTest20, &rectTest21, &rectTest22, &rectTest23, &rectTest24, &rectTest25, &rectTest26, &rectTest27, &rectTest28, &rectTest29, &rectTest30, &rectTest31, NULL }; /* Rect test suite (global) */ SDLTest_TestSuiteReference rectTestSuite = { "Rect", NULL, rectTests, NULL }; /* vi: set ts=4 sw=4 expandtab: */