test/testautomation_rect.c
author Andreas Schiffler <aschiffler@ferzkopp.net>
Mon, 24 Dec 2012 14:43:57 -0800
changeset 6772 5229a117ef97
parent 6769 b49778d885cd
child 7074 0545811b3543
permissions -rw-r--r--
Added audio test suite; minor code cleanups in test lib
aschiffler@6757
     1
/**
aschiffler@6757
     2
 * Original code: automated SDL rect test written by Edgar Simo "bobbens"
aschiffler@6757
     3
 * New/updated tests: aschiffler at ferzkopp dot net
aschiffler@6757
     4
 */
aschiffler@6757
     5
aschiffler@6757
     6
#include <stdio.h>
aschiffler@6757
     7
aschiffler@6757
     8
#include "SDL.h"
aschiffler@6757
     9
#include "SDL_test.h"
aschiffler@6757
    10
aschiffler@6757
    11
/* ================= Test Case Implementation ================== */
aschiffler@6757
    12
aschiffler@6757
    13
/* Helper functions */
aschiffler@6757
    14
aschiffler@6757
    15
/*!
aschiffler@6757
    16
 * \brief Private helper to check SDL_IntersectRectAndLine results
aschiffler@6757
    17
 */
aschiffler@6757
    18
void _validateIntersectRectAndLineResults(
aschiffler@6757
    19
    SDL_bool intersection, SDL_bool expectedIntersection,
aschiffler@6757
    20
    SDL_Rect *rect, SDL_Rect * refRect,
aschiffler@6757
    21
    int x1, int y1, int x2, int y2,
aschiffler@6757
    22
    int x1Ref, int y1Ref, int x2Ref, int y2Ref)
aschiffler@6757
    23
{
aschiffler@6757
    24
    SDLTest_AssertCheck(intersection == expectedIntersection, 
aschiffler@6757
    25
        "Check for correct intersection result: expected %s, got %s intersecting rect (%d,%d,%d,%d) with line (%d,%d - %d,%d)",
aschiffler@6757
    26
        (expectedIntersection == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",
aschiffler@6757
    27
        (intersection == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",
aschiffler@6757
    28
        refRect->x, refRect->y, refRect->w, refRect->h,
aschiffler@6757
    29
        x1Ref, y1Ref, x2Ref, y2Ref);
aschiffler@6757
    30
    SDLTest_AssertCheck(rect->x == refRect->x && rect->y == refRect->y && rect->w == refRect->w && rect->h == refRect->h,
aschiffler@6757
    31
        "Check that source rectangle was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
aschiffler@6757
    32
        rect->x, rect->y, rect->w, rect->h,
aschiffler@6757
    33
        refRect->x, refRect->y, refRect->w, refRect->h);
aschiffler@6757
    34
    SDLTest_AssertCheck(x1 == x1Ref && y1 == y1Ref && x2 == x2Ref && y2 == y2Ref,
aschiffler@6757
    35
        "Check if line was incorrectly clipped or modified: got (%d,%d - %d,%d) expected (%d,%d - %d,%d)",
aschiffler@6757
    36
        x1, y1, x2, y2,
aschiffler@6757
    37
        x1Ref, y1Ref, x2Ref, y2Ref);
aschiffler@6757
    38
}
aschiffler@6757
    39
aschiffler@6757
    40
/* Test case functions */
aschiffler@6757
    41
aschiffler@6757
    42
/*!
aschiffler@6757
    43
 * \brief Tests SDL_IntersectRectAndLine() clipping cases
aschiffler@6757
    44
 *
aschiffler@6757
    45
 * \sa
aschiffler@6757
    46
 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine
aschiffler@6757
    47
 */
aschiffler@6757
    48
int 
aschiffler@6757
    49
rect_testIntersectRectAndLine (void *arg)
aschiffler@6757
    50
{
aschiffler@6757
    51
    SDL_Rect refRect = { 0, 0, 32, 32 };
aschiffler@6757
    52
    SDL_Rect rect;
aschiffler@6757
    53
    int x1, y1;
aschiffler@6757
    54
    int x2, y2;
aschiffler@6757
    55
    SDL_bool intersected;
aschiffler@6757
    56
aschiffler@6757
    57
    int xLeft = -SDLTest_RandomIntegerInRange(1, refRect.w);
aschiffler@6757
    58
    int xRight = refRect.w + SDLTest_RandomIntegerInRange(1, refRect.w);
aschiffler@6757
    59
    int yTop = -SDLTest_RandomIntegerInRange(1, refRect.h);
aschiffler@6757
    60
    int yBottom = refRect.h + SDLTest_RandomIntegerInRange(1, refRect.h);
aschiffler@6757
    61
aschiffler@6757
    62
    x1 = xLeft;
aschiffler@6757
    63
    y1 = 15;
aschiffler@6757
    64
    x2 = xRight;
aschiffler@6757
    65
    y2 = 15;
aschiffler@6757
    66
    rect = refRect;
aschiffler@6757
    67
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
    68
    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 0, 15, 31, 15);
aschiffler@6757
    69
aschiffler@6757
    70
    x1 = 15;
aschiffler@6757
    71
    y1 = yTop;
aschiffler@6757
    72
    x2 = 15;
aschiffler@6757
    73
    y2 = yBottom;
aschiffler@6757
    74
    rect = refRect;
aschiffler@6757
    75
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
    76
    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 15, 0, 15, 31);
aschiffler@6757
    77
aschiffler@6757
    78
    x1 = -refRect.w;
aschiffler@6757
    79
    y1 = -refRect.h;
aschiffler@6757
    80
    x2 = 2*refRect.w;
aschiffler@6757
    81
    y2 = 2*refRect.h;
aschiffler@6757
    82
    rect = refRect;
aschiffler@6757
    83
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
    84
     _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 0, 0, 31, 31);
aschiffler@6757
    85
aschiffler@6757
    86
    x1 = 2*refRect.w;
aschiffler@6757
    87
    y1 = 2*refRect.h;
aschiffler@6757
    88
    x2 = -refRect.w;
aschiffler@6757
    89
    y2 = -refRect.h;
aschiffler@6757
    90
    rect = refRect;
aschiffler@6757
    91
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
    92
    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 31, 31, 0, 0);
aschiffler@6757
    93
aschiffler@6757
    94
    x1 = -1;
aschiffler@6757
    95
    y1 = 32;
aschiffler@6757
    96
    x2 = 32;
aschiffler@6757
    97
    y2 = -1;
aschiffler@6757
    98
    rect = refRect;
aschiffler@6757
    99
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   100
    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 0, 31, 31, 0);
aschiffler@6757
   101
aschiffler@6757
   102
    x1 = 32;
aschiffler@6757
   103
    y1 = -1;
aschiffler@6757
   104
    x2 = -1;
aschiffler@6757
   105
    y2 = 32;
aschiffler@6757
   106
    rect = refRect;
aschiffler@6757
   107
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   108
    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 31, 0, 0, 31);
aschiffler@6757
   109
aschiffler@6757
   110
	return TEST_COMPLETED;
aschiffler@6757
   111
}
aschiffler@6757
   112
aschiffler@6757
   113
/*!
aschiffler@6757
   114
 * \brief Tests SDL_IntersectRectAndLine() non-clipping case line inside
aschiffler@6757
   115
 *
aschiffler@6757
   116
 * \sa
aschiffler@6757
   117
 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine
aschiffler@6757
   118
 */
aschiffler@6757
   119
int 
aschiffler@6757
   120
rect_testIntersectRectAndLineInside (void *arg)
aschiffler@6757
   121
{
aschiffler@6757
   122
    SDL_Rect refRect = { 0, 0, 32, 32 };
aschiffler@6757
   123
    SDL_Rect rect;
aschiffler@6757
   124
    int x1, y1;
aschiffler@6757
   125
    int x2, y2;
aschiffler@6757
   126
    SDL_bool intersected;
aschiffler@6757
   127
aschiffler@6757
   128
    int xmin = refRect.x;
aschiffler@6757
   129
    int xmax = refRect.x + refRect.w - 1;
aschiffler@6757
   130
    int ymin = refRect.y;
aschiffler@6757
   131
    int ymax = refRect.y + refRect.h - 1;
aschiffler@6757
   132
    int x1Ref = SDLTest_RandomIntegerInRange(xmin + 1, xmax - 1);
aschiffler@6757
   133
    int y1Ref = SDLTest_RandomIntegerInRange(ymin + 1, ymax - 1);
aschiffler@6757
   134
    int x2Ref = SDLTest_RandomIntegerInRange(xmin + 1, xmax - 1);
aschiffler@6757
   135
    int y2Ref = SDLTest_RandomIntegerInRange(ymin + 1, ymax - 1);
aschiffler@6757
   136
aschiffler@6757
   137
    x1 = x1Ref;
aschiffler@6757
   138
    y1 = y1Ref;
aschiffler@6757
   139
    x2 = x2Ref;
aschiffler@6757
   140
    y2 = y2Ref;
aschiffler@6757
   141
    rect = refRect;
aschiffler@6757
   142
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   143
    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, x2Ref, y2Ref);
aschiffler@6757
   144
aschiffler@6757
   145
    x1 = x1Ref;
aschiffler@6757
   146
    y1 = y1Ref;
aschiffler@6757
   147
    x2 = xmax;
aschiffler@6757
   148
    y2 = ymax;
aschiffler@6757
   149
    rect = refRect;
aschiffler@6757
   150
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   151
    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, xmax, ymax);
aschiffler@6757
   152
aschiffler@6757
   153
    x1 = xmin;
aschiffler@6757
   154
    y1 = ymin;
aschiffler@6757
   155
    x2 = x2Ref;
aschiffler@6757
   156
    y2 = y2Ref;
aschiffler@6757
   157
    rect = refRect;
aschiffler@6757
   158
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   159
    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, xmin, ymin, x2Ref, y2Ref);
aschiffler@6757
   160
aschiffler@6757
   161
    x1 = xmin;
aschiffler@6757
   162
    y1 = ymin;
aschiffler@6757
   163
    x2 = xmax;
aschiffler@6757
   164
    y2 = ymax;
aschiffler@6757
   165
    rect = refRect;
aschiffler@6757
   166
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   167
    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, xmin, ymin, xmax, ymax);
aschiffler@6757
   168
aschiffler@6757
   169
    x1 = xmin;
aschiffler@6757
   170
    y1 = ymax;
aschiffler@6757
   171
    x2 = xmax;
aschiffler@6757
   172
    y2 = ymin;
aschiffler@6757
   173
    rect = refRect;
aschiffler@6757
   174
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   175
    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, xmin, ymax, xmax, ymin);
aschiffler@6757
   176
aschiffler@6757
   177
	return TEST_COMPLETED;
aschiffler@6757
   178
}
aschiffler@6757
   179
aschiffler@6757
   180
/*!
aschiffler@6757
   181
 * \brief Tests SDL_IntersectRectAndLine() non-clipping cases outside
aschiffler@6757
   182
 *
aschiffler@6757
   183
 * \sa
aschiffler@6757
   184
 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine
aschiffler@6757
   185
 */
aschiffler@6757
   186
int 
aschiffler@6757
   187
rect_testIntersectRectAndLineOutside (void *arg)
aschiffler@6757
   188
{
aschiffler@6757
   189
    SDL_Rect refRect = { 0, 0, 32, 32 };
aschiffler@6757
   190
    SDL_Rect rect;
aschiffler@6757
   191
    int x1, y1;
aschiffler@6757
   192
    int x2, y2;
aschiffler@6757
   193
    SDL_bool intersected;
aschiffler@6757
   194
aschiffler@6757
   195
    int xLeft = -SDLTest_RandomIntegerInRange(1, refRect.w);
aschiffler@6757
   196
    int xRight = refRect.w + SDLTest_RandomIntegerInRange(1, refRect.w);
aschiffler@6757
   197
    int yTop = -SDLTest_RandomIntegerInRange(1, refRect.h);
aschiffler@6757
   198
    int yBottom = refRect.h + SDLTest_RandomIntegerInRange(1, refRect.h);
aschiffler@6757
   199
aschiffler@6757
   200
    x1 = xLeft;
aschiffler@6757
   201
    y1 = 0;
aschiffler@6757
   202
    x2 = xLeft;
aschiffler@6757
   203
    y2 = 31;
aschiffler@6757
   204
    rect = refRect;
aschiffler@6757
   205
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   206
    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, xLeft, 0, xLeft, 31);
aschiffler@6757
   207
aschiffler@6757
   208
    x1 = xRight;
aschiffler@6757
   209
    y1 = 0;
aschiffler@6757
   210
    x2 = xRight;
aschiffler@6757
   211
    y2 = 31;
aschiffler@6757
   212
    rect = refRect;
aschiffler@6757
   213
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   214
    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, xRight, 0, xRight, 31);
aschiffler@6757
   215
aschiffler@6757
   216
    x1 = 0;
aschiffler@6757
   217
    y1 = yTop;
aschiffler@6757
   218
    x2 = 31;
aschiffler@6757
   219
    y2 = yTop;
aschiffler@6757
   220
    rect = refRect;
aschiffler@6757
   221
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   222
    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, 0, yTop, 31, yTop);
aschiffler@6757
   223
aschiffler@6757
   224
    x1 = 0;
aschiffler@6757
   225
    y1 = yBottom;
aschiffler@6757
   226
    x2 = 31;
aschiffler@6757
   227
    y2 = yBottom;
aschiffler@6757
   228
    rect = refRect;
aschiffler@6757
   229
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   230
    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, 0, yBottom, 31, yBottom);
aschiffler@6757
   231
aschiffler@6757
   232
	return TEST_COMPLETED;
aschiffler@6757
   233
}
aschiffler@6757
   234
aschiffler@6757
   235
/*!
aschiffler@6757
   236
 * \brief Tests SDL_IntersectRectAndLine() with empty rectangle
aschiffler@6757
   237
 *
aschiffler@6757
   238
 * \sa
aschiffler@6757
   239
 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine
aschiffler@6757
   240
 */
aschiffler@6757
   241
int 
aschiffler@6757
   242
rect_testIntersectRectAndLineEmpty (void *arg)
aschiffler@6757
   243
{
aschiffler@6757
   244
    SDL_Rect refRect;
aschiffler@6757
   245
    SDL_Rect rect;
aschiffler@6757
   246
    int x1, y1, x1Ref, y1Ref;
aschiffler@6757
   247
    int x2, y2, x2Ref, y2Ref;
aschiffler@6757
   248
    SDL_bool intersected;
aschiffler@6757
   249
        
aschiffler@6757
   250
    refRect.x = SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
   251
    refRect.y = SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
   252
    refRect.w = 0;
aschiffler@6757
   253
    refRect.h = 0;
aschiffler@6757
   254
    x1Ref = refRect.x;
aschiffler@6757
   255
    y1Ref = refRect.y;
aschiffler@6757
   256
    x2Ref = SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
   257
    y2Ref = SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
   258
aschiffler@6757
   259
    x1 = x1Ref;
aschiffler@6757
   260
    y1 = y1Ref;
aschiffler@6757
   261
    x2 = x2Ref;
aschiffler@6757
   262
    y2 = y2Ref;
aschiffler@6757
   263
    rect = refRect;
aschiffler@6757
   264
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   265
    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, x2Ref, y2Ref);
aschiffler@6757
   266
aschiffler@6757
   267
	return TEST_COMPLETED;
aschiffler@6757
   268
}
aschiffler@6757
   269
aschiffler@6757
   270
/*!
aschiffler@6757
   271
 * \brief Negative tests against SDL_IntersectRectAndLine() with invalid parameters
aschiffler@6757
   272
 *
aschiffler@6757
   273
 * \sa
aschiffler@6757
   274
 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRectAndLine
aschiffler@6757
   275
 */
aschiffler@6757
   276
int 
aschiffler@6757
   277
rect_testIntersectRectAndLineParam (void *arg)
aschiffler@6757
   278
{
aschiffler@6757
   279
    SDL_Rect rect = { 0, 0, 32, 32 };
aschiffler@6757
   280
    int x1 = rect.w / 2;
aschiffler@6757
   281
    int y1 = rect.h / 2;
aschiffler@6757
   282
    int x2 = x1;
aschiffler@6757
   283
    int y2 = 2 * rect.h;
aschiffler@6757
   284
    SDL_bool intersected;
aschiffler@6757
   285
    
aschiffler@6757
   286
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, &y2);
aschiffler@6757
   287
    SDLTest_AssertCheck(intersected == SDL_TRUE, "Check that intersection result was SDL_TRUE");
aschiffler@6757
   288
    
aschiffler@6757
   289
    intersected = SDL_IntersectRectAndLine((SDL_Rect *)NULL, &x1, &y1, &x2, &y2);
aschiffler@6757
   290
    SDLTest_AssertCheck(intersected == SDL_FALSE, "Check that function returns SDL_FALSE when 1st parameter is NULL");
aschiffler@6757
   291
    intersected = SDL_IntersectRectAndLine(&rect, (int *)NULL, &y1, &x2, &y2);
aschiffler@6757
   292
    SDLTest_AssertCheck(intersected == SDL_FALSE, "Check that function returns SDL_FALSE when 2nd parameter is NULL");
aschiffler@6757
   293
    intersected = SDL_IntersectRectAndLine(&rect, &x1, (int *)NULL, &x2, &y2);
aschiffler@6757
   294
    SDLTest_AssertCheck(intersected == SDL_FALSE, "Check that function returns SDL_FALSE when 3rd parameter is NULL");
aschiffler@6757
   295
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, (int *)NULL, &y2);
aschiffler@6757
   296
    SDLTest_AssertCheck(intersected == SDL_FALSE, "Check that function returns SDL_FALSE when 4th parameter is NULL");
aschiffler@6757
   297
    intersected = SDL_IntersectRectAndLine(&rect, &x1, &y1, &x2, (int *)NULL);
aschiffler@6757
   298
    SDLTest_AssertCheck(intersected == SDL_FALSE, "Check that function returns SDL_FALSE when 5th parameter is NULL");
aschiffler@6757
   299
    intersected = SDL_IntersectRectAndLine((SDL_Rect *)NULL, (int *)NULL, (int *)NULL, (int *)NULL, (int *)NULL);
aschiffler@6757
   300
    SDLTest_AssertCheck(intersected == SDL_FALSE, "Check that function returns SDL_FALSE when all parameters are NULL");
aschiffler@6757
   301
aschiffler@6757
   302
	return TEST_COMPLETED;
aschiffler@6757
   303
}
aschiffler@6757
   304
aschiffler@6757
   305
/*!
aschiffler@6757
   306
 * \brief Private helper to check SDL_HasIntersection results
aschiffler@6757
   307
 */
aschiffler@6757
   308
void _validateHasIntersectionResults(
aschiffler@6757
   309
    SDL_bool intersection, SDL_bool expectedIntersection, 
aschiffler@6757
   310
    SDL_Rect *rectA, SDL_Rect *rectB, SDL_Rect *refRectA, SDL_Rect *refRectB)
aschiffler@6757
   311
{
aschiffler@6757
   312
    SDLTest_AssertCheck(intersection == expectedIntersection, 
aschiffler@6757
   313
        "Check intersection result: expected %s, got %s intersecting A (%d,%d,%d,%d) with B (%d,%d,%d,%d)",
aschiffler@6757
   314
        (expectedIntersection == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",
aschiffler@6757
   315
        (intersection == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",
aschiffler@6757
   316
        rectA->x, rectA->y, rectA->w, rectA->h, 
aschiffler@6757
   317
        rectB->x, rectB->y, rectB->w, rectB->h);
aschiffler@6757
   318
    SDLTest_AssertCheck(rectA->x == refRectA->x && rectA->y == refRectA->y && rectA->w == refRectA->w && rectA->h == refRectA->h,
aschiffler@6757
   319
        "Check that source rectangle A was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
aschiffler@6757
   320
        rectA->x, rectA->y, rectA->w, rectA->h,
aschiffler@6757
   321
        refRectA->x, refRectA->y, refRectA->w, refRectA->h);
aschiffler@6757
   322
    SDLTest_AssertCheck(rectB->x == refRectB->x && rectB->y == refRectB->y && rectB->w == refRectB->w && rectB->h == refRectB->h,
aschiffler@6757
   323
        "Check that source rectangle B was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
aschiffler@6757
   324
        rectB->x, rectB->y, rectB->w, rectB->h,
aschiffler@6757
   325
        refRectB->x, refRectB->y, refRectB->w, refRectB->h);
aschiffler@6757
   326
}
aschiffler@6757
   327
aschiffler@6757
   328
/*!
aschiffler@6757
   329
 * \brief Private helper to check SDL_IntersectRect results
aschiffler@6757
   330
 */
aschiffler@6757
   331
void _validateIntersectRectResults(
aschiffler@6757
   332
    SDL_bool intersection, SDL_bool expectedIntersection, 
aschiffler@6757
   333
    SDL_Rect *rectA, SDL_Rect *rectB, SDL_Rect *refRectA, SDL_Rect *refRectB, 
aschiffler@6757
   334
    SDL_Rect *result, SDL_Rect *expectedResult)
aschiffler@6757
   335
{
aschiffler@6757
   336
    _validateHasIntersectionResults(intersection, expectedIntersection, rectA, rectB, refRectA, refRectB);
aschiffler@6757
   337
    if (result && expectedResult) {
aschiffler@6757
   338
        SDLTest_AssertCheck(result->x == expectedResult->x && result->y == expectedResult->y && result->w == expectedResult->w && result->h == expectedResult->h,
aschiffler@6757
   339
            "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)",
aschiffler@6757
   340
            rectA->x, rectA->y, rectA->w, rectA->h, 
aschiffler@6757
   341
            rectB->x, rectB->y, rectB->w, rectB->h,
aschiffler@6757
   342
            result->x, result->y, result->w, result->h,
aschiffler@6757
   343
            expectedResult->x, expectedResult->y, expectedResult->w, expectedResult->h);
aschiffler@6757
   344
    }
aschiffler@6757
   345
}
aschiffler@6757
   346
aschiffler@6757
   347
/*!
aschiffler@6757
   348
 * \brief Private helper to check SDL_UnionRect results
aschiffler@6757
   349
 */
aschiffler@6757
   350
void _validateUnionRectResults(
aschiffler@6757
   351
    SDL_Rect *rectA, SDL_Rect *rectB, SDL_Rect *refRectA, SDL_Rect *refRectB, 
aschiffler@6757
   352
    SDL_Rect *result, SDL_Rect *expectedResult)
aschiffler@6757
   353
{
aschiffler@6757
   354
    SDLTest_AssertCheck(rectA->x == refRectA->x && rectA->y == refRectA->y && rectA->w == refRectA->w && rectA->h == refRectA->h,
aschiffler@6757
   355
        "Check that source rectangle A was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
aschiffler@6757
   356
        rectA->x, rectA->y, rectA->w, rectA->h,
aschiffler@6757
   357
        refRectA->x, refRectA->y, refRectA->w, refRectA->h);
aschiffler@6757
   358
    SDLTest_AssertCheck(rectB->x == refRectB->x && rectB->y == refRectB->y && rectB->w == refRectB->w && rectB->h == refRectB->h,
aschiffler@6757
   359
        "Check that source rectangle B was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
aschiffler@6757
   360
        rectB->x, rectB->y, rectB->w, rectB->h,
aschiffler@6757
   361
        refRectB->x, refRectB->y, refRectB->w, refRectB->h);
aschiffler@6757
   362
    SDLTest_AssertCheck(result->x == expectedResult->x && result->y == expectedResult->y && result->w == expectedResult->w && result->h == expectedResult->h,
aschiffler@6757
   363
        "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)",
aschiffler@6757
   364
        rectA->x, rectA->y, rectA->w, rectA->h, 
aschiffler@6757
   365
        rectB->x, rectB->y, rectB->w, rectB->h,
aschiffler@6757
   366
        result->x, result->y, result->w, result->h,
aschiffler@6757
   367
        expectedResult->x, expectedResult->y, expectedResult->w, expectedResult->h);
aschiffler@6757
   368
}
aschiffler@6757
   369
aschiffler@6757
   370
/*!
aschiffler@6757
   371
 * \brief Private helper to check SDL_RectEmpty results
aschiffler@6757
   372
 */
aschiffler@6757
   373
void _validateRectEmptyResults(
aschiffler@6757
   374
    SDL_bool empty, SDL_bool expectedEmpty, 
aschiffler@6757
   375
    SDL_Rect *rect, SDL_Rect *refRect)
aschiffler@6757
   376
{
aschiffler@6757
   377
    SDLTest_AssertCheck(empty == expectedEmpty, 
aschiffler@6757
   378
        "Check for correct empty result: expected %s, got %s testing (%d,%d,%d,%d)",
aschiffler@6757
   379
        (expectedEmpty == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",
aschiffler@6757
   380
        (empty == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",
aschiffler@6757
   381
        rect->x, rect->y, rect->w, rect->h);
aschiffler@6757
   382
    SDLTest_AssertCheck(rect->x == refRect->x && rect->y == refRect->y && rect->w == refRect->w && rect->h == refRect->h,
aschiffler@6757
   383
        "Check that source rectangle was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
aschiffler@6757
   384
        rect->x, rect->y, rect->w, rect->h,
aschiffler@6757
   385
        refRect->x, refRect->y, refRect->w, refRect->h);
aschiffler@6757
   386
}
aschiffler@6757
   387
aschiffler@6757
   388
/*!
aschiffler@6757
   389
 * \brief Private helper to check SDL_RectEquals results
aschiffler@6757
   390
 */
aschiffler@6757
   391
void _validateRectEqualsResults(
aschiffler@6757
   392
    SDL_bool equals, SDL_bool expectedEquals, 
aschiffler@6757
   393
    SDL_Rect *rectA, SDL_Rect *rectB, SDL_Rect *refRectA, SDL_Rect *refRectB)
aschiffler@6757
   394
{
aschiffler@6757
   395
    SDLTest_AssertCheck(equals == expectedEquals, 
aschiffler@6757
   396
        "Check for correct equals result: expected %s, got %s testing (%d,%d,%d,%d) and (%d,%d,%d,%d)",
aschiffler@6757
   397
        (expectedEquals == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",
aschiffler@6757
   398
        (equals == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE",
aschiffler@6757
   399
        rectA->x, rectA->y, rectA->w, rectA->h,
aschiffler@6757
   400
        rectB->x, rectB->y, rectB->w, rectB->h);
aschiffler@6757
   401
    SDLTest_AssertCheck(rectA->x == refRectA->x && rectA->y == refRectA->y && rectA->w == refRectA->w && rectA->h == refRectA->h,
aschiffler@6757
   402
        "Check that source rectangle A was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
aschiffler@6757
   403
        rectA->x, rectA->y, rectA->w, rectA->h,
aschiffler@6757
   404
        refRectA->x, refRectA->y, refRectA->w, refRectA->h);
aschiffler@6757
   405
    SDLTest_AssertCheck(rectB->x == refRectB->x && rectB->y == refRectB->y && rectB->w == refRectB->w && rectB->h == refRectB->h,
aschiffler@6757
   406
        "Check that source rectangle B was not modified: got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
aschiffler@6757
   407
        rectB->x, rectB->y, rectB->w, rectB->h,
aschiffler@6757
   408
        refRectB->x, refRectB->y, refRectB->w, refRectB->h);
aschiffler@6757
   409
}
aschiffler@6757
   410
aschiffler@6757
   411
/*!
aschiffler@6757
   412
 * \brief Tests SDL_IntersectRect() with B fully inside A
aschiffler@6757
   413
 *
aschiffler@6757
   414
 * \sa
aschiffler@6757
   415
 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect
aschiffler@6757
   416
 */
aschiffler@6757
   417
int rect_testIntersectRectInside (void *arg)
aschiffler@6757
   418
{
aschiffler@6757
   419
    SDL_Rect refRectA = { 0, 0, 32, 32 };
aschiffler@6757
   420
    SDL_Rect refRectB;
aschiffler@6757
   421
    SDL_Rect rectA;
aschiffler@6757
   422
    SDL_Rect rectB;
aschiffler@6757
   423
    SDL_Rect result;
aschiffler@6757
   424
    SDL_bool intersection;
aschiffler@6757
   425
aschiffler@6757
   426
    // rectB fully contained in rectA
aschiffler@6757
   427
    refRectB.x = 0;
aschiffler@6757
   428
    refRectB.y = 0;
aschiffler@6757
   429
    refRectB.w = SDLTest_RandomIntegerInRange(refRectA.x + 1, refRectA.x + refRectA.w - 1);
aschiffler@6757
   430
    refRectB.h = SDLTest_RandomIntegerInRange(refRectA.y + 1, refRectA.y + refRectA.h - 1);
aschiffler@6757
   431
    rectA = refRectA;
aschiffler@6757
   432
    rectB = refRectB;
aschiffler@6757
   433
    intersection = SDL_IntersectRect(&rectA, &rectB, &result);
aschiffler@6757
   434
    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &refRectB);
aschiffler@6757
   435
aschiffler@6757
   436
	return TEST_COMPLETED;
aschiffler@6757
   437
}
aschiffler@6757
   438
aschiffler@6757
   439
/*!
aschiffler@6757
   440
 * \brief Tests SDL_IntersectRect() with B fully outside A
aschiffler@6757
   441
 *
aschiffler@6757
   442
 * \sa
aschiffler@6757
   443
 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect
aschiffler@6757
   444
 */
aschiffler@6757
   445
int rect_testIntersectRectOutside (void *arg)
aschiffler@6757
   446
{
aschiffler@6757
   447
    SDL_Rect refRectA = { 0, 0, 32, 32 };
aschiffler@6757
   448
    SDL_Rect refRectB;
aschiffler@6757
   449
    SDL_Rect rectA;
aschiffler@6757
   450
    SDL_Rect rectB;
aschiffler@6757
   451
    SDL_Rect result;
aschiffler@6757
   452
    SDL_bool intersection;
aschiffler@6757
   453
aschiffler@6757
   454
    // rectB fully outside of rectA
aschiffler@6757
   455
    refRectB.x = refRectA.x + refRectA.w + SDLTest_RandomIntegerInRange(1, 10);
aschiffler@6757
   456
    refRectB.y = refRectA.y + refRectA.h + SDLTest_RandomIntegerInRange(1, 10);
aschiffler@6757
   457
    refRectB.w = refRectA.w;
aschiffler@6757
   458
    refRectB.h = refRectA.h;
aschiffler@6757
   459
    rectA = refRectA;
aschiffler@6757
   460
    rectB = refRectB;
aschiffler@6757
   461
    intersection = SDL_IntersectRect(&rectA, &rectB, &result);
aschiffler@6757
   462
    _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);    
aschiffler@6757
   463
aschiffler@6757
   464
	return TEST_COMPLETED;
aschiffler@6757
   465
}
aschiffler@6757
   466
aschiffler@6757
   467
/*!
aschiffler@6757
   468
 * \brief Tests SDL_IntersectRect() with B partially intersecting A
aschiffler@6757
   469
 *
aschiffler@6757
   470
 * \sa
aschiffler@6757
   471
 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect
aschiffler@6757
   472
 */
aschiffler@6757
   473
int rect_testIntersectRectPartial (void *arg)
aschiffler@6757
   474
{
aschiffler@6757
   475
    SDL_Rect refRectA = { 0, 0, 32, 32 };
aschiffler@6757
   476
    SDL_Rect refRectB;
aschiffler@6757
   477
    SDL_Rect rectA;
aschiffler@6757
   478
    SDL_Rect rectB;
aschiffler@6757
   479
    SDL_Rect result;
aschiffler@6757
   480
    SDL_Rect expectedResult;
aschiffler@6757
   481
    SDL_bool intersection;
aschiffler@6757
   482
aschiffler@6757
   483
    // rectB partially contained in rectA
aschiffler@6757
   484
    refRectB.x = SDLTest_RandomIntegerInRange(refRectA.x + 1, refRectA.x + refRectA.w - 1);
aschiffler@6757
   485
    refRectB.y = SDLTest_RandomIntegerInRange(refRectA.y + 1, refRectA.y + refRectA.h - 1);
aschiffler@6757
   486
    refRectB.w = refRectA.w;
aschiffler@6757
   487
    refRectB.h = refRectA.h;
aschiffler@6757
   488
    rectA = refRectA;
aschiffler@6757
   489
    rectB = refRectB;
aschiffler@6757
   490
    expectedResult.x = refRectB.x;
aschiffler@6757
   491
    expectedResult.y = refRectB.y;
aschiffler@6757
   492
    expectedResult.w = refRectA.w - refRectB.x;
aschiffler@6757
   493
    expectedResult.h = refRectA.h - refRectB.y;    
aschiffler@6757
   494
    intersection = SDL_IntersectRect(&rectA, &rectB, &result);
aschiffler@6757
   495
    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
aschiffler@6757
   496
aschiffler@6757
   497
    // rectB right edge
aschiffler@6757
   498
    refRectB.x = rectA.w - 1;
aschiffler@6757
   499
    refRectB.y = rectA.y;
aschiffler@6757
   500
    refRectB.w = SDLTest_RandomIntegerInRange(1, refRectA.w - 1);
aschiffler@6757
   501
    refRectB.h = SDLTest_RandomIntegerInRange(1, refRectA.h - 1);
aschiffler@6757
   502
    rectA = refRectA;
aschiffler@6757
   503
    rectB = refRectB;
aschiffler@6757
   504
    expectedResult.x = refRectB.x;
aschiffler@6757
   505
    expectedResult.y = refRectB.y;
aschiffler@6757
   506
    expectedResult.w = 1;
aschiffler@6757
   507
    expectedResult.h = refRectB.h;    
aschiffler@6757
   508
    intersection = SDL_IntersectRect(&rectA, &rectB, &result);
aschiffler@6757
   509
    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
aschiffler@6757
   510
aschiffler@6757
   511
    // rectB left edge
aschiffler@6757
   512
    refRectB.x = 1 - rectA.w;
aschiffler@6757
   513
    refRectB.y = rectA.y;
aschiffler@6757
   514
    refRectB.w = refRectA.w;
aschiffler@6757
   515
    refRectB.h = SDLTest_RandomIntegerInRange(1, refRectA.h - 1);
aschiffler@6757
   516
    rectA = refRectA;
aschiffler@6757
   517
    rectB = refRectB;
aschiffler@6757
   518
    expectedResult.x = 0;
aschiffler@6757
   519
    expectedResult.y = refRectB.y;
aschiffler@6757
   520
    expectedResult.w = 1;
aschiffler@6757
   521
    expectedResult.h = refRectB.h;    
aschiffler@6757
   522
    intersection = SDL_IntersectRect(&rectA, &rectB, &result);
aschiffler@6757
   523
    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
aschiffler@6757
   524
aschiffler@6757
   525
    // rectB bottom edge
aschiffler@6757
   526
    refRectB.x = rectA.x;
aschiffler@6757
   527
    refRectB.y = rectA.h - 1;
aschiffler@6757
   528
    refRectB.w = SDLTest_RandomIntegerInRange(1, refRectA.w - 1);
aschiffler@6757
   529
    refRectB.h = SDLTest_RandomIntegerInRange(1, refRectA.h - 1);
aschiffler@6757
   530
    rectA = refRectA;
aschiffler@6757
   531
    rectB = refRectB;
aschiffler@6757
   532
    expectedResult.x = refRectB.x;
aschiffler@6757
   533
    expectedResult.y = refRectB.y;
aschiffler@6757
   534
    expectedResult.w = refRectB.w;
aschiffler@6757
   535
    expectedResult.h = 1;    
aschiffler@6757
   536
    intersection = SDL_IntersectRect(&rectA, &rectB, &result);
aschiffler@6757
   537
    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
aschiffler@6757
   538
aschiffler@6757
   539
    // rectB top edge
aschiffler@6757
   540
    refRectB.x = rectA.x;
aschiffler@6757
   541
    refRectB.y = 1 - rectA.h;
aschiffler@6757
   542
    refRectB.w = SDLTest_RandomIntegerInRange(1, refRectA.w - 1);
aschiffler@6757
   543
    refRectB.h = rectA.h;
aschiffler@6757
   544
    rectA = refRectA;
aschiffler@6757
   545
    rectB = refRectB;
aschiffler@6757
   546
    expectedResult.x = refRectB.x;
aschiffler@6757
   547
    expectedResult.y = 0;
aschiffler@6757
   548
    expectedResult.w = refRectB.w;
aschiffler@6757
   549
    expectedResult.h = 1;    
aschiffler@6757
   550
    intersection = SDL_IntersectRect(&rectA, &rectB, &result);
aschiffler@6757
   551
    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
aschiffler@6757
   552
aschiffler@6757
   553
	return TEST_COMPLETED;
aschiffler@6757
   554
}
aschiffler@6757
   555
aschiffler@6757
   556
/*!
aschiffler@6757
   557
 * \brief Tests SDL_IntersectRect() with 1x1 pixel sized rectangles
aschiffler@6757
   558
 *
aschiffler@6757
   559
 * \sa
aschiffler@6757
   560
 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect
aschiffler@6757
   561
 */
aschiffler@6757
   562
int rect_testIntersectRectPoint (void *arg)
aschiffler@6757
   563
{
aschiffler@6757
   564
    SDL_Rect refRectA = { 0, 0, 1, 1 };
aschiffler@6757
   565
    SDL_Rect refRectB = { 0, 0, 1, 1 };
aschiffler@6757
   566
    SDL_Rect rectA;
aschiffler@6757
   567
    SDL_Rect rectB;
aschiffler@6757
   568
    SDL_Rect result;
aschiffler@6757
   569
    SDL_bool intersection;
aschiffler@6757
   570
    int offsetX, offsetY;
aschiffler@6757
   571
aschiffler@6757
   572
    // intersecting pixels
aschiffler@6757
   573
    refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   574
    refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   575
    refRectB.x = refRectA.x;
aschiffler@6757
   576
    refRectB.y = refRectA.y;
aschiffler@6757
   577
    rectA = refRectA;
aschiffler@6757
   578
    rectB = refRectB;
aschiffler@6757
   579
    intersection = SDL_IntersectRect(&rectA, &rectB, &result);
aschiffler@6757
   580
    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &refRectA);
aschiffler@6757
   581
aschiffler@6757
   582
    // non-intersecting pixels cases
aschiffler@6757
   583
    for (offsetX = -1; offsetX <= 1; offsetX++) {
aschiffler@6757
   584
        for (offsetY = -1; offsetY <= 1; offsetY++) {
aschiffler@6757
   585
            if (offsetX != 0 || offsetY != 0) {
aschiffler@6757
   586
                refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   587
                refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   588
                refRectB.x = refRectA.x;
aschiffler@6757
   589
                refRectB.y = refRectA.y;    
aschiffler@6757
   590
                refRectB.x += offsetX;
aschiffler@6757
   591
                refRectB.y += offsetY;
aschiffler@6757
   592
                rectA = refRectA;
aschiffler@6757
   593
                rectB = refRectB;
aschiffler@6757
   594
                intersection = SDL_IntersectRect(&rectA, &rectB, &result);
aschiffler@6757
   595
                _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
aschiffler@6757
   596
            }
aschiffler@6757
   597
        }
aschiffler@6757
   598
    }
aschiffler@6757
   599
aschiffler@6757
   600
	return TEST_COMPLETED;
aschiffler@6757
   601
}
aschiffler@6757
   602
aschiffler@6757
   603
/*!
aschiffler@6757
   604
 * \brief Tests SDL_IntersectRect() with empty rectangles
aschiffler@6757
   605
 *
aschiffler@6757
   606
 * \sa
aschiffler@6757
   607
 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect
aschiffler@6757
   608
 */
aschiffler@6757
   609
int rect_testIntersectRectEmpty (void *arg)
aschiffler@6757
   610
{
aschiffler@6757
   611
    SDL_Rect refRectA;
aschiffler@6757
   612
    SDL_Rect refRectB;
aschiffler@6757
   613
    SDL_Rect rectA;
aschiffler@6757
   614
    SDL_Rect rectB;
aschiffler@6757
   615
    SDL_Rect result;
aschiffler@6757
   616
    SDL_bool intersection;
aschiffler@6757
   617
aschiffler@6757
   618
    // Rect A empty
aschiffler@6757
   619
    refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   620
    refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   621
    refRectA.w = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   622
    refRectA.h = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   623
    refRectB = refRectA;
aschiffler@6757
   624
    refRectA.w = 0;
aschiffler@6757
   625
    refRectA.h = 0;
aschiffler@6757
   626
    rectA = refRectA;
aschiffler@6757
   627
    rectB = refRectB;
aschiffler@6757
   628
    intersection = SDL_IntersectRect(&rectA, &rectB, &result);
aschiffler@6757
   629
    _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
aschiffler@6757
   630
aschiffler@6757
   631
    // Rect B empty
aschiffler@6757
   632
    refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   633
    refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   634
    refRectA.w = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   635
    refRectA.h = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   636
    refRectB = refRectA;
aschiffler@6757
   637
    refRectB.w = 0;
aschiffler@6757
   638
    refRectB.h = 0;
aschiffler@6757
   639
    rectA = refRectA;
aschiffler@6757
   640
    rectB = refRectB;
aschiffler@6757
   641
    intersection = SDL_IntersectRect(&rectA, &rectB, &result);
aschiffler@6757
   642
    _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
aschiffler@6757
   643
aschiffler@6757
   644
    // Rect A and B empty
aschiffler@6757
   645
    refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   646
    refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   647
    refRectA.w = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   648
    refRectA.h = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   649
    refRectB = refRectA;
aschiffler@6757
   650
    refRectA.w = 0;
aschiffler@6757
   651
    refRectA.h = 0;
aschiffler@6757
   652
    refRectB.w = 0;
aschiffler@6757
   653
    refRectB.h = 0;
aschiffler@6757
   654
    rectA = refRectA;
aschiffler@6757
   655
    rectB = refRectB;
aschiffler@6757
   656
    intersection = SDL_IntersectRect(&rectA, &rectB, &result);
aschiffler@6757
   657
    _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
aschiffler@6757
   658
aschiffler@6757
   659
	return TEST_COMPLETED;
aschiffler@6757
   660
}
aschiffler@6757
   661
aschiffler@6757
   662
/*!
aschiffler@6757
   663
 * \brief Negative tests against SDL_IntersectRect() with invalid parameters
aschiffler@6757
   664
 *
aschiffler@6757
   665
 * \sa
aschiffler@6757
   666
 * http://wiki.libsdl.org/moin.cgi/SDL_IntersectRect
aschiffler@6757
   667
 */
aschiffler@6757
   668
int rect_testIntersectRectParam(void *arg)
aschiffler@6757
   669
{
aschiffler@6757
   670
    SDL_Rect rectA;
aschiffler@6757
   671
    SDL_Rect rectB;
aschiffler@6757
   672
    SDL_Rect result;
aschiffler@6757
   673
    SDL_bool intersection;
aschiffler@6757
   674
aschiffler@6757
   675
    // invalid parameter combinations
aschiffler@6757
   676
    intersection = SDL_IntersectRect((SDL_Rect *)NULL, &rectB, &result);
aschiffler@6757
   677
    SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 1st parameter is NULL"); 
aschiffler@6757
   678
    intersection = SDL_IntersectRect(&rectA, (SDL_Rect *)NULL, &result);
aschiffler@6757
   679
    SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 2st parameter is NULL"); 
aschiffler@6757
   680
    intersection = SDL_IntersectRect(&rectA, &rectB, (SDL_Rect *)NULL);
aschiffler@6757
   681
    SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 3st parameter is NULL"); 
aschiffler@6757
   682
    intersection = SDL_IntersectRect((SDL_Rect *)NULL, (SDL_Rect *)NULL, &result);
aschiffler@6757
   683
    SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 1st and 2nd parameters are NULL"); 
aschiffler@6757
   684
    intersection = SDL_IntersectRect((SDL_Rect *)NULL, &rectB, (SDL_Rect *)NULL);
aschiffler@6757
   685
    SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 1st and 3rd parameters are NULL "); 
aschiffler@6757
   686
    intersection = SDL_IntersectRect((SDL_Rect *)NULL, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
aschiffler@6757
   687
    SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when all parameters are NULL");     
aschiffler@6757
   688
aschiffler@6757
   689
	return TEST_COMPLETED;
aschiffler@6757
   690
}
aschiffler@6757
   691
aschiffler@6757
   692
/*!
aschiffler@6757
   693
 * \brief Tests SDL_HasIntersection() with B fully inside A
aschiffler@6757
   694
 *
aschiffler@6757
   695
 * \sa
aschiffler@6757
   696
 * http://wiki.libsdl.org/moin.cgi/SDL_HasIntersection
aschiffler@6757
   697
 */
aschiffler@6757
   698
int rect_testHasIntersectionInside (void *arg)
aschiffler@6757
   699
{
aschiffler@6757
   700
    SDL_Rect refRectA = { 0, 0, 32, 32 };
aschiffler@6757
   701
    SDL_Rect refRectB;
aschiffler@6757
   702
    SDL_Rect rectA;
aschiffler@6757
   703
    SDL_Rect rectB;
aschiffler@6757
   704
    SDL_bool intersection;
aschiffler@6757
   705
aschiffler@6757
   706
    // rectB fully contained in rectA
aschiffler@6757
   707
    refRectB.x = 0;
aschiffler@6757
   708
    refRectB.y = 0;
aschiffler@6757
   709
    refRectB.w = SDLTest_RandomIntegerInRange(refRectA.x + 1, refRectA.x + refRectA.w - 1);
aschiffler@6757
   710
    refRectB.h = SDLTest_RandomIntegerInRange(refRectA.y + 1, refRectA.y + refRectA.h - 1);
aschiffler@6757
   711
    rectA = refRectA;
aschiffler@6757
   712
    rectB = refRectB;
aschiffler@6757
   713
    intersection = SDL_HasIntersection(&rectA, &rectB);
aschiffler@6757
   714
    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
   715
aschiffler@6757
   716
	return TEST_COMPLETED;
aschiffler@6757
   717
}
aschiffler@6757
   718
aschiffler@6757
   719
/*!
aschiffler@6757
   720
 * \brief Tests SDL_HasIntersection() with B fully outside A
aschiffler@6757
   721
 *
aschiffler@6757
   722
 * \sa
aschiffler@6757
   723
 * http://wiki.libsdl.org/moin.cgi/SDL_HasIntersection
aschiffler@6757
   724
 */
aschiffler@6757
   725
int rect_testHasIntersectionOutside (void *arg)
aschiffler@6757
   726
{
aschiffler@6757
   727
    SDL_Rect refRectA = { 0, 0, 32, 32 };
aschiffler@6757
   728
    SDL_Rect refRectB;
aschiffler@6757
   729
    SDL_Rect rectA;
aschiffler@6757
   730
    SDL_Rect rectB;
aschiffler@6757
   731
    SDL_bool intersection;
aschiffler@6757
   732
aschiffler@6757
   733
    // rectB fully outside of rectA
aschiffler@6757
   734
    refRectB.x = refRectA.x + refRectA.w + SDLTest_RandomIntegerInRange(1, 10);
aschiffler@6757
   735
    refRectB.y = refRectA.y + refRectA.h + SDLTest_RandomIntegerInRange(1, 10);
aschiffler@6757
   736
    refRectB.w = refRectA.w;
aschiffler@6757
   737
    refRectB.h = refRectA.h;
aschiffler@6757
   738
    rectA = refRectA;
aschiffler@6757
   739
    rectB = refRectB;
aschiffler@6757
   740
    intersection = SDL_HasIntersection(&rectA, &rectB);
aschiffler@6757
   741
    _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
   742
aschiffler@6757
   743
	return TEST_COMPLETED;
aschiffler@6757
   744
}
aschiffler@6757
   745
aschiffler@6757
   746
/*!
aschiffler@6757
   747
 * \brief Tests SDL_HasIntersection() with B partially intersecting A
aschiffler@6757
   748
 *
aschiffler@6757
   749
 * \sa
aschiffler@6757
   750
 * http://wiki.libsdl.org/moin.cgi/SDL_HasIntersection
aschiffler@6757
   751
 */
aschiffler@6757
   752
int rect_testHasIntersectionPartial (void *arg)
aschiffler@6757
   753
{
aschiffler@6757
   754
    SDL_Rect refRectA = { 0, 0, 32, 32 };
aschiffler@6757
   755
    SDL_Rect refRectB;
aschiffler@6757
   756
    SDL_Rect rectA;
aschiffler@6757
   757
    SDL_Rect rectB;
aschiffler@6757
   758
    SDL_bool intersection;
aschiffler@6757
   759
aschiffler@6757
   760
    // rectB partially contained in rectA
aschiffler@6757
   761
    refRectB.x = SDLTest_RandomIntegerInRange(refRectA.x + 1, refRectA.x + refRectA.w - 1);
aschiffler@6757
   762
    refRectB.y = SDLTest_RandomIntegerInRange(refRectA.y + 1, refRectA.y + refRectA.h - 1);
aschiffler@6757
   763
    refRectB.w = refRectA.w;
aschiffler@6757
   764
    refRectB.h = refRectA.h;
aschiffler@6757
   765
    rectA = refRectA;
aschiffler@6757
   766
    rectB = refRectB;
aschiffler@6757
   767
    intersection = SDL_HasIntersection(&rectA, &rectB);
aschiffler@6757
   768
    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
   769
aschiffler@6757
   770
    // rectB right edge
aschiffler@6757
   771
    refRectB.x = rectA.w - 1;
aschiffler@6757
   772
    refRectB.y = rectA.y;
aschiffler@6757
   773
    refRectB.w = SDLTest_RandomIntegerInRange(1, refRectA.w - 1);
aschiffler@6757
   774
    refRectB.h = SDLTest_RandomIntegerInRange(1, refRectA.h - 1);
aschiffler@6757
   775
    rectA = refRectA;
aschiffler@6757
   776
    rectB = refRectB;
aschiffler@6757
   777
    intersection = SDL_HasIntersection(&rectA, &rectB);
aschiffler@6757
   778
    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
   779
aschiffler@6757
   780
    // rectB left edge
aschiffler@6757
   781
    refRectB.x = 1 - rectA.w;
aschiffler@6757
   782
    refRectB.y = rectA.y;
aschiffler@6757
   783
    refRectB.w = refRectA.w;
aschiffler@6757
   784
    refRectB.h = SDLTest_RandomIntegerInRange(1, refRectA.h - 1);
aschiffler@6757
   785
    rectA = refRectA;
aschiffler@6757
   786
    rectB = refRectB;
aschiffler@6757
   787
    intersection = SDL_HasIntersection(&rectA, &rectB);
aschiffler@6757
   788
    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
   789
aschiffler@6757
   790
    // rectB bottom edge
aschiffler@6757
   791
    refRectB.x = rectA.x;
aschiffler@6757
   792
    refRectB.y = rectA.h - 1;
aschiffler@6757
   793
    refRectB.w = SDLTest_RandomIntegerInRange(1, refRectA.w - 1);
aschiffler@6757
   794
    refRectB.h = SDLTest_RandomIntegerInRange(1, refRectA.h - 1);
aschiffler@6757
   795
    rectA = refRectA;
aschiffler@6757
   796
    rectB = refRectB;
aschiffler@6757
   797
    intersection = SDL_HasIntersection(&rectA, &rectB);
aschiffler@6757
   798
    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
   799
aschiffler@6757
   800
    // rectB top edge
aschiffler@6757
   801
    refRectB.x = rectA.x;
aschiffler@6757
   802
    refRectB.y = 1 - rectA.h;
aschiffler@6757
   803
    refRectB.w = SDLTest_RandomIntegerInRange(1, refRectA.w - 1);
aschiffler@6757
   804
    refRectB.h = rectA.h;
aschiffler@6757
   805
    rectA = refRectA;
aschiffler@6757
   806
    rectB = refRectB;
aschiffler@6757
   807
    intersection = SDL_HasIntersection(&rectA, &rectB);
aschiffler@6757
   808
    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
   809
aschiffler@6757
   810
	return TEST_COMPLETED;
aschiffler@6757
   811
}
aschiffler@6757
   812
aschiffler@6757
   813
/*!
aschiffler@6757
   814
 * \brief Tests SDL_HasIntersection() with 1x1 pixel sized rectangles
aschiffler@6757
   815
 *
aschiffler@6757
   816
 * \sa
aschiffler@6757
   817
 * http://wiki.libsdl.org/moin.cgi/SDL_HasIntersection
aschiffler@6757
   818
 */
aschiffler@6757
   819
int rect_testHasIntersectionPoint (void *arg)
aschiffler@6757
   820
{
aschiffler@6757
   821
    SDL_Rect refRectA = { 0, 0, 1, 1 };
aschiffler@6757
   822
    SDL_Rect refRectB = { 0, 0, 1, 1 };
aschiffler@6757
   823
    SDL_Rect rectA;
aschiffler@6757
   824
    SDL_Rect rectB;
aschiffler@6757
   825
    SDL_bool intersection;
aschiffler@6757
   826
    int offsetX, offsetY;
aschiffler@6757
   827
aschiffler@6757
   828
    // intersecting pixels
aschiffler@6757
   829
    refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   830
    refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   831
    refRectB.x = refRectA.x;
aschiffler@6757
   832
    refRectB.y = refRectA.y;
aschiffler@6757
   833
    rectA = refRectA;
aschiffler@6757
   834
    rectB = refRectB;
aschiffler@6757
   835
    intersection = SDL_HasIntersection(&rectA, &rectB);
aschiffler@6757
   836
    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
   837
aschiffler@6757
   838
    // non-intersecting pixels cases
aschiffler@6757
   839
    for (offsetX = -1; offsetX <= 1; offsetX++) {
aschiffler@6757
   840
        for (offsetY = -1; offsetY <= 1; offsetY++) {
aschiffler@6757
   841
            if (offsetX != 0 || offsetY != 0) {
aschiffler@6757
   842
                refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   843
                refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   844
                refRectB.x = refRectA.x;
aschiffler@6757
   845
                refRectB.y = refRectA.y;    
aschiffler@6757
   846
                refRectB.x += offsetX;
aschiffler@6757
   847
                refRectB.y += offsetY;
aschiffler@6757
   848
                rectA = refRectA;
aschiffler@6757
   849
                rectB = refRectB;
aschiffler@6757
   850
                intersection = SDL_HasIntersection(&rectA, &rectB);
aschiffler@6757
   851
                _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
   852
            }
aschiffler@6757
   853
        }
aschiffler@6757
   854
    }
aschiffler@6757
   855
aschiffler@6757
   856
	return TEST_COMPLETED;
aschiffler@6757
   857
}
aschiffler@6757
   858
aschiffler@6757
   859
/*!
aschiffler@6757
   860
 * \brief Tests SDL_HasIntersection() with empty rectangles
aschiffler@6757
   861
 *
aschiffler@6757
   862
 * \sa
aschiffler@6757
   863
 * http://wiki.libsdl.org/moin.cgi/SDL_HasIntersection
aschiffler@6757
   864
 */
aschiffler@6757
   865
int rect_testHasIntersectionEmpty (void *arg)
aschiffler@6757
   866
{
aschiffler@6757
   867
    SDL_Rect refRectA;
aschiffler@6757
   868
    SDL_Rect refRectB;
aschiffler@6757
   869
    SDL_Rect rectA;
aschiffler@6757
   870
    SDL_Rect rectB;
aschiffler@6757
   871
    SDL_bool intersection;
aschiffler@6757
   872
aschiffler@6757
   873
    // Rect A empty
aschiffler@6757
   874
    refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   875
    refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   876
    refRectA.w = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   877
    refRectA.h = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   878
    refRectB = refRectA;
aschiffler@6757
   879
    refRectA.w = 0;
aschiffler@6757
   880
    refRectA.h = 0;
aschiffler@6757
   881
    rectA = refRectA;
aschiffler@6757
   882
    rectB = refRectB;
aschiffler@6757
   883
    intersection = SDL_HasIntersection(&rectA, &rectB);
aschiffler@6757
   884
    _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
   885
aschiffler@6757
   886
    // Rect B empty
aschiffler@6757
   887
    refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   888
    refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   889
    refRectA.w = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   890
    refRectA.h = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   891
    refRectB = refRectA;
aschiffler@6757
   892
    refRectB.w = 0;
aschiffler@6757
   893
    refRectB.h = 0;
aschiffler@6757
   894
    rectA = refRectA;
aschiffler@6757
   895
    rectB = refRectB;
aschiffler@6757
   896
    intersection = SDL_HasIntersection(&rectA, &rectB);
aschiffler@6757
   897
    _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
   898
aschiffler@6757
   899
    // Rect A and B empty
aschiffler@6757
   900
    refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   901
    refRectA.y = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   902
    refRectA.w = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   903
    refRectA.h = SDLTest_RandomIntegerInRange(1, 100);
aschiffler@6757
   904
    refRectB = refRectA;
aschiffler@6757
   905
    refRectA.w = 0;
aschiffler@6757
   906
    refRectA.h = 0;
aschiffler@6757
   907
    refRectB.w = 0;
aschiffler@6757
   908
    refRectB.h = 0;
aschiffler@6757
   909
    rectA = refRectA;
aschiffler@6757
   910
    rectB = refRectB;
aschiffler@6757
   911
    intersection = SDL_HasIntersection(&rectA, &rectB);
aschiffler@6757
   912
    _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
   913
aschiffler@6757
   914
	return TEST_COMPLETED;
aschiffler@6757
   915
}
aschiffler@6757
   916
aschiffler@6757
   917
/*!
aschiffler@6757
   918
 * \brief Negative tests against SDL_HasIntersection() with invalid parameters
aschiffler@6757
   919
 *
aschiffler@6757
   920
 * \sa
aschiffler@6757
   921
 * http://wiki.libsdl.org/moin.cgi/SDL_HasIntersection
aschiffler@6757
   922
 */
aschiffler@6757
   923
int rect_testHasIntersectionParam(void *arg)
aschiffler@6757
   924
{
aschiffler@6757
   925
    SDL_Rect rectA;
aschiffler@6757
   926
    SDL_Rect rectB;
aschiffler@6757
   927
    SDL_bool intersection;
aschiffler@6757
   928
aschiffler@6757
   929
    // invalid parameter combinations
aschiffler@6757
   930
    intersection = SDL_HasIntersection((SDL_Rect *)NULL, &rectB);
aschiffler@6757
   931
    SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 1st parameter is NULL"); 
aschiffler@6757
   932
    intersection = SDL_HasIntersection(&rectA, (SDL_Rect *)NULL);
aschiffler@6757
   933
    SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when 2st parameter is NULL"); 
aschiffler@6757
   934
    intersection = SDL_HasIntersection((SDL_Rect *)NULL, (SDL_Rect *)NULL);
aschiffler@6757
   935
    SDLTest_AssertCheck(intersection == SDL_FALSE, "Check that function returns SDL_FALSE when all parameters are NULL");     
aschiffler@6757
   936
aschiffler@6757
   937
	return TEST_COMPLETED;
aschiffler@6757
   938
}
aschiffler@6757
   939
aschiffler@6757
   940
/*!
aschiffler@6757
   941
 * \brief Test SDL_EnclosePoints() without clipping
aschiffler@6757
   942
 *
aschiffler@6757
   943
 * \sa
aschiffler@6757
   944
 * http://wiki.libsdl.org/moin.cgi/SDL_EnclosePoints
aschiffler@6757
   945
 */
aschiffler@6757
   946
int rect_testEnclosePoints(void *arg)
aschiffler@6757
   947
{
aschiffler@6757
   948
    const int numPoints = 16;
aschiffler@6757
   949
    SDL_Point refPoints[16];
aschiffler@6757
   950
    SDL_Point points[16];
aschiffler@6757
   951
    SDL_Rect result;
aschiffler@6757
   952
    SDL_bool anyEnclosed;
aschiffler@6757
   953
    SDL_bool anyEnclosedNoResult;
aschiffler@6772
   954
    SDL_bool expectedEnclosed = SDL_TRUE;
aschiffler@6772
   955
    int newx, newy;
aschiffler@6772
   956
    int minx = 0, maxx = 0, miny = 0, maxy = 0;
aschiffler@6772
   957
    int i;
aschiffler@6757
   958
aschiffler@6757
   959
    // Create input data, tracking result
aschiffler@6757
   960
    for (i=0; i<numPoints; i++) {
aschiffler@6757
   961
        newx = SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
   962
        newy = SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
   963
        refPoints[i].x = newx;
aschiffler@6757
   964
        refPoints[i].y = newy;
aschiffler@6757
   965
        points[i].x = newx;
aschiffler@6757
   966
        points[i].y = newy;
aschiffler@6757
   967
        if (i==0) {
aschiffler@6772
   968
            minx = newx;
aschiffler@6772
   969
            maxx = newx;
aschiffler@6772
   970
            miny = newy;
aschiffler@6772
   971
            maxy = newy;
aschiffler@6757
   972
        } else {
aschiffler@6772
   973
            if (newx < minx) minx = newx;
aschiffler@6772
   974
            if (newx > maxx) maxx = newx;
aschiffler@6772
   975
            if (newy < miny) miny = newy;
aschiffler@6772
   976
            if (newy > maxy) maxy = newy;
aschiffler@6757
   977
        }
aschiffler@6757
   978
    }
aschiffler@6757
   979
    
aschiffler@6757
   980
    // Call function and validate - special case: no result requested
aschiffler@6757
   981
    anyEnclosedNoResult = SDL_EnclosePoints((const SDL_Point *)points, numPoints, (const SDL_Rect *)NULL, (SDL_Rect *)NULL);
aschiffler@6757
   982
    SDLTest_AssertCheck(expectedEnclosed==anyEnclosedNoResult, 
aschiffler@6757
   983
        "Check expected return value %s, got %s", 
aschiffler@6757
   984
        (expectedEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE", 
aschiffler@6757
   985
		(anyEnclosedNoResult==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE");
aschiffler@6757
   986
    for (i=0; i<numPoints; i++) {
aschiffler@6757
   987
        SDLTest_AssertCheck(refPoints[i].x==points[i].x && refPoints[i].y==points[i].y,
aschiffler@6757
   988
            "Check that source point %i was not modified: expected (%i,%i) actual (%i,%i)", 
aschiffler@6757
   989
            i, refPoints[i].x, refPoints[i].y, points[i].x, points[i].y);
aschiffler@6757
   990
    }
aschiffler@6757
   991
aschiffler@6757
   992
    // Call function and validate
aschiffler@6757
   993
    anyEnclosed = SDL_EnclosePoints((const SDL_Point *)points, numPoints, (const SDL_Rect *)NULL, &result);
aschiffler@6757
   994
    SDLTest_AssertCheck(expectedEnclosed==anyEnclosed, 
aschiffler@6757
   995
        "Check return value %s, got %s", 
aschiffler@6757
   996
        (expectedEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE", 
aschiffler@6757
   997
		(anyEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE");
aschiffler@6757
   998
    for (i=0; i<numPoints; i++) {
aschiffler@6757
   999
        SDLTest_AssertCheck(refPoints[i].x==points[i].x && refPoints[i].y==points[i].y,
aschiffler@6757
  1000
            "Check that source point %i was not modified: expected (%i,%i) actual (%i,%i)", 
aschiffler@6757
  1001
            i, refPoints[i].x, refPoints[i].y, points[i].x, points[i].y);
aschiffler@6757
  1002
    }
aschiffler@6757
  1003
    SDLTest_AssertCheck(result.x==minx && result.y==miny && result.w==(maxx - minx + 1) && result.h==(maxy - miny + 1),
aschiffler@6757
  1004
        "Resulting enclosing rectangle incorrect: expected (%i,%i - %i,%i), actual (%i,%i - %i,%i)",
aschiffler@6757
  1005
        minx, miny, maxx, maxy, result.x, result.y, result.x + result.w - 1, result.y + result.h - 1);
aschiffler@6757
  1006
aschiffler@6757
  1007
	return TEST_COMPLETED;
aschiffler@6757
  1008
}
aschiffler@6757
  1009
aschiffler@6757
  1010
/*!
aschiffler@6757
  1011
 * \brief Test SDL_EnclosePoints() with repeated input points
aschiffler@6757
  1012
 *
aschiffler@6757
  1013
 * \sa
aschiffler@6757
  1014
 * http://wiki.libsdl.org/moin.cgi/SDL_EnclosePoints
aschiffler@6757
  1015
 */
aschiffler@6757
  1016
int rect_testEnclosePointsRepeatedInput(void *arg)
aschiffler@6757
  1017
{
aschiffler@6757
  1018
    const int numPoints = 8;
aschiffler@6757
  1019
    const int halfPoints = 4;
aschiffler@6757
  1020
    SDL_Point refPoints[8];
aschiffler@6757
  1021
    SDL_Point points[8];
aschiffler@6757
  1022
    SDL_Rect result;
aschiffler@6757
  1023
    SDL_bool anyEnclosed;
aschiffler@6757
  1024
    SDL_bool anyEnclosedNoResult;
aschiffler@6772
  1025
    SDL_bool expectedEnclosed = SDL_TRUE;
aschiffler@6772
  1026
    int newx, newy;
aschiffler@6772
  1027
    int minx = 0, maxx = 0, miny = 0, maxy = 0;
aschiffler@6772
  1028
    int i;
aschiffler@6757
  1029
aschiffler@6757
  1030
    // Create input data, tracking result
aschiffler@6757
  1031
    for (i=0; i<numPoints; i++) {
aschiffler@6757
  1032
        if (i < halfPoints) {
aschiffler@6757
  1033
            newx = SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1034
            newy = SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1035
        } else {
aschiffler@6757
  1036
            newx = refPoints[i-halfPoints].x;
aschiffler@6757
  1037
            newy = refPoints[i-halfPoints].y;
aschiffler@6757
  1038
        }
aschiffler@6757
  1039
        refPoints[i].x = newx;
aschiffler@6757
  1040
        refPoints[i].y = newy;
aschiffler@6757
  1041
        points[i].x = newx;
aschiffler@6757
  1042
        points[i].y = newy;
aschiffler@6757
  1043
        if (i==0) {
aschiffler@6772
  1044
            minx = newx;
aschiffler@6772
  1045
            maxx = newx;
aschiffler@6772
  1046
            miny = newy;
aschiffler@6772
  1047
            maxy = newy;
aschiffler@6757
  1048
        } else {
aschiffler@6772
  1049
            if (newx < minx) minx = newx;
aschiffler@6772
  1050
            if (newx > maxx) maxx = newx;
aschiffler@6772
  1051
            if (newy < miny) miny = newy;
aschiffler@6772
  1052
            if (newy > maxy) maxy = newy;
aschiffler@6757
  1053
        }
aschiffler@6757
  1054
    }
aschiffler@6757
  1055
aschiffler@6757
  1056
    // Call function and validate - special case: no result requested
aschiffler@6757
  1057
    anyEnclosedNoResult = SDL_EnclosePoints((const SDL_Point *)points, numPoints, (const SDL_Rect *)NULL, (SDL_Rect *)NULL);
aschiffler@6757
  1058
    SDLTest_AssertCheck(expectedEnclosed==anyEnclosedNoResult, 
aschiffler@6757
  1059
        "Check return value %s, got %s", 
aschiffler@6757
  1060
        (expectedEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE", 
aschiffler@6757
  1061
		(anyEnclosedNoResult==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE");
aschiffler@6757
  1062
    for (i=0; i<numPoints; i++) {
aschiffler@6757
  1063
        SDLTest_AssertCheck(refPoints[i].x==points[i].x && refPoints[i].y==points[i].y,
aschiffler@6757
  1064
            "Check that source point %i was not modified: expected (%i,%i) actual (%i,%i)", 
aschiffler@6757
  1065
            i, refPoints[i].x, refPoints[i].y, points[i].x, points[i].y);
aschiffler@6757
  1066
    }
aschiffler@6757
  1067
    
aschiffler@6757
  1068
    // Call function and validate
aschiffler@6757
  1069
    anyEnclosed = SDL_EnclosePoints((const SDL_Point *)points, numPoints, (const SDL_Rect *)NULL, &result);
aschiffler@6757
  1070
    SDLTest_AssertCheck(expectedEnclosed==anyEnclosed, 
aschiffler@6757
  1071
        "Check return value %s, got %s", 
aschiffler@6757
  1072
        (expectedEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE", 
aschiffler@6757
  1073
		(anyEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE");
aschiffler@6757
  1074
    for (i=0; i<numPoints; i++) {
aschiffler@6757
  1075
        SDLTest_AssertCheck(refPoints[i].x==points[i].x && refPoints[i].y==points[i].y,
aschiffler@6757
  1076
            "Check that source point %i was not modified: expected (%i,%i) actual (%i,%i)", 
aschiffler@6757
  1077
            i, refPoints[i].x, refPoints[i].y, points[i].x, points[i].y);
aschiffler@6757
  1078
    }
aschiffler@6757
  1079
    SDLTest_AssertCheck(result.x==minx && result.y==miny && result.w==(maxx - minx + 1) && result.h==(maxy - miny + 1),
aschiffler@6757
  1080
        "Check resulting enclosing rectangle: expected (%i,%i - %i,%i), actual (%i,%i - %i,%i)",
aschiffler@6757
  1081
        minx, miny, maxx, maxy, result.x, result.y, result.x + result.w - 1, result.y + result.h - 1);
aschiffler@6757
  1082
aschiffler@6757
  1083
	return TEST_COMPLETED;
aschiffler@6757
  1084
}
aschiffler@6757
  1085
aschiffler@6757
  1086
/*!
aschiffler@6757
  1087
 * \brief Test SDL_EnclosePoints() with clipping
aschiffler@6757
  1088
 *
aschiffler@6757
  1089
 * \sa
aschiffler@6757
  1090
 * http://wiki.libsdl.org/moin.cgi/SDL_EnclosePoints
aschiffler@6757
  1091
 */
aschiffler@6757
  1092
int rect_testEnclosePointsWithClipping(void *arg)
aschiffler@6757
  1093
{
aschiffler@6757
  1094
    const int numPoints = 16;
aschiffler@6757
  1095
    SDL_Point refPoints[16];
aschiffler@6757
  1096
    SDL_Point points[16];
aschiffler@6757
  1097
    SDL_Rect refClip;
aschiffler@6757
  1098
    SDL_Rect clip;
aschiffler@6757
  1099
    SDL_Rect result;
aschiffler@6757
  1100
    SDL_bool anyEnclosed;
aschiffler@6757
  1101
    SDL_bool anyEnclosedNoResult;
aschiffler@6757
  1102
    SDL_bool expectedEnclosed = SDL_FALSE;
aschiffler@6757
  1103
    int newx, newy;
aschiffler@6772
  1104
    int minx = 0, maxx = 0, miny = 0, maxy = 0;
aschiffler@6757
  1105
    int i;
aschiffler@6757
  1106
aschiffler@6757
  1107
    // Setup clipping rectangle
aschiffler@6757
  1108
    refClip.x = SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1109
    refClip.y = SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1110
    refClip.w = SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
  1111
    refClip.h = SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
  1112
aschiffler@6757
  1113
    // Create input data, tracking result
aschiffler@6757
  1114
    for (i=0; i<numPoints; i++) {
aschiffler@6757
  1115
        newx = SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1116
        newy = SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1117
        refPoints[i].x = newx;
aschiffler@6757
  1118
        refPoints[i].y = newy;
aschiffler@6757
  1119
        points[i].x = newx;
aschiffler@6757
  1120
        points[i].y = newy;
aschiffler@6757
  1121
        if ((newx>=refClip.x) && (newx<(refClip.x + refClip.w)) &&
aschiffler@6757
  1122
            (newy>=refClip.y) && (newy<(refClip.y + refClip.h))) {
aschiffler@6757
  1123
            if (expectedEnclosed==SDL_FALSE) {
aschiffler@6772
  1124
                minx = newx;
aschiffler@6772
  1125
                maxx = newx;
aschiffler@6772
  1126
                miny = newy;
aschiffler@6772
  1127
                maxy = newy;
aschiffler@6757
  1128
            } else {
aschiffler@6772
  1129
                if (newx < minx) minx = newx;
aschiffler@6772
  1130
                if (newx > maxx) maxx = newx;
aschiffler@6772
  1131
                if (newy < miny) miny = newy;
aschiffler@6772
  1132
                if (newy > maxy) maxy = newy;
aschiffler@6757
  1133
            }
aschiffler@6757
  1134
            expectedEnclosed = SDL_TRUE;
aschiffler@6757
  1135
        }
aschiffler@6757
  1136
    }
aschiffler@6757
  1137
aschiffler@6757
  1138
    // Call function and validate - special case: no result requested
aschiffler@6757
  1139
    clip = refClip;
aschiffler@6757
  1140
    anyEnclosedNoResult = SDL_EnclosePoints((const SDL_Point *)points, numPoints, (const SDL_Rect *)&clip, (SDL_Rect *)NULL);
aschiffler@6757
  1141
    SDLTest_AssertCheck(expectedEnclosed==anyEnclosedNoResult, 
aschiffler@6757
  1142
        "Expected return value %s, got %s", 
aschiffler@6757
  1143
        (expectedEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE", 
aschiffler@6757
  1144
		(anyEnclosedNoResult==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE");
aschiffler@6757
  1145
    for (i=0; i<numPoints; i++) {
aschiffler@6757
  1146
        SDLTest_AssertCheck(refPoints[i].x==points[i].x && refPoints[i].y==points[i].y,
aschiffler@6757
  1147
            "Check that source point %i was not modified: expected (%i,%i) actual (%i,%i)", 
aschiffler@6757
  1148
            i, refPoints[i].x, refPoints[i].y, points[i].x, points[i].y);
aschiffler@6757
  1149
    }
aschiffler@6757
  1150
    SDLTest_AssertCheck(refClip.x==clip.x && refClip.y==clip.y && refClip.w==clip.w && refClip.h==clip.h,
aschiffler@6757
  1151
        "Check that source clipping rectangle was not modified");
aschiffler@6757
  1152
    
aschiffler@6757
  1153
    // Call function and validate
aschiffler@6757
  1154
    anyEnclosed = SDL_EnclosePoints((const SDL_Point *)points, numPoints, (const SDL_Rect *)&clip, &result);
aschiffler@6757
  1155
    SDLTest_AssertCheck(expectedEnclosed==anyEnclosed, 
aschiffler@6757
  1156
        "Check return value %s, got %s", 
aschiffler@6757
  1157
        (expectedEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE", 
aschiffler@6757
  1158
		(anyEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE");
aschiffler@6757
  1159
    for (i=0; i<numPoints; i++) {
aschiffler@6757
  1160
        SDLTest_AssertCheck(refPoints[i].x==points[i].x && refPoints[i].y==points[i].y,
aschiffler@6757
  1161
            "Check that source point %i was not modified: expected (%i,%i) actual (%i,%i)", 
aschiffler@6757
  1162
            i, refPoints[i].x, refPoints[i].y, points[i].x, points[i].y);
aschiffler@6757
  1163
    }
aschiffler@6757
  1164
    SDLTest_AssertCheck(refClip.x==clip.x && refClip.y==clip.y && refClip.w==clip.w && refClip.h==clip.h,
aschiffler@6757
  1165
        "Check that source clipping rectangle was not modified");
aschiffler@6757
  1166
    if (expectedEnclosed==SDL_TRUE) {
aschiffler@6757
  1167
        SDLTest_AssertCheck(result.x==minx && result.y==miny && result.w==(maxx - minx + 1) && result.h==(maxy - miny + 1),
aschiffler@6757
  1168
            "Check resulting enclosing rectangle: expected (%i,%i - %i,%i), actual (%i,%i - %i,%i)",
aschiffler@6757
  1169
            minx, miny, maxx, maxy, result.x, result.y, result.x + result.w - 1, result.y + result.h - 1);
aschiffler@6757
  1170
    }    
aschiffler@6757
  1171
    
aschiffler@6757
  1172
    /* Empty clipping rectangle */
aschiffler@6757
  1173
    clip.w = 0;
aschiffler@6757
  1174
    clip.h = 0;
aschiffler@6757
  1175
    expectedEnclosed = SDL_FALSE;
aschiffler@6757
  1176
    anyEnclosed = SDL_EnclosePoints((const SDL_Point *)points, numPoints, (const SDL_Rect *)&clip, &result);
aschiffler@6757
  1177
    SDLTest_AssertCheck(expectedEnclosed==anyEnclosed, 
aschiffler@6757
  1178
        "Check return value %s, got %s", 
aschiffler@6757
  1179
        (expectedEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE", 
aschiffler@6757
  1180
		(anyEnclosed==SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE");    
aschiffler@6757
  1181
aschiffler@6757
  1182
	return TEST_COMPLETED;
aschiffler@6757
  1183
}
aschiffler@6757
  1184
aschiffler@6757
  1185
/*!
aschiffler@6757
  1186
 * \brief Negative tests against SDL_EnclosePoints() with invalid parameters
aschiffler@6757
  1187
 *
aschiffler@6757
  1188
 * \sa
aschiffler@6757
  1189
 * http://wiki.libsdl.org/moin.cgi/SDL_EnclosePoints
aschiffler@6757
  1190
 */
aschiffler@6757
  1191
int rect_testEnclosePointsParam(void *arg)
aschiffler@6757
  1192
{
aschiffler@6757
  1193
    SDL_Point points[1];
aschiffler@6757
  1194
    int count;
aschiffler@6757
  1195
    SDL_Rect clip;
aschiffler@6757
  1196
    SDL_Rect result;
aschiffler@6757
  1197
    SDL_bool anyEnclosed;
aschiffler@6757
  1198
aschiffler@6757
  1199
    // invalid parameter combinations
aschiffler@6757
  1200
    anyEnclosed = SDL_EnclosePoints((SDL_Point *)NULL, 1, (const SDL_Rect *)&clip, &result);
aschiffler@6757
  1201
    SDLTest_AssertCheck(anyEnclosed == SDL_FALSE, "Check that functions returns SDL_FALSE when 1st parameter is NULL"); 
aschiffler@6757
  1202
    anyEnclosed = SDL_EnclosePoints((const SDL_Point *)points, 0, (const SDL_Rect *)&clip, &result);
aschiffler@6757
  1203
    SDLTest_AssertCheck(anyEnclosed == SDL_FALSE, "Check that functions returns SDL_FALSE when 2nd parameter is 0");
aschiffler@6757
  1204
    count = SDLTest_RandomIntegerInRange(-100, -1);
aschiffler@6757
  1205
    anyEnclosed = SDL_EnclosePoints((const SDL_Point *)points, count, (const SDL_Rect *)&clip, &result);
aschiffler@6757
  1206
    SDLTest_AssertCheck(anyEnclosed == SDL_FALSE, "Check that functions returns SDL_FALSE when 2nd parameter is %i (negative)", count); 
aschiffler@6757
  1207
    anyEnclosed = SDL_EnclosePoints((SDL_Point *)NULL, 0, (const SDL_Rect *)&clip, &result);
aschiffler@6757
  1208
    SDLTest_AssertCheck(anyEnclosed == SDL_FALSE, "Check that functions returns SDL_FALSE when 1st parameter is NULL and 2nd parameter was 0"); 
aschiffler@6757
  1209
aschiffler@6757
  1210
	return TEST_COMPLETED;
aschiffler@6757
  1211
}
aschiffler@6757
  1212
aschiffler@6757
  1213
/*!
aschiffler@6757
  1214
 * \brief Tests SDL_UnionRect() where rect B is outside rect A
aschiffler@6757
  1215
 *
aschiffler@6757
  1216
 * \sa
aschiffler@6757
  1217
 * http://wiki.libsdl.org/moin.cgi/SDL_UnionRect
aschiffler@6757
  1218
 */
aschiffler@6757
  1219
int rect_testUnionRectOutside(void *arg)
aschiffler@6757
  1220
{
aschiffler@6757
  1221
    SDL_Rect refRectA, refRectB;
aschiffler@6757
  1222
    SDL_Rect rectA, rectB;
aschiffler@6757
  1223
    SDL_Rect expectedResult;
aschiffler@6757
  1224
    SDL_Rect result;
aschiffler@6757
  1225
    int minx, maxx, miny, maxy;
aschiffler@6757
  1226
    int dx, dy;
aschiffler@6757
  1227
    
aschiffler@6757
  1228
    /* Union 1x1 outside */
aschiffler@6757
  1229
    for (dx = -1; dx < 2; dx++) {     
aschiffler@6757
  1230
        for (dy = -1; dy < 2; dy++) {
aschiffler@6757
  1231
            if ((dx != 0) || (dy != 0)) {
aschiffler@6757
  1232
                refRectA.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1233
                refRectA.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1234
                refRectA.w=1;
aschiffler@6757
  1235
                refRectA.h=1;
aschiffler@6757
  1236
                refRectB.x=SDLTest_RandomIntegerInRange(-1024, 1024) + dx*2048;
aschiffler@6757
  1237
                refRectB.y=SDLTest_RandomIntegerInRange(-1024, 1024) + dx*2048;
aschiffler@6757
  1238
                refRectB.w=1;
aschiffler@6757
  1239
                refRectB.h=1;
aschiffler@6757
  1240
                minx = (refRectA.x<refRectB.x) ? refRectA.x : refRectB.x;
aschiffler@6757
  1241
                maxx = (refRectA.x>refRectB.x) ? refRectA.x : refRectB.x;
aschiffler@6757
  1242
                miny = (refRectA.y<refRectB.y) ? refRectA.y : refRectB.y;
aschiffler@6757
  1243
                maxy = (refRectA.y>refRectB.y) ? refRectA.y : refRectB.y;                
aschiffler@6757
  1244
                expectedResult.x = minx;
aschiffler@6757
  1245
                expectedResult.y = miny;
aschiffler@6757
  1246
                expectedResult.w = maxx - minx + 1;
aschiffler@6757
  1247
                expectedResult.h = maxy - miny + 1;
aschiffler@6757
  1248
                rectA = refRectA;
aschiffler@6757
  1249
                rectB = refRectB;
aschiffler@6757
  1250
                SDL_UnionRect(&rectA, &rectB, &result);
aschiffler@6757
  1251
                _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
aschiffler@6757
  1252
            }
aschiffler@6757
  1253
        }
aschiffler@6757
  1254
    }
aschiffler@6757
  1255
aschiffler@6757
  1256
    /* Union outside overlap */
aschiffler@6757
  1257
    for (dx = -1; dx < 2; dx++) {     
aschiffler@6757
  1258
        for (dy = -1; dy < 2; dy++) {
aschiffler@6757
  1259
            if ((dx != 0) || (dy != 0)) {
aschiffler@6757
  1260
                refRectA.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1261
                refRectA.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1262
                refRectA.w=SDLTest_RandomIntegerInRange(256, 512);
aschiffler@6757
  1263
                refRectA.h=SDLTest_RandomIntegerInRange(256, 512);
aschiffler@6757
  1264
                refRectB.x=refRectA.x + 1 + dx*2;
aschiffler@6757
  1265
                refRectB.y=refRectA.y + 1 + dy*2;
aschiffler@6757
  1266
                refRectB.w=refRectA.w - 2;
aschiffler@6757
  1267
                refRectB.h=refRectA.h - 2;
aschiffler@6757
  1268
                expectedResult = refRectA;
aschiffler@6757
  1269
                if (dx == -1) expectedResult.x--;
aschiffler@6757
  1270
                if (dy == -1) expectedResult.y--;
aschiffler@6757
  1271
                if ((dx == 1) || (dx == -1)) expectedResult.w++;
aschiffler@6757
  1272
                if ((dy == 1) || (dy == -1)) expectedResult.h++;
aschiffler@6757
  1273
                rectA = refRectA;
aschiffler@6757
  1274
                rectB = refRectB;
aschiffler@6757
  1275
                SDL_UnionRect(&rectA, &rectB, &result);
aschiffler@6757
  1276
                _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
aschiffler@6757
  1277
            }
aschiffler@6757
  1278
        }
aschiffler@6757
  1279
    }
aschiffler@6757
  1280
aschiffler@6757
  1281
	return TEST_COMPLETED;
aschiffler@6757
  1282
}
aschiffler@6757
  1283
aschiffler@6757
  1284
/*!
aschiffler@6757
  1285
 * \brief Tests SDL_UnionRect() where rect A or rect B are empty
aschiffler@6757
  1286
 *
aschiffler@6757
  1287
 * \sa
aschiffler@6757
  1288
 * http://wiki.libsdl.org/moin.cgi/SDL_UnionRect
aschiffler@6757
  1289
 */
aschiffler@6757
  1290
int rect_testUnionRectEmpty(void *arg)
aschiffler@6757
  1291
{
aschiffler@6757
  1292
    SDL_Rect refRectA, refRectB;
aschiffler@6757
  1293
    SDL_Rect rectA, rectB;
aschiffler@6757
  1294
    SDL_Rect expectedResult;
aschiffler@6757
  1295
    SDL_Rect result;
aschiffler@6757
  1296
aschiffler@6757
  1297
    /* A empty */    
aschiffler@6757
  1298
    refRectA.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1299
    refRectA.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1300
    refRectA.w=0;
aschiffler@6757
  1301
    refRectA.h=0;
aschiffler@6757
  1302
    refRectB.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1303
    refRectB.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1304
    refRectB.w=SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
  1305
    refRectB.h=SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
  1306
    expectedResult = refRectB;
aschiffler@6757
  1307
    rectA = refRectA;
aschiffler@6757
  1308
    rectB = refRectB;
aschiffler@6757
  1309
    SDL_UnionRect(&rectA, &rectB, &result);
aschiffler@6757
  1310
    _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
aschiffler@6757
  1311
    
aschiffler@6757
  1312
    /* B empty */    
aschiffler@6757
  1313
    refRectA.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1314
    refRectA.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1315
    refRectA.w=SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
  1316
    refRectA.h=SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
  1317
    refRectB.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1318
    refRectB.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1319
    refRectB.w=0;
aschiffler@6757
  1320
    refRectB.h=0;
aschiffler@6757
  1321
    expectedResult = refRectA;
aschiffler@6757
  1322
    rectA = refRectA;
aschiffler@6757
  1323
    rectB = refRectB;
aschiffler@6757
  1324
    SDL_UnionRect(&rectA, &rectB, &result);
aschiffler@6757
  1325
    _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
aschiffler@6757
  1326
aschiffler@6757
  1327
    /* A and B empty */    
aschiffler@6757
  1328
    refRectA.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1329
    refRectA.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1330
    refRectA.w=0;
aschiffler@6757
  1331
    refRectA.h=0;
aschiffler@6757
  1332
    refRectB.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1333
    refRectB.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1334
    refRectB.w=0;
aschiffler@6757
  1335
    refRectB.h=0;
aschiffler@6757
  1336
    result.x=0;
aschiffler@6757
  1337
    result.y=0;
aschiffler@6757
  1338
    result.w=0;
aschiffler@6757
  1339
    result.h=0;
aschiffler@6757
  1340
    expectedResult = result;
aschiffler@6757
  1341
    rectA = refRectA;
aschiffler@6757
  1342
    rectB = refRectB;
aschiffler@6757
  1343
    SDL_UnionRect(&rectA, &rectB, &result);
aschiffler@6757
  1344
    _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
aschiffler@6757
  1345
aschiffler@6757
  1346
	return TEST_COMPLETED;
aschiffler@6757
  1347
}
aschiffler@6757
  1348
aschiffler@6757
  1349
/*!
aschiffler@6757
  1350
 * \brief Tests SDL_UnionRect() where rect B is inside rect A
aschiffler@6757
  1351
 *
aschiffler@6757
  1352
 * \sa
aschiffler@6757
  1353
 * http://wiki.libsdl.org/moin.cgi/SDL_UnionRect
aschiffler@6757
  1354
 */
aschiffler@6757
  1355
int rect_testUnionRectInside(void *arg)
aschiffler@6757
  1356
{
aschiffler@6757
  1357
    SDL_Rect refRectA, refRectB;
aschiffler@6757
  1358
    SDL_Rect rectA, rectB;
aschiffler@6757
  1359
    SDL_Rect expectedResult;
aschiffler@6757
  1360
    SDL_Rect result;
aschiffler@6757
  1361
    int dx, dy;
aschiffler@6757
  1362
    
aschiffler@6757
  1363
    /* Union 1x1 with itself */
aschiffler@6757
  1364
    refRectA.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1365
    refRectA.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1366
    refRectA.w=1;
aschiffler@6757
  1367
    refRectA.h=1;
aschiffler@6757
  1368
    expectedResult = refRectA;
aschiffler@6757
  1369
    rectA = refRectA;
aschiffler@6757
  1370
    SDL_UnionRect(&rectA, &rectA, &result);
aschiffler@6757
  1371
    _validateUnionRectResults(&rectA, &rectA, &refRectA, &refRectA, &result, &expectedResult);
aschiffler@6757
  1372
aschiffler@6757
  1373
    /* Union 1x1 somewhere inside */
aschiffler@6757
  1374
    refRectA.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1375
    refRectA.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1376
    refRectA.w=SDLTest_RandomIntegerInRange(256, 1024);
aschiffler@6757
  1377
    refRectA.h=SDLTest_RandomIntegerInRange(256, 1024);
aschiffler@6757
  1378
    refRectB.x=refRectA.x + 1 + SDLTest_RandomIntegerInRange(1, refRectA.w - 2);
aschiffler@6757
  1379
    refRectB.y=refRectA.y + 1 + SDLTest_RandomIntegerInRange(1, refRectA.h - 2);
aschiffler@6757
  1380
    refRectB.w=1;
aschiffler@6757
  1381
    refRectB.h=1;
aschiffler@6757
  1382
    expectedResult = refRectA;
aschiffler@6757
  1383
    rectA = refRectA;
aschiffler@6757
  1384
    rectB = refRectB;
aschiffler@6757
  1385
    SDL_UnionRect(&rectA, &rectB, &result);
aschiffler@6757
  1386
    _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
aschiffler@6757
  1387
aschiffler@6757
  1388
    /* Union inside with edges modified */
aschiffler@6757
  1389
    for (dx = -1; dx < 2; dx++) {     
aschiffler@6757
  1390
        for (dy = -1; dy < 2; dy++) {
aschiffler@6757
  1391
            if ((dx != 0) || (dy != 0)) {
aschiffler@6757
  1392
                refRectA.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1393
                refRectA.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1394
                refRectA.w=SDLTest_RandomIntegerInRange(256, 1024);
aschiffler@6757
  1395
                refRectA.h=SDLTest_RandomIntegerInRange(256, 1024);
aschiffler@6757
  1396
                refRectB = refRectA;
aschiffler@6757
  1397
                if (dx == -1) refRectB.x++;
aschiffler@6757
  1398
                if ((dx == 1) || (dx == -1)) refRectB.w--;
aschiffler@6757
  1399
                if (dy == -1) refRectB.y++;
aschiffler@6757
  1400
                if ((dy == 1) || (dy == -1)) refRectB.h--;                
aschiffler@6757
  1401
                expectedResult = refRectA;
aschiffler@6757
  1402
                rectA = refRectA;
aschiffler@6757
  1403
                rectB = refRectB;
aschiffler@6757
  1404
                SDL_UnionRect(&rectA, &rectB, &result);
aschiffler@6757
  1405
                _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
aschiffler@6757
  1406
            }
aschiffler@6757
  1407
        }
aschiffler@6757
  1408
    }
aschiffler@6757
  1409
aschiffler@6757
  1410
	return TEST_COMPLETED;
aschiffler@6757
  1411
}
aschiffler@6757
  1412
aschiffler@6757
  1413
/*!
aschiffler@6757
  1414
 * \brief Negative tests against SDL_UnionRect() with invalid parameters
aschiffler@6757
  1415
 *
aschiffler@6757
  1416
 * \sa
aschiffler@6757
  1417
 * http://wiki.libsdl.org/moin.cgi/SDL_UnionRect
aschiffler@6757
  1418
 */
aschiffler@6757
  1419
int rect_testUnionRectParam(void *arg)
aschiffler@6757
  1420
{
aschiffler@6757
  1421
    SDL_Rect rectA, rectB;
aschiffler@6757
  1422
    SDL_Rect result;
aschiffler@6757
  1423
aschiffler@6757
  1424
    // invalid parameter combinations
aschiffler@6757
  1425
    SDL_UnionRect((SDL_Rect *)NULL, &rectB, &result);
aschiffler@6757
  1426
    SDLTest_AssertPass("Check that function returns when 1st parameter is NULL"); 
aschiffler@6757
  1427
    SDL_UnionRect(&rectA, (SDL_Rect *)NULL, &result);
aschiffler@6757
  1428
    SDLTest_AssertPass("Check that function returns  when 2nd parameter is NULL"); 
aschiffler@6757
  1429
    SDL_UnionRect(&rectA, &rectB, (SDL_Rect *)NULL);
aschiffler@6757
  1430
    SDLTest_AssertPass("Check that function returns  when 3rd parameter is NULL"); 
aschiffler@6757
  1431
    SDL_UnionRect((SDL_Rect *)NULL, &rectB, (SDL_Rect *)NULL);
aschiffler@6757
  1432
    SDLTest_AssertPass("Check that function returns  when 1st and 3rd parameter are NULL"); 
aschiffler@6757
  1433
    SDL_UnionRect(&rectA, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
aschiffler@6757
  1434
    SDLTest_AssertPass("Check that function returns  when 2nd and 3rd parameter are NULL"); 
aschiffler@6757
  1435
    SDL_UnionRect((SDL_Rect *)NULL, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
aschiffler@6757
  1436
    SDLTest_AssertPass("Check that function returns  when all parameters are NULL"); 
aschiffler@6757
  1437
aschiffler@6757
  1438
	return TEST_COMPLETED;
aschiffler@6757
  1439
}
aschiffler@6757
  1440
aschiffler@6757
  1441
/*!
aschiffler@6757
  1442
 * \brief Tests SDL_RectEmpty() with various inputs
aschiffler@6757
  1443
 *
aschiffler@6757
  1444
 * \sa
aschiffler@6757
  1445
 * http://wiki.libsdl.org/moin.cgi/SDL_RectEmpty
aschiffler@6757
  1446
 */
aschiffler@6757
  1447
int rect_testRectEmpty(void *arg)
aschiffler@6757
  1448
{
aschiffler@6757
  1449
    SDL_Rect refRect;
aschiffler@6757
  1450
    SDL_Rect rect;
aschiffler@6757
  1451
    SDL_bool expectedResult;
aschiffler@6757
  1452
    SDL_bool result;
aschiffler@6757
  1453
    int w, h;
aschiffler@6757
  1454
aschiffler@6757
  1455
    // Non-empty case
aschiffler@6757
  1456
    refRect.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1457
    refRect.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1458
    refRect.w=SDLTest_RandomIntegerInRange(256, 1024);
aschiffler@6757
  1459
    refRect.h=SDLTest_RandomIntegerInRange(256, 1024);
aschiffler@6757
  1460
    expectedResult = SDL_FALSE;
aschiffler@6757
  1461
    rect = refRect;
aschiffler@6757
  1462
    result = (SDL_bool)SDL_RectEmpty((const SDL_Rect *)&rect);
aschiffler@6757
  1463
    _validateRectEmptyResults(result, expectedResult, &rect, &refRect);
aschiffler@6757
  1464
    
aschiffler@6757
  1465
    // Empty case
aschiffler@6757
  1466
    for (w=-1; w<2; w++) {
aschiffler@6757
  1467
        for (h=-1; h<2; h++) {
aschiffler@6757
  1468
            if ((w != 1) || (h != 1)) {
aschiffler@6757
  1469
                refRect.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1470
                refRect.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1471
                refRect.w=w;
aschiffler@6757
  1472
                refRect.h=h;
aschiffler@6757
  1473
                expectedResult = SDL_TRUE;
aschiffler@6757
  1474
                rect = refRect;
aschiffler@6757
  1475
                result = (SDL_bool)SDL_RectEmpty((const SDL_Rect *)&rect);
aschiffler@6757
  1476
                _validateRectEmptyResults(result, expectedResult, &rect, &refRect);
aschiffler@6757
  1477
            }
aschiffler@6757
  1478
        }
aschiffler@6757
  1479
    }
aschiffler@6757
  1480
aschiffler@6757
  1481
	return TEST_COMPLETED;
aschiffler@6757
  1482
}
aschiffler@6757
  1483
aschiffler@6757
  1484
/*!
aschiffler@6757
  1485
 * \brief Negative tests against SDL_RectEmpty() with invalid parameters
aschiffler@6757
  1486
 *
aschiffler@6757
  1487
 * \sa
aschiffler@6757
  1488
 * http://wiki.libsdl.org/moin.cgi/SDL_RectEmpty
aschiffler@6757
  1489
 */
aschiffler@6757
  1490
int rect_testRectEmptyParam(void *arg)
aschiffler@6757
  1491
{
aschiffler@6757
  1492
    SDL_bool result;
aschiffler@6757
  1493
aschiffler@6757
  1494
    // invalid parameter combinations
aschiffler@6757
  1495
    result = (SDL_bool)SDL_RectEmpty((const SDL_Rect *)NULL);
aschiffler@6757
  1496
    SDLTest_AssertCheck(result == SDL_TRUE, "Check that function returns TRUE when 1st parameter is NULL"); 
aschiffler@6757
  1497
aschiffler@6757
  1498
	return TEST_COMPLETED;
aschiffler@6757
  1499
}
aschiffler@6757
  1500
aschiffler@6757
  1501
/*!
aschiffler@6757
  1502
 * \brief Tests SDL_RectEquals() with various inputs
aschiffler@6757
  1503
 *
aschiffler@6757
  1504
 * \sa
aschiffler@6757
  1505
 * http://wiki.libsdl.org/moin.cgi/SDL_RectEquals
aschiffler@6757
  1506
 */
aschiffler@6757
  1507
int rect_testRectEquals(void *arg)
aschiffler@6757
  1508
{
aschiffler@6757
  1509
    SDL_Rect refRectA;
aschiffler@6757
  1510
    SDL_Rect refRectB;
aschiffler@6757
  1511
    SDL_Rect rectA;
aschiffler@6757
  1512
    SDL_Rect rectB;
aschiffler@6757
  1513
    SDL_bool expectedResult;
aschiffler@6757
  1514
    SDL_bool result;
aschiffler@6757
  1515
aschiffler@6757
  1516
    // Equals
aschiffler@6757
  1517
    refRectA.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1518
    refRectA.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1519
    refRectA.w=SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
  1520
    refRectA.h=SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
  1521
    refRectB = refRectA;    
aschiffler@6757
  1522
    expectedResult = SDL_TRUE;
aschiffler@6757
  1523
    rectA = refRectA;
aschiffler@6757
  1524
    rectB = refRectB;
aschiffler@6757
  1525
    result = (SDL_bool)SDL_RectEquals((const SDL_Rect *)&rectA, (const SDL_Rect *)&rectB);
aschiffler@6757
  1526
    _validateRectEqualsResults(result, expectedResult, &rectA, &rectB, &refRectA, &refRectB);
aschiffler@6757
  1527
aschiffler@6757
  1528
	return TEST_COMPLETED;
aschiffler@6757
  1529
}
aschiffler@6757
  1530
aschiffler@6757
  1531
/*!
aschiffler@6757
  1532
 * \brief Negative tests against SDL_RectEquals() with invalid parameters
aschiffler@6757
  1533
 *
aschiffler@6757
  1534
 * \sa
aschiffler@6757
  1535
 * http://wiki.libsdl.org/moin.cgi/SDL_RectEquals
aschiffler@6757
  1536
 */
aschiffler@6757
  1537
int rect_testRectEqualsParam(void *arg)
aschiffler@6757
  1538
{
aschiffler@6757
  1539
    SDL_Rect rectA;
aschiffler@6757
  1540
    SDL_Rect rectB;
aschiffler@6757
  1541
    SDL_bool result;
aschiffler@6757
  1542
aschiffler@6757
  1543
    /* data setup */
aschiffler@6757
  1544
    rectA.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1545
    rectA.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1546
    rectA.w=SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
  1547
    rectA.h=SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
  1548
    rectB.x=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1549
    rectB.y=SDLTest_RandomIntegerInRange(-1024, 1024);
aschiffler@6757
  1550
    rectB.w=SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
  1551
    rectB.h=SDLTest_RandomIntegerInRange(1, 1024);
aschiffler@6757
  1552
aschiffler@6757
  1553
    // invalid parameter combinations
aschiffler@6757
  1554
    result = (SDL_bool)SDL_RectEquals((const SDL_Rect *)NULL, (const SDL_Rect *)&rectB);
aschiffler@6757
  1555
    SDLTest_AssertCheck(result == SDL_FALSE, "Check that function returns SDL_FALSE when 1st parameter is NULL"); 
aschiffler@6757
  1556
    result = (SDL_bool)SDL_RectEquals((const SDL_Rect *)&rectA, (const SDL_Rect *)NULL);
aschiffler@6757
  1557
    SDLTest_AssertCheck(result == SDL_FALSE, "Check that function returns SDL_FALSE when 2nd parameter is NULL"); 
aschiffler@6757
  1558
    result = (SDL_bool)SDL_RectEquals((const SDL_Rect *)NULL, (const SDL_Rect *)NULL);
aschiffler@6757
  1559
    SDLTest_AssertCheck(result == SDL_FALSE, "Check that function returns SDL_FALSE when 1st and 2nd parameter are NULL"); 
aschiffler@6757
  1560
aschiffler@6757
  1561
	return TEST_COMPLETED;
aschiffler@6757
  1562
}
aschiffler@6757
  1563
aschiffler@6757
  1564
/* ================= Test References ================== */
aschiffler@6757
  1565
aschiffler@6757
  1566
/* Rect test cases */
aschiffler@6757
  1567
aschiffler@6757
  1568
/* SDL_IntersectRectAndLine */
aschiffler@6757
  1569
static const SDLTest_TestCaseReference rectTest1 =
aschiffler@6757
  1570
		{ (SDLTest_TestCaseFp)rect_testIntersectRectAndLine,"rect_testIntersectRectAndLine",  "Tests SDL_IntersectRectAndLine clipping cases", TEST_ENABLED };
aschiffler@6757
  1571
aschiffler@6757
  1572
static const SDLTest_TestCaseReference rectTest2 =
aschiffler@6757
  1573
		{ (SDLTest_TestCaseFp)rect_testIntersectRectAndLineInside, "rect_testIntersectRectAndLineInside", "Tests SDL_IntersectRectAndLine with line fully contained in rect", TEST_ENABLED };
aschiffler@6757
  1574
aschiffler@6757
  1575
static const SDLTest_TestCaseReference rectTest3 =
aschiffler@6757
  1576
		{ (SDLTest_TestCaseFp)rect_testIntersectRectAndLineOutside, "rect_testIntersectRectAndLineOutside", "Tests SDL_IntersectRectAndLine with line fully outside of rect", TEST_ENABLED };
aschiffler@6757
  1577
aschiffler@6757
  1578
static const SDLTest_TestCaseReference rectTest4 =
aschiffler@6757
  1579
		{ (SDLTest_TestCaseFp)rect_testIntersectRectAndLineEmpty, "rect_testIntersectRectAndLineEmpty", "Tests SDL_IntersectRectAndLine with empty rectangle ", TEST_ENABLED };
aschiffler@6757
  1580
aschiffler@6757
  1581
static const SDLTest_TestCaseReference rectTest5 =
aschiffler@6757
  1582
		{ (SDLTest_TestCaseFp)rect_testIntersectRectAndLineParam, "rect_testIntersectRectAndLineParam", "Negative tests against SDL_IntersectRectAndLine with invalid parameters", TEST_ENABLED };
aschiffler@6757
  1583
aschiffler@6757
  1584
/* SDL_IntersectRect */
aschiffler@6757
  1585
static const SDLTest_TestCaseReference rectTest6 =
aschiffler@6757
  1586
		{ (SDLTest_TestCaseFp)rect_testIntersectRectInside, "rect_testIntersectRectInside", "Tests SDL_IntersectRect with B fully contained in A", TEST_ENABLED };
aschiffler@6757
  1587
aschiffler@6757
  1588
static const SDLTest_TestCaseReference rectTest7 =
aschiffler@6757
  1589
		{ (SDLTest_TestCaseFp)rect_testIntersectRectOutside, "rect_testIntersectRectOutside", "Tests SDL_IntersectRect with B fully outside of A", TEST_ENABLED };
aschiffler@6757
  1590
aschiffler@6757
  1591
static const SDLTest_TestCaseReference rectTest8 =
aschiffler@6757
  1592
		{ (SDLTest_TestCaseFp)rect_testIntersectRectPartial, "rect_testIntersectRectPartial", "Tests SDL_IntersectRect with B partially intersecting A", TEST_ENABLED };
aschiffler@6757
  1593
aschiffler@6757
  1594
static const SDLTest_TestCaseReference rectTest9 =
aschiffler@6757
  1595
		{ (SDLTest_TestCaseFp)rect_testIntersectRectPoint, "rect_testIntersectRectPoint", "Tests SDL_IntersectRect with 1x1 sized rectangles", TEST_ENABLED };
aschiffler@6757
  1596
aschiffler@6757
  1597
static const SDLTest_TestCaseReference rectTest10 =
aschiffler@6757
  1598
		{ (SDLTest_TestCaseFp)rect_testIntersectRectEmpty, "rect_testIntersectRectEmpty", "Tests SDL_IntersectRect with empty rectangles", TEST_ENABLED };
aschiffler@6757
  1599
aschiffler@6757
  1600
static const SDLTest_TestCaseReference rectTest11 =
aschiffler@6757
  1601
		{ (SDLTest_TestCaseFp)rect_testIntersectRectParam, "rect_testIntersectRectParam", "Negative tests against SDL_IntersectRect with invalid parameters", TEST_ENABLED };
aschiffler@6757
  1602
aschiffler@6757
  1603
/* SDL_HasIntersection */
aschiffler@6757
  1604
static const SDLTest_TestCaseReference rectTest12 =
aschiffler@6757
  1605
		{ (SDLTest_TestCaseFp)rect_testHasIntersectionInside, "rect_testHasIntersectionInside", "Tests SDL_HasIntersection with B fully contained in A", TEST_ENABLED };
aschiffler@6757
  1606
aschiffler@6757
  1607
static const SDLTest_TestCaseReference rectTest13 =
aschiffler@6757
  1608
		{ (SDLTest_TestCaseFp)rect_testHasIntersectionOutside, "rect_testHasIntersectionOutside", "Tests SDL_HasIntersection with B fully outside of A", TEST_ENABLED };
aschiffler@6757
  1609
aschiffler@6757
  1610
static const SDLTest_TestCaseReference rectTest14 =
aschiffler@6757
  1611
		{ (SDLTest_TestCaseFp)rect_testHasIntersectionPartial,"rect_testHasIntersectionPartial",  "Tests SDL_HasIntersection with B partially intersecting A", TEST_ENABLED };
aschiffler@6757
  1612
aschiffler@6757
  1613
static const SDLTest_TestCaseReference rectTest15 =
aschiffler@6757
  1614
		{ (SDLTest_TestCaseFp)rect_testHasIntersectionPoint, "rect_testHasIntersectionPoint", "Tests SDL_HasIntersection with 1x1 sized rectangles", TEST_ENABLED };
aschiffler@6757
  1615
aschiffler@6757
  1616
static const SDLTest_TestCaseReference rectTest16 =
aschiffler@6757
  1617
		{ (SDLTest_TestCaseFp)rect_testHasIntersectionEmpty, "rect_testHasIntersectionEmpty", "Tests SDL_HasIntersection with empty rectangles", TEST_ENABLED };
aschiffler@6757
  1618
aschiffler@6757
  1619
static const SDLTest_TestCaseReference rectTest17 =
aschiffler@6757
  1620
		{ (SDLTest_TestCaseFp)rect_testHasIntersectionParam, "rect_testHasIntersectionParam", "Negative tests against SDL_HasIntersection with invalid parameters", TEST_ENABLED };
aschiffler@6757
  1621
aschiffler@6757
  1622
/* SDL_EnclosePoints */
aschiffler@6757
  1623
static const SDLTest_TestCaseReference rectTest18 =
aschiffler@6757
  1624
		{ (SDLTest_TestCaseFp)rect_testEnclosePoints, "rect_testEnclosePoints", "Tests SDL_EnclosePoints without clipping", TEST_ENABLED };
aschiffler@6757
  1625
aschiffler@6757
  1626
static const SDLTest_TestCaseReference rectTest19 =
aschiffler@6757
  1627
		{ (SDLTest_TestCaseFp)rect_testEnclosePointsWithClipping, "rect_testEnclosePointsWithClipping", "Tests SDL_EnclosePoints with clipping", TEST_ENABLED };
aschiffler@6757
  1628
aschiffler@6757
  1629
static const SDLTest_TestCaseReference rectTest20 =
aschiffler@6757
  1630
		{ (SDLTest_TestCaseFp)rect_testEnclosePointsRepeatedInput, "rect_testEnclosePointsRepeatedInput", "Tests SDL_EnclosePoints with repeated input", TEST_ENABLED };
aschiffler@6757
  1631
aschiffler@6757
  1632
static const SDLTest_TestCaseReference rectTest21 =
aschiffler@6757
  1633
		{ (SDLTest_TestCaseFp)rect_testEnclosePointsParam, "rect_testEnclosePointsParam", "Negative tests against SDL_EnclosePoints with invalid parameters", TEST_ENABLED };
aschiffler@6757
  1634
aschiffler@6757
  1635
/* SDL_UnionRect */
aschiffler@6757
  1636
static const SDLTest_TestCaseReference rectTest22 =
aschiffler@6757
  1637
		{ (SDLTest_TestCaseFp)rect_testUnionRectInside, "rect_testUnionRectInside", "Tests SDL_UnionRect where rect B is inside rect A", TEST_ENABLED };
aschiffler@6757
  1638
aschiffler@6757
  1639
static const SDLTest_TestCaseReference rectTest23 =
aschiffler@6757
  1640
		{ (SDLTest_TestCaseFp)rect_testUnionRectOutside, "rect_testUnionRectOutside", "Tests SDL_UnionRect where rect B is outside rect A", TEST_ENABLED };
aschiffler@6757
  1641
aschiffler@6757
  1642
static const SDLTest_TestCaseReference rectTest24 =
aschiffler@6757
  1643
		{ (SDLTest_TestCaseFp)rect_testUnionRectEmpty, "rect_testUnionRectEmpty", "Tests SDL_UnionRect where rect A or rect B are empty", TEST_ENABLED };
aschiffler@6757
  1644
aschiffler@6757
  1645
static const SDLTest_TestCaseReference rectTest25 =
aschiffler@6757
  1646
		{ (SDLTest_TestCaseFp)rect_testUnionRectParam, "rect_testUnionRectParam", "Negative tests against SDL_UnionRect with invalid parameters", TEST_ENABLED };
aschiffler@6757
  1647
aschiffler@6757
  1648
/* SDL_RectEmpty */
aschiffler@6757
  1649
static const SDLTest_TestCaseReference rectTest26 =
aschiffler@6757
  1650
		{ (SDLTest_TestCaseFp)rect_testRectEmpty, "rect_testRectEmpty", "Tests SDL_RectEmpty with various inputs", TEST_ENABLED };
aschiffler@6757
  1651
aschiffler@6757
  1652
static const SDLTest_TestCaseReference rectTest27 =
aschiffler@6757
  1653
		{ (SDLTest_TestCaseFp)rect_testRectEmptyParam, "rect_testRectEmptyParam", "Negative tests against SDL_RectEmpty with invalid parameters", TEST_ENABLED };
aschiffler@6757
  1654
aschiffler@6757
  1655
/* SDL_RectEquals */
aschiffler@6757
  1656
aschiffler@6757
  1657
static const SDLTest_TestCaseReference rectTest28 =
aschiffler@6757
  1658
		{ (SDLTest_TestCaseFp)rect_testRectEquals, "rect_testRectEquals", "Tests SDL_RectEquals with various inputs", TEST_ENABLED };
aschiffler@6757
  1659
aschiffler@6757
  1660
static const SDLTest_TestCaseReference rectTest29 =
aschiffler@6757
  1661
		{ (SDLTest_TestCaseFp)rect_testRectEqualsParam, "rect_testRectEqualsParam", "Negative tests against SDL_RectEquals with invalid parameters", TEST_ENABLED };
aschiffler@6757
  1662
aschiffler@6757
  1663
aschiffler@6757
  1664
/*!
aschiffler@6757
  1665
 * \brief Sequence of Rect test cases; functions that handle simple rectangles including overlaps and merges.
aschiffler@6757
  1666
 *
aschiffler@6757
  1667
 * \sa
aschiffler@6757
  1668
 * http://wiki.libsdl.org/moin.cgi/CategoryRect
aschiffler@6757
  1669
 */
aschiffler@6757
  1670
static const SDLTest_TestCaseReference *rectTests[] =  {
aschiffler@6757
  1671
	&rectTest1, &rectTest2, &rectTest3, &rectTest4, &rectTest5, &rectTest6, &rectTest7, &rectTest8, &rectTest9, &rectTest10, &rectTest11, &rectTest12, &rectTest13, &rectTest14, 
aschiffler@6757
  1672
	&rectTest15, &rectTest16, &rectTest17, &rectTest18, &rectTest19, &rectTest20, &rectTest21, &rectTest22, &rectTest23, &rectTest24, &rectTest25, &rectTest26, &rectTest27,
aschiffler@6757
  1673
	&rectTest28, &rectTest29, NULL
aschiffler@6757
  1674
};
aschiffler@6757
  1675
aschiffler@6757
  1676
aschiffler@6757
  1677
/* Rect test suite (global) */
aschiffler@6757
  1678
SDLTest_TestSuiteReference rectTestSuite = {
aschiffler@6757
  1679
	"Rect",
aschiffler@6757
  1680
	NULL,
aschiffler@6757
  1681
	rectTests,
aschiffler@6757
  1682
	NULL
aschiffler@6757
  1683
};