/**

* Video test suite

*/

#include <stdio.h>

#include "SDL.h"

#include "SDL_test.h"

/* Private helpers */

/*

* Create a test window

*/

SDL_Window *_createVideoSuiteTestWindow(const char *title)

{

SDL_Window* window;

int x, y, w, h;

SDL_WindowFlags flags;

/* Standard window */

x = SDLTest_RandomIntegerInRange(1, 100);

y = SDLTest_RandomIntegerInRange(1, 100);

w = SDLTest_RandomIntegerInRange(320, 1024);

h = SDLTest_RandomIntegerInRange(320, 768);

flags = SDL_WINDOW_SHOWN;

window = SDL_CreateWindow(title, x, y, w, h, flags);

SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,%d)", x, y, w, h, flags);

SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL");

return window;

}

/*

* Destroy test window

*/

void _destroyVideoSuiteTestWindow(SDL_Window *window)

{

if (window != NULL) {

SDL_DestroyWindow(window);

window = NULL;

SDLTest_AssertPass("Call to SDL_DestroyWindow");

}

}

/* Test case functions */

/**

* @brief Enable and disable screensaver while checking state

*/

int

video_enableDisableScreensaver(void *arg)

{

SDL_bool initialResult;

SDL_bool result;

/* Get current state and proceed according to current state */

initialResult = SDL_IsScreenSaverEnabled();

SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");

if (initialResult == SDL_TRUE) {

/* Currently enabled: disable first, then enable again */

/* Disable screensaver and check */

SDL_DisableScreenSaver();

SDLTest_AssertPass("Call to SDL_DisableScreenSaver()");

result = SDL_IsScreenSaverEnabled();

SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");

SDLTest_AssertCheck(result == SDL_FALSE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_FALSE, result);

/* Enable screensaver and check */

SDL_EnableScreenSaver();

SDLTest_AssertPass("Call to SDL_EnableScreenSaver()");

result = SDL_IsScreenSaverEnabled();

SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");

SDLTest_AssertCheck(result == SDL_TRUE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_TRUE, result);

} else {

/* Currently disabled: enable first, then disable again */

/* Enable screensaver and check */

SDL_EnableScreenSaver();

SDLTest_AssertPass("Call to SDL_EnableScreenSaver()");

result = SDL_IsScreenSaverEnabled();

SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");

SDLTest_AssertCheck(result == SDL_TRUE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_TRUE, result);

/* Disable screensaver and check */

SDL_DisableScreenSaver();

SDLTest_AssertPass("Call to SDL_DisableScreenSaver()");

result = SDL_IsScreenSaverEnabled();

SDLTest_AssertPass("Call to SDL_IsScreenSaverEnabled()");

SDLTest_AssertCheck(result == SDL_FALSE, "Verify result from SDL_IsScreenSaverEnabled, expected: %i, got: %i", SDL_FALSE, result);

}

return TEST_COMPLETED;

}

/**

* @brief Tests the functionality of the SDL_CreateWindow function using different positions

*/

int

video_createWindowVariousPositions(void *arg)

{

SDL_Window* window;

const char* title = "video_createWindowVariousPositions Test Window";

int x, y, w, h;

int xVariation, yVariation;

for (xVariation = 0; xVariation < 6; xVariation++) {

for (yVariation = 0; yVariation < 6; yVariation++) {

switch(xVariation) {

case 0:

/* Zero X Position */

x = 0;

break;

case 1:

/* Random X position inside screen */

x = SDLTest_RandomIntegerInRange(1, 100);

break;

case 2:

/* Random X position outside screen (positive) */

x = SDLTest_RandomIntegerInRange(10000, 11000);

break;

case 3:

/* Random X position outside screen (negative) */

x = SDLTest_RandomIntegerInRange(-1000, -100);

break;

case 4:

/* Centered X position */

x = SDL_WINDOWPOS_CENTERED;

break;

case 5:

/* Undefined X position */

x = SDL_WINDOWPOS_UNDEFINED;

break;

}

switch(yVariation) {

case 0:

/* Zero X Position */

y = 0;

break;

case 1:

/* Random X position inside screen */

y = SDLTest_RandomIntegerInRange(1, 100);

break;

case 2:

/* Random X position outside screen (positive) */

y = SDLTest_RandomIntegerInRange(10000, 11000);

break;

case 3:

/* Random Y position outside screen (negative) */

y = SDLTest_RandomIntegerInRange(-1000, -100);

break;

case 4:

/* Centered Y position */

y = SDL_WINDOWPOS_CENTERED;

break;

case 5:

/* Undefined Y position */

y = SDL_WINDOWPOS_UNDEFINED;

break;

}

w = SDLTest_RandomIntegerInRange(32, 96);

h = SDLTest_RandomIntegerInRange(32, 96);

window = SDL_CreateWindow(title, x, y, w, h, SDL_WINDOW_SHOWN);

SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,SHOWN)", x, y, w, h);

SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL");

/* Clean up */

_destroyVideoSuiteTestWindow(window);

}

}

return TEST_COMPLETED;

}

/**

* @brief Tests the functionality of the SDL_CreateWindow function using different sizes

*/

int

video_createWindowVariousSizes(void *arg)

{

SDL_Window* window;

const char* title = "video_createWindowVariousSizes Test Window";

int x, y, w, h;

int wVariation, hVariation;

x = SDLTest_RandomIntegerInRange(1, 100);

y = SDLTest_RandomIntegerInRange(1, 100);

for (wVariation = 0; wVariation < 3; wVariation++) {

for (hVariation = 0; hVariation < 3; hVariation++) {

switch(wVariation) {

case 0:

/* Width of 1 */

w = 1;

break;

case 1:

/* Random "normal" width */

w = SDLTest_RandomIntegerInRange(320, 1920);

break;

case 2:

/* Random "large" width */

w = SDLTest_RandomIntegerInRange(2048, 4095);

break;

}

switch(hVariation) {

case 0:

/* Height of 1 */

h = 1;

break;

case 1:

/* Random "normal" height */

h = SDLTest_RandomIntegerInRange(320, 1080);

break;

case 2:

/* Random "large" height */

h = SDLTest_RandomIntegerInRange(2048, 4095);

break;

}

window = SDL_CreateWindow(title, x, y, w, h, SDL_WINDOW_SHOWN);

SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,SHOWN)", x, y, w, h);

SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL");

/* Clean up */

_destroyVideoSuiteTestWindow(window);

}

}

return TEST_COMPLETED;

}

/**

* @brief Tests the functionality of the SDL_CreateWindow function using different flags

*/

int

video_createWindowVariousFlags(void *arg)

{

SDL_Window* window;

const char* title = "video_createWindowVariousFlags Test Window";

int x, y, w, h;

int fVariation;

SDL_WindowFlags flags;

/* Standard window */

x = SDLTest_RandomIntegerInRange(1, 100);

y = SDLTest_RandomIntegerInRange(1, 100);

w = SDLTest_RandomIntegerInRange(320, 1024);

h = SDLTest_RandomIntegerInRange(320, 768);

for (fVariation = 0; fVariation < 13; fVariation++) {

switch(fVariation) {

case 0:

flags = SDL_WINDOW_FULLSCREEN;

/* Skip - blanks screen; comment out next line to run test */

continue;

break;

case 1:

flags = SDL_WINDOW_FULLSCREEN_DESKTOP;

/* Skip - blanks screen; comment out next line to run test */

continue;

break;

case 2:

flags = SDL_WINDOW_OPENGL;

break;

case 3:

flags = SDL_WINDOW_SHOWN;

break;

case 4:

flags = SDL_WINDOW_HIDDEN;

break;

case 5:

flags = SDL_WINDOW_BORDERLESS;

break;

case 6:

flags = SDL_WINDOW_RESIZABLE;

break;

case 7:

flags = SDL_WINDOW_MINIMIZED;

break;

case 8:

flags = SDL_WINDOW_MAXIMIZED;

break;

case 9:

flags = SDL_WINDOW_INPUT_GRABBED;

break;

case 10:

flags = SDL_WINDOW_INPUT_FOCUS;

break;

case 11:

flags = SDL_WINDOW_MOUSE_FOCUS;

break;

case 12:

flags = SDL_WINDOW_FOREIGN;

break;

}

window = SDL_CreateWindow(title, x, y, w, h, flags);

SDLTest_AssertPass("Call to SDL_CreateWindow('Title',%d,%d,%d,%d,%d)", x, y, w, h, flags);

SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL");

/* Clean up */

_destroyVideoSuiteTestWindow(window);

}

return TEST_COMPLETED;

}

/**

* @brief Tests the functionality of the SDL_GetWindowFlags function

*/

int

video_getWindowFlags(void *arg)

{

SDL_Window* window;

const char* title = "video_getWindowFlags Test Window";

SDL_WindowFlags flags;

Uint32 actualFlags;

flags = SDL_WINDOW_SHOWN;

/* Call against new test window */

window = _createVideoSuiteTestWindow(title);

if (window != NULL) {

actualFlags = SDL_GetWindowFlags(window);

SDLTest_AssertPass("Call to SDL_GetWindowFlags");

SDLTest_AssertCheck((flags & actualFlags) == flags, "Verify returned value has flags %d set, got: %d", flags, actualFlags);

}

/* Clean up */

_destroyVideoSuiteTestWindow(window);

return TEST_COMPLETED;

}

/**

* @brief Tests the functionality of the SDL_GetNumDisplayModes function

*/

int

video_getNumDisplayModes(void *arg)

{

int result;

int displayNum;

int i;

/* Get number of displays */

displayNum = SDL_GetNumVideoDisplays();

SDLTest_AssertPass("Call to SDL_GetNumVideoDisplays");

/* Make call for each display */

for (i=0; i<displayNum; i++) {

result = SDL_GetNumDisplayModes(i);

SDLTest_AssertPass("Call to SDL_GetNumDisplayModes(%d)", i);

SDLTest_AssertCheck(result >= 1, "Validate returned value from function; expected: >=1; got: %d", result);

}

return TEST_COMPLETED;

}

/**

* @brief Tests negative call to SDL_GetNumDisplayModes function

*/

int

video_getNumDisplayModesNegative(void *arg)

{

int result;

int displayNum;

int displayIndex;

/* Get number of displays */

displayNum = SDL_GetNumVideoDisplays();

SDLTest_AssertPass("Call to SDL_GetNumVideoDisplays");

/* Invalid boundary values */

displayIndex = SDLTest_RandomSint32BoundaryValue(0, displayNum, SDL_FALSE);

result = SDL_GetNumDisplayModes(displayIndex);

SDLTest_AssertPass("Call to SDL_GetNumDisplayModes(%d=out-of-bounds/boundary)", displayIndex);

SDLTest_AssertCheck(result < 0, "Validate returned value from function; expected: <0; got: %d", result);

/* Large (out-of-bounds) display index */

displayIndex = SDLTest_RandomIntegerInRange(-2000, -1000);

result = SDL_GetNumDisplayModes(displayIndex);

SDLTest_AssertPass("Call to SDL_GetNumDisplayModes(%d=out-of-bounds/large negative)", displayIndex);

SDLTest_AssertCheck(result < 0, "Validate returned value from function; expected: <0; got: %d", result);

displayIndex = SDLTest_RandomIntegerInRange(1000, 2000);

result = SDL_GetNumDisplayModes(displayIndex);

SDLTest_AssertPass("Call to SDL_GetNumDisplayModes(%d=out-of-bounds/large positive)", displayIndex);

SDLTest_AssertCheck(result < 0, "Validate returned value from function; expected: <0; got: %d", result);

return TEST_COMPLETED;

}

/**

* @brief Tests the functionality of the SDL_GetClosestDisplayMode function against current resolution

*/

int

video_getClosestDisplayModeCurrentResolution(void *arg)

{

int result;

SDL_DisplayMode current;

SDL_DisplayMode target;

SDL_DisplayMode closest;

SDL_DisplayMode* dResult;

int displayNum;

int i;

int variation;

/* Get number of displays */

displayNum = SDL_GetNumVideoDisplays();

SDLTest_AssertPass("Call to SDL_GetNumVideoDisplays");

/* Make calls for each display */

for (i=0; i<displayNum; i++) {

SDLTest_Log("Testing against display: %d", i);

/* Get first display mode to get a sane resolution; this should always work */

result = SDL_GetDisplayMode(i, 0, &current);

SDLTest_AssertPass("Call to SDL_GetDisplayMode");

SDLTest_AssertCheck(result == 0, "Verify return value, expected: 0, got: %d", result);

if (result != 0) {

return TEST_ABORTED;

}

/* Set the desired resolution equals to current resolution */

target.w = current.w;

target.h = current.h;

for (variation = 0; variation < 8; variation ++) {

/* Vary constraints on other query parameters */

target.format = (variation & 1) ? current.format : 0;

target.refresh_rate = (variation & 2) ? current.refresh_rate : 0;

target.driverdata = (variation & 4) ? current.driverdata : 0;

/* Make call */

dResult = SDL_GetClosestDisplayMode(i, &target, &closest);

SDLTest_AssertPass("Call to SDL_GetClosestDisplayMode(target=current/variation%d)", variation);

SDLTest_AssertCheck(dResult != NULL, "Verify returned value is not NULL");

/* Check that one gets the current resolution back again */

SDLTest_AssertCheck(closest.w == current.w, "Verify returned width matches current width; expected: %d, got: %d", current.w, closest.w);

SDLTest_AssertCheck(closest.h == current.h, "Verify returned height matches current height; expected: %d, got: %d", current.h, closest.h);

SDLTest_AssertCheck(closest.w == dResult->w, "Verify return value matches assigned value; expected: %d, got: %d", closest.w, dResult->w);

SDLTest_AssertCheck(closest.h == dResult->h, "Verify return value matches assigned value; expected: %d, got: %d", closest.h, dResult->h);

}

}

return TEST_COMPLETED;

}

/**

* @brief Tests the functionality of the SDL_GetClosestDisplayMode function against random resolution

*/

int

video_getClosestDisplayModeRandomResolution(void *arg)

{

SDL_DisplayMode target;

SDL_DisplayMode closest;

SDL_DisplayMode* dResult;

int displayNum;

int i;

int variation;

/* Get number of displays */

displayNum = SDL_GetNumVideoDisplays();

SDLTest_AssertPass("Call to SDL_GetNumVideoDisplays");

/* Make calls for each display */

for (i=0; i<displayNum; i++) {

SDLTest_Log("Testing against display: %d", i);

for (variation = 0; variation < 16; variation ++) {

/* Set random constraints */

target.w = (variation & 1) ? SDLTest_RandomIntegerInRange(1, 4096) : 0;

target.h = (variation & 2) ? SDLTest_RandomIntegerInRange(1, 4096) : 0;

target.format = (variation & 4) ? SDLTest_RandomIntegerInRange(1, 10) : 0;

target.refresh_rate = (variation & 8) ? SDLTest_RandomIntegerInRange(25, 120) : 0;

target.driverdata = 0;

/* Make call; may or may not find anything, so don't validate any further */

dResult = SDL_GetClosestDisplayMode(i, &target, &closest);

SDLTest_AssertPass("Call to SDL_GetClosestDisplayMode(target=random/variation%d)", variation);

}

}

return TEST_COMPLETED;

}

/**

* @brief Tests call to SDL_GetWindowBrightness

*/

int

video_getWindowBrightness(void *arg)

{

SDL_Window* window;

const char* title = "video_getWindowBrightness Test Window";

float result;

/* Call against new test window */

window = _createVideoSuiteTestWindow(title);

if (window != NULL) {

result = SDL_GetWindowBrightness(window);

SDLTest_AssertPass("Call to SDL_GetWindowBrightness");

SDLTest_AssertCheck(result >= 0.0 && result <= 1.0, "Validate range of result value; expected: [0.0, 1.0], got: %f", result);

}

/* Clean up */

_destroyVideoSuiteTestWindow(window);

return TEST_COMPLETED;

}

/* ================= Test References ================== */

/* Video test cases */

static const SDLTest_TestCaseReference videoTest1 =

{ (SDLTest_TestCaseFp)video_enableDisableScreensaver, "video_enableDisableScreensaver", "Enable and disable screenaver while checking state", TEST_ENABLED };

static const SDLTest_TestCaseReference videoTest2 =

{ (SDLTest_TestCaseFp)video_createWindowVariousPositions, "video_createWindowVariousPositions", "Create windows at various locations", TEST_ENABLED };

static const SDLTest_TestCaseReference videoTest3 =

{ (SDLTest_TestCaseFp)video_createWindowVariousSizes, "video_createWindowVariousSizes", "Create windows with various sizes", TEST_ENABLED };

static const SDLTest_TestCaseReference videoTest4 =

{ (SDLTest_TestCaseFp)video_createWindowVariousFlags, "video_createWindowVariousFlags", "Create windows using various flags", TEST_ENABLED };

static const SDLTest_TestCaseReference videoTest5 =

{ (SDLTest_TestCaseFp)video_getWindowFlags, "video_getWindowFlags", "Get window flags set during SDL_CreateWindow", TEST_ENABLED };

static const SDLTest_TestCaseReference videoTest6 =

{ (SDLTest_TestCaseFp)video_getNumDisplayModes, "video_getNumDisplayModes", "Use SDL_GetNumDisplayModes function to get number of display modes", TEST_ENABLED };

static const SDLTest_TestCaseReference videoTest7 =

{ (SDLTest_TestCaseFp)video_getNumDisplayModesNegative, "video_getNumDisplayModesNegative", "Negative tests for SDL_GetNumDisplayModes", TEST_ENABLED };

static const SDLTest_TestCaseReference videoTest8 =

{ (SDLTest_TestCaseFp)video_getClosestDisplayModeCurrentResolution, "video_getClosestDisplayModeCurrentResolution", "Use function to get closes match to requested display mode for current resolution", TEST_ENABLED };

static const SDLTest_TestCaseReference videoTest9 =

{ (SDLTest_TestCaseFp)video_getClosestDisplayModeRandomResolution, "video_getClosestDisplayModeRandomResolution", "Use function to get closes match to requested display mode for random resolution", TEST_ENABLED };

static const SDLTest_TestCaseReference videoTest10 =

{ (SDLTest_TestCaseFp)video_getWindowBrightness, "video_getWindowBrightness", "Get window brightness", TEST_ENABLED };

/* Sequence of Video test cases */

static const SDLTest_TestCaseReference *videoTests[] = {

&videoTest1, &videoTest2, &videoTest3, &videoTest4, &videoTest5, &videoTest6,

&videoTest7, &videoTest8, &videoTest9, &videoTest10, NULL

};

/* Video test suite (global) */

SDLTest_TestSuiteReference videoTestSuite = {

"Video",

NULL,

videoTests,

NULL

};