This repository has been archived by the owner on Feb 11, 2021. It is now read-only.
testautomation_pixels.c
1
2
3
4
5
6
7
8
9
10
11
12
13
/**
* Pixels test suite
*/
#include <stdio.h>
#include "SDL.h"
#include "SDL_test.h"
/* Test case functions */
/* Definition of all RGB formats used to test pixel conversions */
const int _numRGBPixelFormats = 30;
14
Uint32 _RGBPixelFormats[] =
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
{
SDL_PIXELFORMAT_INDEX1LSB,
SDL_PIXELFORMAT_INDEX1MSB,
SDL_PIXELFORMAT_INDEX4LSB,
SDL_PIXELFORMAT_INDEX4MSB,
SDL_PIXELFORMAT_INDEX8,
SDL_PIXELFORMAT_RGB332,
SDL_PIXELFORMAT_RGB444,
SDL_PIXELFORMAT_RGB555,
SDL_PIXELFORMAT_BGR555,
SDL_PIXELFORMAT_ARGB4444,
SDL_PIXELFORMAT_RGBA4444,
SDL_PIXELFORMAT_ABGR4444,
SDL_PIXELFORMAT_BGRA4444,
SDL_PIXELFORMAT_ARGB1555,
SDL_PIXELFORMAT_RGBA5551,
SDL_PIXELFORMAT_ABGR1555,
SDL_PIXELFORMAT_BGRA5551,
SDL_PIXELFORMAT_RGB565,
SDL_PIXELFORMAT_BGR565,
SDL_PIXELFORMAT_RGB24,
SDL_PIXELFORMAT_BGR24,
SDL_PIXELFORMAT_RGB888,
SDL_PIXELFORMAT_RGBX8888,
SDL_PIXELFORMAT_BGR888,
SDL_PIXELFORMAT_BGRX8888,
SDL_PIXELFORMAT_ARGB8888,
SDL_PIXELFORMAT_RGBA8888,
SDL_PIXELFORMAT_ABGR8888,
SDL_PIXELFORMAT_BGRA8888,
SDL_PIXELFORMAT_ARGB2101010
};
47
char* _RGBPixelFormatsVerbose[] =
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
{
"SDL_PIXELFORMAT_INDEX1LSB",
"SDL_PIXELFORMAT_INDEX1MSB",
"SDL_PIXELFORMAT_INDEX4LSB",
"SDL_PIXELFORMAT_INDEX4MSB",
"SDL_PIXELFORMAT_INDEX8",
"SDL_PIXELFORMAT_RGB332",
"SDL_PIXELFORMAT_RGB444",
"SDL_PIXELFORMAT_RGB555",
"SDL_PIXELFORMAT_BGR555",
"SDL_PIXELFORMAT_ARGB4444",
"SDL_PIXELFORMAT_RGBA4444",
"SDL_PIXELFORMAT_ABGR4444",
"SDL_PIXELFORMAT_BGRA4444",
"SDL_PIXELFORMAT_ARGB1555",
"SDL_PIXELFORMAT_RGBA5551",
"SDL_PIXELFORMAT_ABGR1555",
"SDL_PIXELFORMAT_BGRA5551",
"SDL_PIXELFORMAT_RGB565",
"SDL_PIXELFORMAT_BGR565",
"SDL_PIXELFORMAT_RGB24",
"SDL_PIXELFORMAT_BGR24",
"SDL_PIXELFORMAT_RGB888",
"SDL_PIXELFORMAT_RGBX8888",
"SDL_PIXELFORMAT_BGR888",
"SDL_PIXELFORMAT_BGRX8888",
"SDL_PIXELFORMAT_ARGB8888",
"SDL_PIXELFORMAT_RGBA8888",
"SDL_PIXELFORMAT_ABGR8888",
"SDL_PIXELFORMAT_BGRA8888",
"SDL_PIXELFORMAT_ARGB2101010"
};
/* Definition of all Non-RGB formats used to test pixel conversions */
const int _numNonRGBPixelFormats = 5;
83
Uint32 _nonRGBPixelFormats[] =
84
85
86
87
88
{
SDL_PIXELFORMAT_YV12,
SDL_PIXELFORMAT_IYUV,
SDL_PIXELFORMAT_YUY2,
SDL_PIXELFORMAT_UYVY,
89
SDL_PIXELFORMAT_YVYU
91
char* _nonRGBPixelFormatsVerbose[] =
92
93
94
95
96
{
"SDL_PIXELFORMAT_YV12",
"SDL_PIXELFORMAT_IYUV",
"SDL_PIXELFORMAT_YUY2",
"SDL_PIXELFORMAT_UYVY",
97
"SDL_PIXELFORMAT_YVYU"
100
101
/* Definition of some invalid formats for negative tests */
const int _numInvalidPixelFormats = 2;
102
Uint32 _invalidPixelFormats[] =
103
104
105
106
{
0xfffffffe,
0xffffffff
};
107
char* _invalidPixelFormatsVerbose[] =
108
109
110
111
112
{
"SDL_PIXELFORMAT_UNKNOWN",
"SDL_PIXELFORMAT_UNKNOWN"
};
113
114
115
116
/* Test case functions */
/**
* @brief Call to SDL_AllocFormat and SDL_FreeFormat
117
118
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_AllocFormat
119
* @sa http://wiki.libsdl.org/moin.fcg/SDL_FreeFormat
120
121
122
123
*/
int
pixels_allocFreeFormat(void *arg)
{
124
const char *unknownFormat = "SDL_PIXELFORMAT_UNKNOWN";
125
const char *expectedError = "Parameter 'format' is invalid";
126
const char *error;
127
128
129
130
131
int i;
Uint32 format;
Uint32 masks;
SDL_PixelFormat* result;
132
133
134
/* Blank/unknown format */
format = 0;
SDLTest_Log("RGB Format: %s (%u)", unknownFormat, format);
136
137
138
/* Allocate format */
result = SDL_AllocFormat(format);
SDLTest_AssertPass("Call to SDL_AllocFormat()");
139
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
140
if (result != NULL) {
141
142
143
SDLTest_AssertCheck(result->format == format, "Verify value of result.format; expected: %u, got %u", format, result->format);
SDLTest_AssertCheck(result->BitsPerPixel == 0, "Verify value of result.BitsPerPixel; expected: 0, got %u", result->BitsPerPixel);
SDLTest_AssertCheck(result->BytesPerPixel == 0, "Verify value of result.BytesPerPixel; expected: 0, got %u", result->BytesPerPixel);
144
145
masks = result->Rmask | result->Gmask | result->Bmask | result->Amask;
SDLTest_AssertCheck(masks == 0, "Verify value of result.[RGBA]mask combined; expected: 0, got %u", masks);
147
148
/* Deallocate again */
SDL_FreeFormat(result);
149
SDLTest_AssertPass("Call to SDL_FreeFormat()");
152
153
154
155
/* RGB formats */
for (i = 0; i < _numRGBPixelFormats; i++) {
format = _RGBPixelFormats[i];
SDLTest_Log("RGB Format: %s (%u)", _RGBPixelFormatsVerbose[i], format);
157
158
159
/* Allocate format */
result = SDL_AllocFormat(format);
SDLTest_AssertPass("Call to SDL_AllocFormat()");
160
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
161
if (result != NULL) {
162
163
164
165
SDLTest_AssertCheck(result->format == format, "Verify value of result.format; expected: %u, got %u", format, result->format);
SDLTest_AssertCheck(result->BitsPerPixel > 0, "Verify value of result.BitsPerPixel; expected: >0, got %u", result->BitsPerPixel);
SDLTest_AssertCheck(result->BytesPerPixel > 0, "Verify value of result.BytesPerPixel; expected: >0, got %u", result->BytesPerPixel);
if (result->palette != NULL) {
166
167
168
masks = result->Rmask | result->Gmask | result->Bmask | result->Amask;
SDLTest_AssertCheck(masks > 0, "Verify value of result.[RGBA]mask combined; expected: >0, got %u", masks);
}
170
171
/* Deallocate again */
SDL_FreeFormat(result);
172
SDLTest_AssertPass("Call to SDL_FreeFormat()");
173
174
175
176
177
178
179
}
}
/* Non-RGB formats */
for (i = 0; i < _numNonRGBPixelFormats; i++) {
format = _nonRGBPixelFormats[i];
SDLTest_Log("non-RGB Format: %s (%u)", _nonRGBPixelFormatsVerbose[i], format);
181
182
183
/* Try to allocate format */
result = SDL_AllocFormat(format);
SDLTest_AssertPass("Call to SDL_AllocFormat()");
184
SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
187
/* Negative cases */
188
189
/* Invalid Formats */
190
191
192
193
194
195
for (i = 0; i < _numInvalidPixelFormats; i++) {
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
format = _invalidPixelFormats[i];
result = SDL_AllocFormat(format);
SDLTest_AssertPass("Call to SDL_AllocFormat(%u)", format);
196
SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
197
198
199
200
error = SDL_GetError();
SDLTest_AssertPass("Call to SDL_GetError()");
SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
if (error != NULL) {
201
SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0,
202
"Validate error message, expected: '%s', got: '%s'", expectedError, error);
206
207
208
/* Invalid free pointer */
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
209
210
SDL_FreeFormat(NULL);
SDLTest_AssertPass("Call to SDL_FreeFormat(NULL)");
211
212
213
214
error = SDL_GetError();
SDLTest_AssertPass("Call to SDL_GetError()");
SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
if (error != NULL) {
215
SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0,
216
217
"Validate error message, expected: '%s', got: '%s'", expectedError, error);
}
219
220
221
return TEST_COMPLETED;
}
222
223
224
225
226
227
228
229
230
/**
* @brief Call to SDL_GetPixelFormatName
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_GetPixelFormatName
*/
int
pixels_getPixelFormatName(void *arg)
{
const char *unknownFormat = "SDL_PIXELFORMAT_UNKNOWN";
231
const char *error;
232
233
234
235
236
237
238
int i;
Uint32 format;
char* result;
/* Blank/undefined format */
format = 0;
SDLTest_Log("RGB Format: %s (%u)", unknownFormat, format);
240
241
242
/* Get name of format */
result = (char *)SDL_GetPixelFormatName(format);
SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
243
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
244
245
if (result != NULL) {
SDLTest_AssertCheck(SDL_strlen(result) > 0, "Verify result is non-empty");
246
SDLTest_AssertCheck(SDL_strcmp(result, unknownFormat) == 0,
247
248
249
250
251
252
253
"Verify result text; expected: %s, got %s", unknownFormat, result);
}
/* RGB formats */
for (i = 0; i < _numRGBPixelFormats; i++) {
format = _RGBPixelFormats[i];
SDLTest_Log("RGB Format: %s (%u)", _RGBPixelFormatsVerbose[i], format);
255
256
257
/* Get name of format */
result = (char *)SDL_GetPixelFormatName(format);
SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
258
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
259
260
if (result != NULL) {
SDLTest_AssertCheck(SDL_strlen(result) > 0, "Verify result is non-empty");
261
SDLTest_AssertCheck(SDL_strcmp(result, _RGBPixelFormatsVerbose[i]) == 0,
262
263
264
265
266
267
268
269
"Verify result text; expected: %s, got %s", _RGBPixelFormatsVerbose[i], result);
}
}
/* Non-RGB formats */
for (i = 0; i < _numNonRGBPixelFormats; i++) {
format = _nonRGBPixelFormats[i];
SDLTest_Log("non-RGB Format: %s (%u)", _nonRGBPixelFormatsVerbose[i], format);
271
272
273
/* Get name of format */
result = (char *)SDL_GetPixelFormatName(format);
SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
274
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
275
276
if (result != NULL) {
SDLTest_AssertCheck(SDL_strlen(result) > 0, "Verify result is non-empty");
277
SDLTest_AssertCheck(SDL_strcmp(result, _nonRGBPixelFormatsVerbose[i]) == 0,
278
279
280
"Verify result text; expected: %s, got %s", _nonRGBPixelFormatsVerbose[i], result);
}
}
282
/* Negative cases */
283
284
/* Invalid Formats */
285
286
287
288
289
290
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
for (i = 0; i < _numInvalidPixelFormats; i++) {
format = _invalidPixelFormats[i];
result = (char *)SDL_GetPixelFormatName(format);
SDLTest_AssertPass("Call to SDL_GetPixelFormatName(%u)", format);
291
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
292
if (result != NULL) {
293
SDLTest_AssertCheck(SDL_strlen(result) > 0,
294
295
296
297
298
299
300
301
302
303
304
305
"Verify result is non-empty; got: %s", result);
SDLTest_AssertCheck(SDL_strcmp(result, _invalidPixelFormatsVerbose[i]) == 0,
"Validate name is UNKNOWN, expected: '%s', got: '%s'", _invalidPixelFormatsVerbose[i], result);
}
error = SDL_GetError();
SDLTest_AssertPass("Call to SDL_GetError()");
SDLTest_AssertCheck(error != NULL && SDL_strlen(error) == 0, "Validate that error message is empty");
}
return TEST_COMPLETED;
}
306
307
308
309
310
311
312
313
314
/**
* @brief Call to SDL_AllocPalette and SDL_FreePalette
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_AllocPalette
* @sa http://wiki.libsdl.org/moin.fcg/SDL_FreePalette
*/
int
pixels_allocFreePalette(void *arg)
{
315
316
const char *expectedError1 = "Parameter 'ncolors' is invalid";
const char *expectedError2 = "Parameter 'palette' is invalid";
317
const char *error;
318
319
320
321
322
323
int variation;
int i;
int ncolors;
SDL_Palette* result;
/* Allocate palette */
324
for (variation = 1; variation <= 3; variation++) {
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
switch (variation) {
/* Just one color */
case 1:
ncolors = 1;
break;
/* Two colors */
case 2:
ncolors = 2;
break;
/* More than two colors */
case 3:
ncolors = SDLTest_RandomIntegerInRange(8, 16);
break;
}
result = SDL_AllocPalette(ncolors);
SDLTest_AssertPass("Call to SDL_AllocPalette(%d)", ncolors);
342
SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
343
if (result != NULL) {
344
SDLTest_AssertCheck(result->ncolors == ncolors, "Verify value of result.ncolors; expected: %u, got %u", ncolors, result->ncolors);
345
346
347
348
if (result->ncolors > 0) {
SDLTest_AssertCheck(result->colors != NULL, "Verify value of result.colors is not NULL");
if (result->colors != NULL) {
for(i = 0; i < result->ncolors; i++) {
349
350
351
SDLTest_AssertCheck(result->colors[i].r == 255, "Verify value of result.colors[%d].r; expected: 255, got %u", i, result->colors[i].r);
SDLTest_AssertCheck(result->colors[i].g == 255, "Verify value of result.colors[%d].g; expected: 255, got %u", i, result->colors[i].g);
SDLTest_AssertCheck(result->colors[i].b == 255, "Verify value of result.colors[%d].b; expected: 255, got %u", i, result->colors[i].b);
356
357
/* Deallocate again */
SDL_FreePalette(result);
358
SDLTest_AssertPass("Call to SDL_FreePalette()");
359
360
361
362
}
}
/* Negative cases */
364
/* Invalid number of colors */
365
for (ncolors = 0; ncolors > -3; ncolors--) {
366
367
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
368
369
370
result = SDL_AllocPalette(ncolors);
SDLTest_AssertPass("Call to SDL_AllocPalette(%d)", ncolors);
SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
371
372
373
374
error = SDL_GetError();
SDLTest_AssertPass("Call to SDL_GetError()");
SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
if (error != NULL) {
375
SDLTest_AssertCheck(SDL_strcmp(error, expectedError1) == 0,
376
377
"Validate error message, expected: '%s', got: '%s'", expectedError1, error);
}
380
381
382
/* Invalid free pointer */
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
383
384
SDL_FreePalette(NULL);
SDLTest_AssertPass("Call to SDL_FreePalette(NULL)");
385
386
387
388
error = SDL_GetError();
SDLTest_AssertPass("Call to SDL_GetError()");
SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
if (error != NULL) {
389
SDLTest_AssertCheck(SDL_strcmp(error, expectedError2) == 0,
390
391
"Validate error message, expected: '%s', got: '%s'", expectedError2, error);
}
393
394
395
396
397
398
399
400
401
402
403
404
405
return TEST_COMPLETED;
}
/**
* @brief Call to SDL_CalculateGammaRamp
*
* @sa http://wiki.libsdl.org/moin.fcg/SDL_CalculateGammaRamp
*/
int
pixels_calcGammaRamp(void *arg)
{
const char *expectedError1 = "Parameter 'gamma' is invalid";
const char *expectedError2 = "Parameter 'ramp' is invalid";
406
const char *error;
407
408
409
410
411
412
413
414
415
416
417
float gamma;
Uint16 *ramp;
int variation;
int i;
int changed;
Uint16 magic = 0xbeef;
/* Allocate temp ramp array and fill with some value*/
ramp = (Uint16 *)SDL_malloc(256 * sizeof(Uint16));
SDLTest_AssertCheck(ramp != NULL, "Validate temp ramp array could be allocated");
if (ramp == NULL) return TEST_ABORTED;
419
420
421
422
/* Make call with different gamma values */
for (variation = 0; variation < 4; variation++) {
switch (variation) {
/* gamma = 0 all black */
423
case 0:
424
425
426
427
428
429
gamma = 0.0f;
break;
/* gamma = 1 identity */
case 1:
gamma = 1.0f;
break;
430
/* gamma = [0.2,0.8] normal range */
432
gamma = 0.2f + 0.8f * SDLTest_RandomUnitFloat();
434
/* gamma = >1.1 non-standard range */
436
gamma = 1.1f + SDLTest_RandomUnitFloat();
437
438
439
break;
}
440
/* Make call and check that values were updated */
441
442
443
444
445
446
447
448
449
450
451
452
453
454
for (i = 0; i < 256; i++) ramp[i] = magic;
SDL_CalculateGammaRamp(gamma, ramp);
SDLTest_AssertPass("Call to SDL_CalculateGammaRamp(%f)", gamma);
changed = 0;
for (i = 0; i < 256; i++) if (ramp[i] != magic) changed++;
SDLTest_AssertCheck(changed > 250, "Validate that ramp was calculated; expected: >250 values changed, got: %d values changed", changed);
/* Additional value checks for some cases */
i = SDLTest_RandomIntegerInRange(64,192);
switch (variation) {
case 0:
SDLTest_AssertCheck(ramp[i] == 0, "Validate value at position %d; expected: 0, got: %d", i, ramp[i]);
break;
case 1:
455
SDLTest_AssertCheck(ramp[i] == ((i << 8) | i), "Validate value at position %d; expected: %d, got: %d", i, (i << 8) | i, ramp[i]);
456
457
458
459
460
461
462
break;
case 2:
case 3:
SDLTest_AssertCheck(ramp[i] > 0, "Validate value at position %d; expected: >0, got: %d", i, ramp[i]);
break;
}
}
464
465
466
467
468
469
470
471
472
473
474
/* Negative cases */
SDL_ClearError();
SDLTest_AssertPass("Call to SDL_ClearError()");
gamma = -1;
for (i=0; i<256; i++) ramp[i] = magic;
SDL_CalculateGammaRamp(gamma, ramp);
SDLTest_AssertPass("Call to SDL_CalculateGammaRamp(%f)", gamma);
error = SDL_GetError();
SDLTest_AssertPass("Call to SDL_GetError()");
SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
if (error != NULL) {
475
SDLTest_AssertCheck(SDL_strcmp(error, expectedError1) == 0,
476
477
478
479
480
481
482
483
484
485
486
487
"Validate error message, expected: '%s', got: '%s'", expectedError1, error);
}
changed = 0;
for (i = 0; i < 256; i++) if (ramp[i] != magic) changed++;
SDLTest_AssertCheck(changed ==0, "Validate that ramp unchanged; expected: 0 values changed got: %d values changed", changed);
SDL_CalculateGammaRamp(0.5f, NULL);
SDLTest_AssertPass("Call to SDL_CalculateGammaRamp(0.5,NULL)");
error = SDL_GetError();
SDLTest_AssertPass("Call to SDL_GetError()");
SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
if (error != NULL) {
488
SDLTest_AssertCheck(SDL_strcmp(error, expectedError2) == 0,
489
490
"Validate error message, expected: '%s', got: '%s'", expectedError2, error);
}
492
493
/* Cleanup */
SDL_free(ramp);
496
497
498
499
500
return TEST_COMPLETED;
}
/* ================= Test References ================== */
501
/* Pixels test cases */
502
static const SDLTest_TestCaseReference pixelsTest1 =
503
{ (SDLTest_TestCaseFp)pixels_allocFreeFormat, "pixels_allocFreeFormat", "Call to SDL_AllocFormat and SDL_FreeFormat", TEST_ENABLED };
505
static const SDLTest_TestCaseReference pixelsTest2 =
506
{ (SDLTest_TestCaseFp)pixels_allocFreePalette, "pixels_allocFreePalette", "Call to SDL_AllocPalette and SDL_FreePalette", TEST_ENABLED };
508
static const SDLTest_TestCaseReference pixelsTest3 =
509
{ (SDLTest_TestCaseFp)pixels_calcGammaRamp, "pixels_calcGammaRamp", "Call to SDL_CalculateGammaRamp", TEST_ENABLED };
511
static const SDLTest_TestCaseReference pixelsTest4 =
512
{ (SDLTest_TestCaseFp)pixels_getPixelFormatName, "pixels_getPixelFormatName", "Call to SDL_GetPixelFormatName", TEST_ENABLED };
514
515
/* Sequence of Pixels test cases */
static const SDLTest_TestCaseReference *pixelsTests[] = {
516
&pixelsTest1, &pixelsTest2, &pixelsTest3, &pixelsTest4, NULL
517
518
519
520
};
/* Pixels test suite (global) */
SDLTest_TestSuiteReference pixelsTestSuite = {
521
522
523
524
"Pixels",
NULL,
pixelsTests,
NULL