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