summaryrefslogtreecommitdiffstatshomepage
path: root/3rdparty/SDL2/test/testautomation_pixels.c
diff options
context:
space:
mode:
author Miodrag Milanovic <mmicko@gmail.com>2016-02-27 16:28:05 +0100
committer Miodrag Milanovic <mmicko@gmail.com>2016-02-27 16:53:49 +0100
commitcf6dc7d370407914020f3e623719f09c8668c692 (patch)
tree46b3416d091b4c09b50fba7ffcbd310aed032cc8 /3rdparty/SDL2/test/testautomation_pixels.c
parent64135e73f973d9b95beb0c60b65feb34fbfec64a (diff)
Placed SDL2 source since we need it on some platforms (nw)
Diffstat (limited to '3rdparty/SDL2/test/testautomation_pixels.c')
-rw-r--r--3rdparty/SDL2/test/testautomation_pixels.c529
1 files changed, 529 insertions, 0 deletions
diff --git a/3rdparty/SDL2/test/testautomation_pixels.c b/3rdparty/SDL2/test/testautomation_pixels.c
new file mode 100644
index 00000000000..7b88caaa9da
--- /dev/null
+++ b/3rdparty/SDL2/test/testautomation_pixels.c
@@ -0,0 +1,529 @@
+/**
+ * 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;
+Uint32 _RGBPixelFormats[] =
+ {
+ 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
+ };
+char* _RGBPixelFormatsVerbose[] =
+ {
+ "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 = 7;
+Uint32 _nonRGBPixelFormats[] =
+ {
+ SDL_PIXELFORMAT_YV12,
+ SDL_PIXELFORMAT_IYUV,
+ SDL_PIXELFORMAT_YUY2,
+ SDL_PIXELFORMAT_UYVY,
+ SDL_PIXELFORMAT_YVYU,
+ SDL_PIXELFORMAT_NV12,
+ SDL_PIXELFORMAT_NV21
+ };
+char* _nonRGBPixelFormatsVerbose[] =
+ {
+ "SDL_PIXELFORMAT_YV12",
+ "SDL_PIXELFORMAT_IYUV",
+ "SDL_PIXELFORMAT_YUY2",
+ "SDL_PIXELFORMAT_UYVY",
+ "SDL_PIXELFORMAT_YVYU",
+ "SDL_PIXELFORMAT_NV12",
+ "SDL_PIXELFORMAT_NV21"
+ };
+
+/* Definition of some invalid formats for negative tests */
+const int _numInvalidPixelFormats = 2;
+Uint32 _invalidPixelFormats[] =
+ {
+ 0xfffffffe,
+ 0xffffffff
+ };
+char* _invalidPixelFormatsVerbose[] =
+ {
+ "SDL_PIXELFORMAT_UNKNOWN",
+ "SDL_PIXELFORMAT_UNKNOWN"
+ };
+
+/* Test case functions */
+
+/**
+ * @brief Call to SDL_AllocFormat and SDL_FreeFormat
+ *
+ * @sa http://wiki.libsdl.org/moin.fcg/SDL_AllocFormat
+ * @sa http://wiki.libsdl.org/moin.fcg/SDL_FreeFormat
+ */
+int
+pixels_allocFreeFormat(void *arg)
+{
+ const char *unknownFormat = "SDL_PIXELFORMAT_UNKNOWN";
+ const char *expectedError = "Parameter 'format' is invalid";
+ const char *error;
+ int i;
+ Uint32 format;
+ Uint32 masks;
+ SDL_PixelFormat* result;
+
+ /* Blank/unknown format */
+ format = 0;
+ SDLTest_Log("RGB Format: %s (%u)", unknownFormat, format);
+
+ /* Allocate format */
+ result = SDL_AllocFormat(format);
+ SDLTest_AssertPass("Call to SDL_AllocFormat()");
+ SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
+ if (result != NULL) {
+ 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);
+ 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);
+
+ /* Deallocate again */
+ SDL_FreeFormat(result);
+ SDLTest_AssertPass("Call to SDL_FreeFormat()");
+ }
+
+ /* RGB formats */
+ for (i = 0; i < _numRGBPixelFormats; i++) {
+ format = _RGBPixelFormats[i];
+ SDLTest_Log("RGB Format: %s (%u)", _RGBPixelFormatsVerbose[i], format);
+
+ /* Allocate format */
+ result = SDL_AllocFormat(format);
+ SDLTest_AssertPass("Call to SDL_AllocFormat()");
+ SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
+ if (result != NULL) {
+ 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) {
+ 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);
+ }
+
+ /* Deallocate again */
+ SDL_FreeFormat(result);
+ SDLTest_AssertPass("Call to SDL_FreeFormat()");
+ }
+ }
+
+ /* Non-RGB formats */
+ for (i = 0; i < _numNonRGBPixelFormats; i++) {
+ format = _nonRGBPixelFormats[i];
+ SDLTest_Log("non-RGB Format: %s (%u)", _nonRGBPixelFormatsVerbose[i], format);
+
+ /* Try to allocate format */
+ result = SDL_AllocFormat(format);
+ SDLTest_AssertPass("Call to SDL_AllocFormat()");
+ SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
+ }
+
+ /* Negative cases */
+
+ /* Invalid Formats */
+ 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);
+ SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
+ error = SDL_GetError();
+ SDLTest_AssertPass("Call to SDL_GetError()");
+ SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
+ if (error != NULL) {
+ SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0,
+ "Validate error message, expected: '%s', got: '%s'", expectedError, error);
+ }
+ }
+
+ /* Invalid free pointer */
+ SDL_ClearError();
+ SDLTest_AssertPass("Call to SDL_ClearError()");
+ SDL_FreeFormat(NULL);
+ SDLTest_AssertPass("Call to SDL_FreeFormat(NULL)");
+ error = SDL_GetError();
+ SDLTest_AssertPass("Call to SDL_GetError()");
+ SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
+ if (error != NULL) {
+ SDLTest_AssertCheck(SDL_strcmp(error, expectedError) == 0,
+ "Validate error message, expected: '%s', got: '%s'", expectedError, error);
+ }
+
+ return TEST_COMPLETED;
+}
+
+/**
+ * @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";
+ const char *error;
+ int i;
+ Uint32 format;
+ char* result;
+
+ /* Blank/undefined format */
+ format = 0;
+ SDLTest_Log("RGB Format: %s (%u)", unknownFormat, format);
+
+ /* Get name of format */
+ result = (char *)SDL_GetPixelFormatName(format);
+ SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
+ SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
+ if (result != NULL) {
+ SDLTest_AssertCheck(result[0] != '\0', "Verify result is non-empty");
+ SDLTest_AssertCheck(SDL_strcmp(result, unknownFormat) == 0,
+ "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);
+
+ /* Get name of format */
+ result = (char *)SDL_GetPixelFormatName(format);
+ SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
+ SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
+ if (result != NULL) {
+ SDLTest_AssertCheck(result[0] != '\0', "Verify result is non-empty");
+ SDLTest_AssertCheck(SDL_strcmp(result, _RGBPixelFormatsVerbose[i]) == 0,
+ "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);
+
+ /* Get name of format */
+ result = (char *)SDL_GetPixelFormatName(format);
+ SDLTest_AssertPass("Call to SDL_GetPixelFormatName()");
+ SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
+ if (result != NULL) {
+ SDLTest_AssertCheck(result[0] != '\0', "Verify result is non-empty");
+ SDLTest_AssertCheck(SDL_strcmp(result, _nonRGBPixelFormatsVerbose[i]) == 0,
+ "Verify result text; expected: %s, got %s", _nonRGBPixelFormatsVerbose[i], result);
+ }
+ }
+
+ /* Negative cases */
+
+ /* Invalid Formats */
+ 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);
+ SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
+ if (result != NULL) {
+ SDLTest_AssertCheck(result[0] != '\0',
+ "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 || error[0] == '\0', "Validate that error message is empty");
+ }
+
+ return TEST_COMPLETED;
+}
+
+/**
+ * @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)
+{
+ const char *expectedError1 = "Parameter 'ncolors' is invalid";
+ const char *expectedError2 = "Parameter 'palette' is invalid";
+ const char *error;
+ int variation;
+ int i;
+ int ncolors;
+ SDL_Palette* result;
+
+ /* Allocate palette */
+ for (variation = 1; variation <= 3; variation++) {
+ 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);
+ SDLTest_AssertCheck(result != NULL, "Verify result is not NULL");
+ if (result != NULL) {
+ SDLTest_AssertCheck(result->ncolors == ncolors, "Verify value of result.ncolors; expected: %u, got %u", ncolors, result->ncolors);
+ 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++) {
+ 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);
+ }
+ }
+ }
+
+ /* Deallocate again */
+ SDL_FreePalette(result);
+ SDLTest_AssertPass("Call to SDL_FreePalette()");
+ }
+ }
+
+ /* Negative cases */
+
+ /* Invalid number of colors */
+ for (ncolors = 0; ncolors > -3; ncolors--) {
+ SDL_ClearError();
+ SDLTest_AssertPass("Call to SDL_ClearError()");
+ result = SDL_AllocPalette(ncolors);
+ SDLTest_AssertPass("Call to SDL_AllocPalette(%d)", ncolors);
+ SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
+ error = SDL_GetError();
+ SDLTest_AssertPass("Call to SDL_GetError()");
+ SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
+ if (error != NULL) {
+ SDLTest_AssertCheck(SDL_strcmp(error, expectedError1) == 0,
+ "Validate error message, expected: '%s', got: '%s'", expectedError1, error);
+ }
+ }
+
+ /* Invalid free pointer */
+ SDL_ClearError();
+ SDLTest_AssertPass("Call to SDL_ClearError()");
+ SDL_FreePalette(NULL);
+ SDLTest_AssertPass("Call to SDL_FreePalette(NULL)");
+ error = SDL_GetError();
+ SDLTest_AssertPass("Call to SDL_GetError()");
+ SDLTest_AssertCheck(error != NULL, "Validate that error message was not NULL");
+ if (error != NULL) {
+ SDLTest_AssertCheck(SDL_strcmp(error, expectedError2) == 0,
+ "Validate error message, expected: '%s', got: '%s'", expectedError2, error);
+ }
+
+ 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";
+ const char *error;
+ 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;
+
+ /* Make call with different gamma values */
+ for (variation = 0; variation < 4; variation++) {
+ switch (variation) {
+ /* gamma = 0 all black */
+ case 0:
+ gamma = 0.0f;
+ break;
+ /* gamma = 1 identity */
+ case 1:
+ gamma = 1.0f;
+ break;
+ /* gamma = [0.2,0.8] normal range */
+ case 2:
+ gamma = 0.2f + 0.8f * SDLTest_RandomUnitFloat();
+ break;
+ /* gamma = >1.1 non-standard range */
+ case 3:
+ gamma = 1.1f + SDLTest_RandomUnitFloat();
+ break;
+ }
+
+ /* Make call and check that values were updated */
+ 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:
+ SDLTest_AssertCheck(ramp[i] == ((i << 8) | i), "Validate value at position %d; expected: %d, got: %d", i, (i << 8) | i, ramp[i]);
+ break;
+ case 2:
+ case 3:
+ SDLTest_AssertCheck(ramp[i] > 0, "Validate value at position %d; expected: >0, got: %d", i, ramp[i]);
+ break;
+ }
+ }
+
+ /* 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) {
+ SDLTest_AssertCheck(SDL_strcmp(error, expectedError1) == 0,
+ "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) {
+ SDLTest_AssertCheck(SDL_strcmp(error, expectedError2) == 0,
+ "Validate error message, expected: '%s', got: '%s'", expectedError2, error);
+ }
+
+ /* Cleanup */
+ SDL_free(ramp);
+
+
+ return TEST_COMPLETED;
+}
+
+/* ================= Test References ================== */
+
+/* Pixels test cases */
+static const SDLTest_TestCaseReference pixelsTest1 =
+ { (SDLTest_TestCaseFp)pixels_allocFreeFormat, "pixels_allocFreeFormat", "Call to SDL_AllocFormat and SDL_FreeFormat", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference pixelsTest2 =
+ { (SDLTest_TestCaseFp)pixels_allocFreePalette, "pixels_allocFreePalette", "Call to SDL_AllocPalette and SDL_FreePalette", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference pixelsTest3 =
+ { (SDLTest_TestCaseFp)pixels_calcGammaRamp, "pixels_calcGammaRamp", "Call to SDL_CalculateGammaRamp", TEST_ENABLED };
+
+static const SDLTest_TestCaseReference pixelsTest4 =
+ { (SDLTest_TestCaseFp)pixels_getPixelFormatName, "pixels_getPixelFormatName", "Call to SDL_GetPixelFormatName", TEST_ENABLED };
+
+/* Sequence of Pixels test cases */
+static const SDLTest_TestCaseReference *pixelsTests[] = {
+ &pixelsTest1, &pixelsTest2, &pixelsTest3, &pixelsTest4, NULL
+};
+
+/* Pixels test suite (global) */
+SDLTest_TestSuiteReference pixelsTestSuite = {
+ "Pixels",
+ NULL,
+ pixelsTests,
+ NULL
+};