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