mirror of
https://github.com/Relintai/sdl2_frt.git
synced 2024-12-16 11:06:49 +01:00
0e45984fa0
The internal function SDL_EGL_LoadLibrary() did not delete and remove a mostly uninitialized data structure if loading the library first failed. A later try to use EGL then skipped initialization and assumed it was previously successful because the data structure now already existed. This led to at least one crash in the internal function SDL_EGL_ChooseConfig() because a NULL pointer was dereferenced to make a call to eglBindAPI().
530 lines
18 KiB
C
530 lines
18 KiB
C
/**
|
|
* 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
|
|
};
|