test/testautomation_pixels.c
author Sam Lantinga <slouken@libsdl.org>
Sat, 27 Jan 2018 12:05:26 -0800
changeset 11836 a42b155124a3
parent 9046 c3ec7c3e6c24
child 13249 0d2519c40e47
permissions -rw-r--r--
Fixed bug 4065 - SDL_wave.c fail to compile in armeabi with ndk r16b

Sylvain

armeabi is almost deprecated for android-ndk higher that r13b.
either it doesn't compile (ICE), or it executes wrongly (using long long for instance).

android people advices to use armeabi-v7a (or use r13b).
     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
   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
   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
   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
   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 };