From c3af575a4ebb1e9e949ca0c00e325c2e4e06f80b Mon Sep 17 00:00:00 2001 From: Andreas Schiffler Date: Sun, 9 Dec 2012 17:56:19 -0800 Subject: [PATCH] Added existing common.c/.h functions to test lib; minor assert refactoring --- VisualC/SDLtest/SDLtest_VS2010.vcxproj | 2 + VisualC/SDLtest/SDLtest_VS2012.vcxproj | 2 + include/SDL_test.h | 1 + include/SDL_test_assert.h | 15 +- include/SDL_test_common.h | 182 ++++ src/test/SDL_test_assert.c | 22 + src/test/SDL_test_common.c | 1261 ++++++++++++++++++++++++ src/test/SDL_test_harness.c | 26 +- 8 files changed, 1491 insertions(+), 20 deletions(-) create mode 100644 include/SDL_test_common.h create mode 100644 src/test/SDL_test_common.c diff --git a/VisualC/SDLtest/SDLtest_VS2010.vcxproj b/VisualC/SDLtest/SDLtest_VS2010.vcxproj index a15240f83..caad8f90c 100644 --- a/VisualC/SDLtest/SDLtest_VS2010.vcxproj +++ b/VisualC/SDLtest/SDLtest_VS2010.vcxproj @@ -153,6 +153,7 @@ + @@ -163,6 +164,7 @@ + diff --git a/VisualC/SDLtest/SDLtest_VS2012.vcxproj b/VisualC/SDLtest/SDLtest_VS2012.vcxproj index 9c58947b0..771dfd605 100644 --- a/VisualC/SDLtest/SDLtest_VS2012.vcxproj +++ b/VisualC/SDLtest/SDLtest_VS2012.vcxproj @@ -157,6 +157,7 @@ + @@ -167,6 +168,7 @@ + diff --git a/include/SDL_test.h b/include/SDL_test.h index ff29cc4b8..af7613316 100644 --- a/include/SDL_test.h +++ b/include/SDL_test.h @@ -31,6 +31,7 @@ #define _SDL_test_h #include "SDL.h" +#include "SDL_test_common.h" #include "SDL_test_font.h" #include "SDL_test_random.h" #include "SDL_test_fuzzer.h" diff --git a/include/SDL_test_assert.h b/include/SDL_test_assert.h index 7159ccd41..d557a76fb 100644 --- a/include/SDL_test_assert.h +++ b/include/SDL_test_assert.h @@ -54,12 +54,6 @@ extern "C" { */ #define ASSERT_PASS 1 -/*! \brief counts the failed asserts */ -static Uint32 SDLTest_AssertsFailed = 0; - -/*! \brief counts the passed asserts */ -static Uint32 SDLTest_AssertsPassed = 0; - /** * \brief Assert that logs and break execution flow on failures. * @@ -85,10 +79,17 @@ void SDLTest_ResetAssertSummary(); /** * \brief Logs summary of all assertions (total, pass, fail) since last reset as INFO or ERROR. - * */ void SDLTest_LogAssertSummary(); + +/** + * \brief Converts the current assert summary state to a test result. + * + * \returns TEST_RESULT_PASSED, TEST_RESULT_FAILED, or TEST_RESULT_NO_ASSERT + */ +int SDLTest_AssertSummaryToTestResult(); + #ifdef __cplusplus /* *INDENT-OFF* */ } diff --git a/include/SDL_test_common.h b/include/SDL_test_common.h new file mode 100644 index 000000000..5ccb1bf3f --- /dev/null +++ b/include/SDL_test_common.h @@ -0,0 +1,182 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/** + * \file SDL_test_common.h + * + * Include file for SDL test framework. + * + * This code is a part of the SDL2_test library, not the main SDL library. + */ + +/* Ported from original test\common.h file. */ + +#ifndef _SDL_test_common_h +#define _SDL_test_common_h + +#include "SDL.h" + +#ifdef __NDS__ +#define DEFAULT_WINDOW_WIDTH 256 +#define DEFAULT_WINDOW_HEIGHT (2*192) +#else +#define DEFAULT_WINDOW_WIDTH 640 +#define DEFAULT_WINDOW_HEIGHT 480 +#endif + +#define VERBOSE_VIDEO 0x00000001 +#define VERBOSE_MODES 0x00000002 +#define VERBOSE_RENDER 0x00000004 +#define VERBOSE_EVENT 0x00000008 +#define VERBOSE_AUDIO 0x00000010 + +typedef struct +{ + /* SDL init flags */ + char **argv; + Uint32 flags; + Uint32 verbose; + + /* Video info */ + const char *videodriver; + int display; + const char *window_title; + const char *window_icon; + Uint32 window_flags; + int window_x; + int window_y; + int window_w; + int window_h; + int depth; + int refresh_rate; + int num_windows; + SDL_Window **windows; + + /* Renderer info */ + const char *renderdriver; + Uint32 render_flags; + SDL_bool skip_renderer; + SDL_Renderer **renderers; + + /* Audio info */ + const char *audiodriver; + SDL_AudioSpec audiospec; + + /* GL settings */ + int gl_red_size; + int gl_green_size; + int gl_blue_size; + int gl_alpha_size; + int gl_buffer_size; + int gl_depth_size; + int gl_stencil_size; + int gl_double_buffer; + int gl_accum_red_size; + int gl_accum_green_size; + int gl_accum_blue_size; + int gl_accum_alpha_size; + int gl_stereo; + int gl_multisamplebuffers; + int gl_multisamplesamples; + int gl_retained_backing; + int gl_accelerated; + int gl_major_version; + int gl_minor_version; +} SDLTest_CommonState; + +#include "begin_code.h" +/* Set up for C function definitions, even when using C++ */ +#ifdef __cplusplus +/* *INDENT-OFF* */ +extern "C" { +/* *INDENT-ON* */ +#endif + +/* Function prototypes */ + +/** + * \brief Parse command line parameters and create common state. + * + * \param argv Array of command line parameters + * \param flags Flags indicating which subsystem to initialize (i.e. SDL_INIT_VIDEO | SDL_INIT_AUDIO) + * + * \returns Returns a newly allocated common state object. + */ +SDLTest_CommonState *SDLTest_CommonCreateState(char **argv, Uint32 flags); + +/** + * \brief Process one common argument. + * + * \param state The common state describing the test window to create. + * \param index The index of the argument to process in argv[]. + * + * \returns The number of arguments processed (i.e. 1 for --fullscreen, 2 for --video [videodriver], or -1 on error. + */ +int SDLTest_CommonArg(SDLTest_CommonState * state, int index); + +/** + * \brief Returns common usage information + * + * \param state The common state describing the test window to create. + * + * \returns String with usage information + */ +const char *SDLTest_CommonUsage(SDLTest_CommonState * state); + +/** + * \brief Open test window. + * + * \param state The common state describing the test window to create. + * + * \returns True if initialization succeeded, false otherwise + */ +SDL_bool SDLTest_CommonInit(SDLTest_CommonState * state); + +/** + * \brief Common event handler for test windows. + * + * \param state The common state used to create test window. + * \param event The event to handle. + * \param done Flag indicating we are done. + * + */ +void SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done); + +/** + * \brief Close test window. + * + * \param state The common state used to create test window. + * + */ +void SDLTest_CommonQuit(SDLTest_CommonState * state); + + +/* Ends C function definitions when using C++ */ +#ifdef __cplusplus +/* *INDENT-OFF* */ +} +/* *INDENT-ON* */ +#endif +#include "close_code.h" + +#endif /* _SDL_test_common_h */ + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/test/SDL_test_assert.c b/src/test/SDL_test_assert.c index 8298db171..13eda7be8 100644 --- a/src/test/SDL_test_assert.c +++ b/src/test/SDL_test_assert.c @@ -35,6 +35,12 @@ const char *SDLTest_AssertCheckFmt = "Assert '%s': %s"; /* Assert summary message format */ const char *SDLTest_AssertSummaryFmt = "Assert Summary: Total=%d Passed=%d Failed=%d"; +/*! \brief counts the failed asserts */ +static Uint32 SDLTest_AssertsFailed = 0; + +/*! \brief counts the passed asserts */ +static Uint32 SDLTest_AssertsPassed = 0; + /* * Assert that logs and break execution flow on failures (i.e. for harness errors). */ @@ -89,3 +95,19 @@ void SDLTest_LogAssertSummary() SDLTest_LogError(fmt, totalAsserts, SDLTest_AssertsPassed, SDLTest_AssertsFailed); } } + +/* + * Converts the current assert state into a test result + */ +int SDLTest_AssertSummaryToTestResult() +{ + if (SDLTest_AssertsFailed > 0) { + return TEST_RESULT_FAILED; + } else { + if (SDLTest_AssertsPassed > 0) { + return TEST_RESULT_PASSED; + } else { + return TEST_RESULT_NO_ASSERT; + } + } +} diff --git a/src/test/SDL_test_common.c b/src/test/SDL_test_common.c new file mode 100644 index 000000000..2fe85b56c --- /dev/null +++ b/src/test/SDL_test_common.c @@ -0,0 +1,1261 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2012 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* Ported from original test\common.c file. */ + +#include "SDL_config.h" +#include "SDL_test.h" + +#include + +#define VIDEO_USAGE \ +"[--video driver] [--renderer driver] [--info all|video|modes|render|event] [--log all|error|system|audio|video|render|input] [--display N] [--fullscreen | --windows N] [--title title] [--icon icon.bmp] [--center | --position X,Y] [--geometry WxH] [--depth N] [--refresh R] [--vsync] [--noframe] [--resize] [--minimize] [--maximize] [--grab]" + +#define AUDIO_USAGE \ +"[--rate N] [--format U8|S8|U16|U16LE|U16BE|S16|S16LE|S16BE] [--channels N] [--samples N]" + +SDLTest_CommonState * +SDLTest_CommonCreateState(char **argv, Uint32 flags) +{ + SDLTest_CommonState *state = (SDLTest_CommonState *)SDL_calloc(1, sizeof(*state)); + if (!state) { + SDL_OutOfMemory(); + return NULL; + } + + /* Initialize some defaults */ + state->argv = argv; + state->flags = flags; +#ifdef __NDS__ + state->window_title = ""; +#else + state->window_title = argv[0]; +#endif + state->window_flags = 0; + state->window_x = SDL_WINDOWPOS_UNDEFINED; + state->window_y = SDL_WINDOWPOS_UNDEFINED; + state->window_w = DEFAULT_WINDOW_WIDTH; + state->window_h = DEFAULT_WINDOW_HEIGHT; + state->num_windows = 1; + state->audiospec.freq = 22050; + state->audiospec.format = AUDIO_S16; + state->audiospec.channels = 2; + state->audiospec.samples = 2048; + + /* Set some very sane GL defaults */ + state->gl_red_size = 3; + state->gl_green_size = 3; + state->gl_blue_size = 2; + state->gl_alpha_size = 0; + state->gl_buffer_size = 0; + state->gl_depth_size = 16; + state->gl_stencil_size = 0; + state->gl_double_buffer = 1; + state->gl_accum_red_size = 0; + state->gl_accum_green_size = 0; + state->gl_accum_blue_size = 0; + state->gl_accum_alpha_size = 0; + state->gl_stereo = 0; + state->gl_multisamplebuffers = 0; + state->gl_multisamplesamples = 0; + state->gl_retained_backing = 1; + state->gl_accelerated = -1; + + return state; +} + +int +SDLTest_CommonArg(SDLTest_CommonState * state, int index) +{ + char **argv = state->argv; + +#ifdef __NDS__ + return 0; +#endif + + if (SDL_strcasecmp(argv[index], "--video") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + state->videodriver = argv[index]; + return 2; + } + if (SDL_strcasecmp(argv[index], "--renderer") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + state->renderdriver = argv[index]; + return 2; + } + if (SDL_strcasecmp(argv[index], "--info") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + if (SDL_strcasecmp(argv[index], "all") == 0) { + state->verbose |= + (VERBOSE_VIDEO | VERBOSE_MODES | VERBOSE_RENDER | + VERBOSE_EVENT); + return 2; + } + if (SDL_strcasecmp(argv[index], "video") == 0) { + state->verbose |= VERBOSE_VIDEO; + return 2; + } + if (SDL_strcasecmp(argv[index], "modes") == 0) { + state->verbose |= VERBOSE_MODES; + return 2; + } + if (SDL_strcasecmp(argv[index], "render") == 0) { + state->verbose |= VERBOSE_RENDER; + return 2; + } + if (SDL_strcasecmp(argv[index], "event") == 0) { + state->verbose |= VERBOSE_EVENT; + return 2; + } + return -1; + } + if (SDL_strcasecmp(argv[index], "--log") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + if (SDL_strcasecmp(argv[index], "all") == 0) { + SDL_LogSetAllPriority(SDL_LOG_PRIORITY_VERBOSE); + return 2; + } + if (SDL_strcasecmp(argv[index], "error") == 0) { + SDL_LogSetPriority(SDL_LOG_CATEGORY_ERROR, SDL_LOG_PRIORITY_VERBOSE); + return 2; + } + if (SDL_strcasecmp(argv[index], "system") == 0) { + SDL_LogSetPriority(SDL_LOG_CATEGORY_SYSTEM, SDL_LOG_PRIORITY_VERBOSE); + return 2; + } + if (SDL_strcasecmp(argv[index], "audio") == 0) { + SDL_LogSetPriority(SDL_LOG_CATEGORY_AUDIO, SDL_LOG_PRIORITY_VERBOSE); + return 2; + } + if (SDL_strcasecmp(argv[index], "video") == 0) { + SDL_LogSetPriority(SDL_LOG_CATEGORY_VIDEO, SDL_LOG_PRIORITY_VERBOSE); + return 2; + } + if (SDL_strcasecmp(argv[index], "render") == 0) { + SDL_LogSetPriority(SDL_LOG_CATEGORY_RENDER, SDL_LOG_PRIORITY_VERBOSE); + return 2; + } + if (SDL_strcasecmp(argv[index], "input") == 0) { + SDL_LogSetPriority(SDL_LOG_CATEGORY_INPUT, SDL_LOG_PRIORITY_VERBOSE); + return 2; + } + return -1; + } + if (SDL_strcasecmp(argv[index], "--display") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + state->display = SDL_atoi(argv[index]); + if (SDL_WINDOWPOS_ISUNDEFINED(state->window_x)) { + state->window_x = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display); + state->window_y = SDL_WINDOWPOS_UNDEFINED_DISPLAY(state->display); + } + if (SDL_WINDOWPOS_ISCENTERED(state->window_x)) { + state->window_x = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display); + state->window_y = SDL_WINDOWPOS_CENTERED_DISPLAY(state->display); + } + return 2; + } + if (SDL_strcasecmp(argv[index], "--fullscreen") == 0) { + state->window_flags |= SDL_WINDOW_FULLSCREEN; + state->num_windows = 1; + return 1; + } + if (SDL_strcasecmp(argv[index], "--windows") == 0) { + ++index; + if (!argv[index] || !SDL_isdigit(*argv[index])) { + return -1; + } + if (!(state->window_flags & SDL_WINDOW_FULLSCREEN)) { + state->num_windows = SDL_atoi(argv[index]); + } + return 2; + } + if (SDL_strcasecmp(argv[index], "--title") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + state->window_title = argv[index]; + return 2; + } + if (SDL_strcasecmp(argv[index], "--icon") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + state->window_icon = argv[index]; + return 2; + } + if (SDL_strcasecmp(argv[index], "--center") == 0) { + state->window_x = SDL_WINDOWPOS_CENTERED; + state->window_y = SDL_WINDOWPOS_CENTERED; + return 1; + } + if (SDL_strcasecmp(argv[index], "--position") == 0) { + char *x, *y; + ++index; + if (!argv[index]) { + return -1; + } + x = argv[index]; + y = argv[index]; + while (*y && *y != ',') { + ++y; + } + if (!*y) { + return -1; + } + *y++ = '\0'; + state->window_x = SDL_atoi(x); + state->window_y = SDL_atoi(y); + return 2; + } + if (SDL_strcasecmp(argv[index], "--geometry") == 0) { + char *w, *h; + ++index; + if (!argv[index]) { + return -1; + } + w = argv[index]; + h = argv[index]; + while (*h && *h != 'x') { + ++h; + } + if (!*h) { + return -1; + } + *h++ = '\0'; + state->window_w = SDL_atoi(w); + state->window_h = SDL_atoi(h); + return 2; + } + if (SDL_strcasecmp(argv[index], "--depth") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + state->depth = SDL_atoi(argv[index]); + return 2; + } + if (SDL_strcasecmp(argv[index], "--refresh") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + state->refresh_rate = SDL_atoi(argv[index]); + return 2; + } + if (SDL_strcasecmp(argv[index], "--vsync") == 0) { + state->render_flags |= SDL_RENDERER_PRESENTVSYNC; + return 1; + } + if (SDL_strcasecmp(argv[index], "--noframe") == 0) { + state->window_flags |= SDL_WINDOW_BORDERLESS; + return 1; + } + if (SDL_strcasecmp(argv[index], "--resize") == 0) { + state->window_flags |= SDL_WINDOW_RESIZABLE; + return 1; + } + if (SDL_strcasecmp(argv[index], "--minimize") == 0) { + state->window_flags |= SDL_WINDOW_MINIMIZED; + return 1; + } + if (SDL_strcasecmp(argv[index], "--maximize") == 0) { + state->window_flags |= SDL_WINDOW_MAXIMIZED; + return 1; + } + if (SDL_strcasecmp(argv[index], "--grab") == 0) { + state->window_flags |= SDL_WINDOW_INPUT_GRABBED; + return 1; + } + if (SDL_strcasecmp(argv[index], "--rate") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + state->audiospec.freq = SDL_atoi(argv[index]); + return 2; + } + if (SDL_strcasecmp(argv[index], "--format") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + if (SDL_strcasecmp(argv[index], "U8") == 0) { + state->audiospec.format = AUDIO_U8; + return 2; + } + if (SDL_strcasecmp(argv[index], "S8") == 0) { + state->audiospec.format = AUDIO_S8; + return 2; + } + if (SDL_strcasecmp(argv[index], "U16") == 0) { + state->audiospec.format = AUDIO_U16; + return 2; + } + if (SDL_strcasecmp(argv[index], "U16LE") == 0) { + state->audiospec.format = AUDIO_U16LSB; + return 2; + } + if (SDL_strcasecmp(argv[index], "U16BE") == 0) { + state->audiospec.format = AUDIO_U16MSB; + return 2; + } + if (SDL_strcasecmp(argv[index], "S16") == 0) { + state->audiospec.format = AUDIO_S16; + return 2; + } + if (SDL_strcasecmp(argv[index], "S16LE") == 0) { + state->audiospec.format = AUDIO_S16LSB; + return 2; + } + if (SDL_strcasecmp(argv[index], "S16BE") == 0) { + state->audiospec.format = AUDIO_S16MSB; + return 2; + } + return -1; + } + if (SDL_strcasecmp(argv[index], "--channels") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + state->audiospec.channels = (Uint8) SDL_atoi(argv[index]); + return 2; + } + if (SDL_strcasecmp(argv[index], "--samples") == 0) { + ++index; + if (!argv[index]) { + return -1; + } + state->audiospec.samples = (Uint16) SDL_atoi(argv[index]); + return 2; + } + if ((SDL_strcasecmp(argv[index], "-h") == 0) + || (SDL_strcasecmp(argv[index], "--help") == 0)) { + /* Print the usage message */ + return -1; + } + if (SDL_strcmp(argv[index], "-NSDocumentRevisionsDebugMode") == 0) { + /* Debug flag sent by Xcode */ + return 2; + } + return 0; +} + +const char * +SDLTest_CommonUsage(SDLTest_CommonState * state) +{ + switch (state->flags & (SDL_INIT_VIDEO | SDL_INIT_AUDIO)) { + case SDL_INIT_VIDEO: + return VIDEO_USAGE; + case SDL_INIT_AUDIO: + return AUDIO_USAGE; + case (SDL_INIT_VIDEO | SDL_INIT_AUDIO): + return VIDEO_USAGE " " AUDIO_USAGE; + default: + return ""; + } +} + +static void +SDLTest_PrintRendererFlag(Uint32 flag) +{ + switch (flag) { + case SDL_RENDERER_PRESENTVSYNC: + fprintf(stderr, "PresentVSync"); + break; + case SDL_RENDERER_ACCELERATED: + fprintf(stderr, "Accelerated"); + break; + default: + fprintf(stderr, "0x%8.8x", flag); + break; + } +} + +static void +SDLTest_PrintPixelFormat(Uint32 format) +{ + switch (format) { + case SDL_PIXELFORMAT_UNKNOWN: + fprintf(stderr, "Unknwon"); + break; + case SDL_PIXELFORMAT_INDEX1LSB: + fprintf(stderr, "Index1LSB"); + break; + case SDL_PIXELFORMAT_INDEX1MSB: + fprintf(stderr, "Index1MSB"); + break; + case SDL_PIXELFORMAT_INDEX4LSB: + fprintf(stderr, "Index4LSB"); + break; + case SDL_PIXELFORMAT_INDEX4MSB: + fprintf(stderr, "Index4MSB"); + break; + case SDL_PIXELFORMAT_INDEX8: + fprintf(stderr, "Index8"); + break; + case SDL_PIXELFORMAT_RGB332: + fprintf(stderr, "RGB332"); + break; + case SDL_PIXELFORMAT_RGB444: + fprintf(stderr, "RGB444"); + break; + case SDL_PIXELFORMAT_RGB555: + fprintf(stderr, "RGB555"); + break; + case SDL_PIXELFORMAT_BGR555: + fprintf(stderr, "BGR555"); + break; + case SDL_PIXELFORMAT_ARGB4444: + fprintf(stderr, "ARGB4444"); + break; + case SDL_PIXELFORMAT_ABGR4444: + fprintf(stderr, "ABGR4444"); + break; + case SDL_PIXELFORMAT_ARGB1555: + fprintf(stderr, "ARGB1555"); + break; + case SDL_PIXELFORMAT_ABGR1555: + fprintf(stderr, "ABGR1555"); + break; + case SDL_PIXELFORMAT_RGB565: + fprintf(stderr, "RGB565"); + break; + case SDL_PIXELFORMAT_BGR565: + fprintf(stderr, "BGR565"); + break; + case SDL_PIXELFORMAT_RGB24: + fprintf(stderr, "RGB24"); + break; + case SDL_PIXELFORMAT_BGR24: + fprintf(stderr, "BGR24"); + break; + case SDL_PIXELFORMAT_RGB888: + fprintf(stderr, "RGB888"); + break; + case SDL_PIXELFORMAT_BGR888: + fprintf(stderr, "BGR888"); + break; + case SDL_PIXELFORMAT_ARGB8888: + fprintf(stderr, "ARGB8888"); + break; + case SDL_PIXELFORMAT_RGBA8888: + fprintf(stderr, "RGBA8888"); + break; + case SDL_PIXELFORMAT_ABGR8888: + fprintf(stderr, "ABGR8888"); + break; + case SDL_PIXELFORMAT_BGRA8888: + fprintf(stderr, "BGRA8888"); + break; + case SDL_PIXELFORMAT_ARGB2101010: + fprintf(stderr, "ARGB2101010"); + break; + case SDL_PIXELFORMAT_YV12: + fprintf(stderr, "YV12"); + break; + case SDL_PIXELFORMAT_IYUV: + fprintf(stderr, "IYUV"); + break; + case SDL_PIXELFORMAT_YUY2: + fprintf(stderr, "YUY2"); + break; + case SDL_PIXELFORMAT_UYVY: + fprintf(stderr, "UYVY"); + break; + case SDL_PIXELFORMAT_YVYU: + fprintf(stderr, "YVYU"); + break; + default: + fprintf(stderr, "0x%8.8x", format); + break; + } +} + +static void +SDLTest_PrintRenderer(SDL_RendererInfo * info) +{ + int i, count; + + fprintf(stderr, " Renderer %s:\n", info->name); + + fprintf(stderr, " Flags: 0x%8.8X", info->flags); + fprintf(stderr, " ("); + count = 0; + for (i = 0; i < sizeof(info->flags) * 8; ++i) { + Uint32 flag = (1 << i); + if (info->flags & flag) { + if (count > 0) { + fprintf(stderr, " | "); + } + SDLTest_PrintRendererFlag(flag); + ++count; + } + } + fprintf(stderr, ")\n"); + + fprintf(stderr, " Texture formats (%d): ", info->num_texture_formats); + for (i = 0; i < (int) info->num_texture_formats; ++i) { + if (i > 0) { + fprintf(stderr, ", "); + } + SDLTest_PrintPixelFormat(info->texture_formats[i]); + } + fprintf(stderr, "\n"); + + if (info->max_texture_width || info->max_texture_height) { + fprintf(stderr, " Max Texture Size: %dx%d\n", + info->max_texture_width, info->max_texture_height); + } +} + +static SDL_Surface * +SDLTest_LoadIcon(const char *file) +{ + SDL_Surface *icon; + + /* Load the icon surface */ + icon = SDL_LoadBMP(file); + if (icon == NULL) { + fprintf(stderr, "Couldn't load %s: %s\n", file, SDL_GetError()); + return (NULL); + } + + if (icon->format->palette) { + /* Set the colorkey */ + SDL_SetColorKey(icon, 1, *((Uint8 *) icon->pixels)); + } + + return (icon); +} + +SDL_bool +SDLTest_CommonInit(SDLTest_CommonState * state) +{ + int i, j, m, n, w, h; + SDL_DisplayMode fullscreen_mode; + + if (state->flags & SDL_INIT_VIDEO) { + if (state->verbose & VERBOSE_VIDEO) { + n = SDL_GetNumVideoDrivers(); + if (n == 0) { + fprintf(stderr, "No built-in video drivers\n"); + } else { + fprintf(stderr, "Built-in video drivers:"); + for (i = 0; i < n; ++i) { + if (i > 0) { + fprintf(stderr, ","); + } + fprintf(stderr, " %s", SDL_GetVideoDriver(i)); + } + fprintf(stderr, "\n"); + } + } + if (SDL_VideoInit(state->videodriver) < 0) { + fprintf(stderr, "Couldn't initialize video driver: %s\n", + SDL_GetError()); + return SDL_FALSE; + } + if (state->verbose & VERBOSE_VIDEO) { + fprintf(stderr, "Video driver: %s\n", + SDL_GetCurrentVideoDriver()); + } + + /* Upload GL settings */ + SDL_GL_SetAttribute(SDL_GL_RED_SIZE, state->gl_red_size); + SDL_GL_SetAttribute(SDL_GL_GREEN_SIZE, state->gl_green_size); + SDL_GL_SetAttribute(SDL_GL_BLUE_SIZE, state->gl_blue_size); + SDL_GL_SetAttribute(SDL_GL_ALPHA_SIZE, state->gl_alpha_size); + SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, state->gl_double_buffer); + SDL_GL_SetAttribute(SDL_GL_BUFFER_SIZE, state->gl_buffer_size); + SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, state->gl_depth_size); + SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, state->gl_stencil_size); + SDL_GL_SetAttribute(SDL_GL_ACCUM_RED_SIZE, state->gl_accum_red_size); + SDL_GL_SetAttribute(SDL_GL_ACCUM_GREEN_SIZE, state->gl_accum_green_size); + SDL_GL_SetAttribute(SDL_GL_ACCUM_BLUE_SIZE, state->gl_accum_blue_size); + SDL_GL_SetAttribute(SDL_GL_ACCUM_ALPHA_SIZE, state->gl_accum_alpha_size); + SDL_GL_SetAttribute(SDL_GL_STEREO, state->gl_stereo); + SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, state->gl_multisamplebuffers); + SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, state->gl_multisamplesamples); + if (state->gl_accelerated >= 0) { + SDL_GL_SetAttribute(SDL_GL_ACCELERATED_VISUAL, + state->gl_accelerated); + } + SDL_GL_SetAttribute(SDL_GL_RETAINED_BACKING, state->gl_retained_backing); + if (state->gl_major_version) { + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, state->gl_major_version); + SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, state->gl_minor_version); + } + + if (state->verbose & VERBOSE_MODES) { + SDL_Rect bounds; + SDL_DisplayMode mode; + int bpp; + Uint32 Rmask, Gmask, Bmask, Amask; + + n = SDL_GetNumVideoDisplays(); + fprintf(stderr, "Number of displays: %d\n", n); + for (i = 0; i < n; ++i) { + fprintf(stderr, "Display %d:\n", i); + + SDL_zero(bounds); + SDL_GetDisplayBounds(i, &bounds); + fprintf(stderr, "Bounds: %dx%d at %d,%d\n", bounds.w, bounds.h, bounds.x, bounds.y); + + SDL_GetDesktopDisplayMode(i, &mode); + SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, &Gmask, + &Bmask, &Amask); + fprintf(stderr, + " Current mode: %dx%d@%dHz, %d bits-per-pixel (%s)\n", + mode.w, mode.h, mode.refresh_rate, bpp, + SDL_GetPixelFormatName(mode.format)); + if (Rmask || Gmask || Bmask) { + fprintf(stderr, " Red Mask = 0x%.8x\n", Rmask); + fprintf(stderr, " Green Mask = 0x%.8x\n", Gmask); + fprintf(stderr, " Blue Mask = 0x%.8x\n", Bmask); + if (Amask) + fprintf(stderr, " Alpha Mask = 0x%.8x\n", Amask); + } + + /* Print available fullscreen video modes */ + m = SDL_GetNumDisplayModes(i); + if (m == 0) { + fprintf(stderr, "No available fullscreen video modes\n"); + } else { + fprintf(stderr, " Fullscreen video modes:\n"); + for (j = 0; j < m; ++j) { + SDL_GetDisplayMode(i, j, &mode); + SDL_PixelFormatEnumToMasks(mode.format, &bpp, &Rmask, + &Gmask, &Bmask, &Amask); + fprintf(stderr, + " Mode %d: %dx%d@%dHz, %d bits-per-pixel (%s)\n", + j, mode.w, mode.h, mode.refresh_rate, bpp, + SDL_GetPixelFormatName(mode.format)); + if (Rmask || Gmask || Bmask) { + fprintf(stderr, " Red Mask = 0x%.8x\n", + Rmask); + fprintf(stderr, " Green Mask = 0x%.8x\n", + Gmask); + fprintf(stderr, " Blue Mask = 0x%.8x\n", + Bmask); + if (Amask) + fprintf(stderr, + " Alpha Mask = 0x%.8x\n", + Amask); + } + } + } + } + } + + if (state->verbose & VERBOSE_RENDER) { + SDL_RendererInfo info; + + n = SDL_GetNumRenderDrivers(); + if (n == 0) { + fprintf(stderr, "No built-in render drivers\n"); + } else { + fprintf(stderr, "Built-in render drivers:\n"); + for (i = 0; i < n; ++i) { + SDL_GetRenderDriverInfo(i, &info); + SDLTest_PrintRenderer(&info); + } + } + } + + SDL_zero(fullscreen_mode); + switch (state->depth) { + case 8: + fullscreen_mode.format = SDL_PIXELFORMAT_INDEX8; + break; + case 15: + fullscreen_mode.format = SDL_PIXELFORMAT_RGB555; + break; + case 16: + fullscreen_mode.format = SDL_PIXELFORMAT_RGB565; + break; + case 24: + fullscreen_mode.format = SDL_PIXELFORMAT_RGB24; + break; + default: + fullscreen_mode.format = SDL_PIXELFORMAT_RGB888; + break; + } + fullscreen_mode.refresh_rate = state->refresh_rate; + + state->windows = + (SDL_Window **) SDL_malloc(state->num_windows * + sizeof(*state->windows)); + state->renderers = + (SDL_Renderer **) SDL_malloc(state->num_windows * + sizeof(*state->renderers)); + if (!state->windows || !state->renderers) { + fprintf(stderr, "Out of memory!\n"); + return SDL_FALSE; + } + for (i = 0; i < state->num_windows; ++i) { + char title[1024]; + + if (state->num_windows > 1) { + SDL_snprintf(title, SDL_arraysize(title), "%s %d", + state->window_title, i + 1); + } else { + SDL_strlcpy(title, state->window_title, SDL_arraysize(title)); + } + state->windows[i] = + SDL_CreateWindow(title, state->window_x, state->window_y, + state->window_w, state->window_h, + state->window_flags); + if (!state->windows[i]) { + fprintf(stderr, "Couldn't create window: %s\n", + SDL_GetError()); + return SDL_FALSE; + } + SDL_GetWindowSize(state->windows[i], &w, &h); + if (!(state->window_flags & SDL_WINDOW_RESIZABLE) && + (w != state->window_w || h != state->window_h)) { + printf("Window requested size %dx%d, got %dx%d\n", state->window_w, state->window_h, w, h); + state->window_w = w; + state->window_h = h; + } + if (SDL_SetWindowDisplayMode(state->windows[i], &fullscreen_mode) < 0) { + fprintf(stderr, "Can't set up fullscreen display mode: %s\n", + SDL_GetError()); + return SDL_FALSE; + } + + if (state->window_icon) { + SDL_Surface *icon = SDLTest_LoadIcon(state->window_icon); + if (icon) { + SDL_SetWindowIcon(state->windows[i], icon); + SDL_FreeSurface(icon); + } + } + + SDL_ShowWindow(state->windows[i]); + + state->renderers[i] = NULL; + + if (!state->skip_renderer + && (state->renderdriver + || !(state->window_flags & SDL_WINDOW_OPENGL))) { + m = -1; + if (state->renderdriver) { + SDL_RendererInfo info; + n = SDL_GetNumRenderDrivers(); + for (j = 0; j < n; ++j) { + SDL_GetRenderDriverInfo(j, &info); + if (SDL_strcasecmp(info.name, state->renderdriver) == + 0) { + m = j; + break; + } + } + if (m == n) { + fprintf(stderr, + "Couldn't find render driver named %s", + state->renderdriver); + return SDL_FALSE; + } + } + state->renderers[i] = SDL_CreateRenderer(state->windows[i], + m, state->render_flags); + if (!state->renderers[i]) { + fprintf(stderr, "Couldn't create renderer: %s\n", + SDL_GetError()); + return SDL_FALSE; + } + if (state->verbose & VERBOSE_RENDER) { + SDL_RendererInfo info; + + fprintf(stderr, "Current renderer:\n"); + SDL_GetRendererInfo(state->renderers[i], &info); + SDLTest_PrintRenderer(&info); + } + } + } + } + + if (state->flags & SDL_INIT_AUDIO) { + if (state->verbose & VERBOSE_AUDIO) { + n = SDL_GetNumAudioDrivers(); + if (n == 0) { + fprintf(stderr, "No built-in audio drivers\n"); + } else { + fprintf(stderr, "Built-in audio drivers:"); + for (i = 0; i < n; ++i) { + if (i > 0) { + fprintf(stderr, ","); + } + fprintf(stderr, " %s", SDL_GetAudioDriver(i)); + } + fprintf(stderr, "\n"); + } + } + if (SDL_AudioInit(state->audiodriver) < 0) { + fprintf(stderr, "Couldn't initialize audio driver: %s\n", + SDL_GetError()); + return SDL_FALSE; + } + if (state->verbose & VERBOSE_VIDEO) { + fprintf(stderr, "Audio driver: %s\n", + SDL_GetCurrentAudioDriver()); + } + + if (SDL_OpenAudio(&state->audiospec, NULL) < 0) { + fprintf(stderr, "Couldn't open audio: %s\n", SDL_GetError()); + return SDL_FALSE; + } + } + + return SDL_TRUE; +} + +static void +SDLTest_PrintEvent(SDL_Event * event) +{ + if (event->type == SDL_MOUSEMOTION) { + /* Mouse motion is really spammy */ + //return; + } + + fprintf(stderr, "SDL EVENT: "); + switch (event->type) { + case SDL_WINDOWEVENT: + switch (event->window.event) { + case SDL_WINDOWEVENT_SHOWN: + fprintf(stderr, "Window %d shown", event->window.windowID); + break; + case SDL_WINDOWEVENT_HIDDEN: + fprintf(stderr, "Window %d hidden", event->window.windowID); + break; + case SDL_WINDOWEVENT_EXPOSED: + fprintf(stderr, "Window %d exposed", event->window.windowID); + break; + case SDL_WINDOWEVENT_MOVED: + fprintf(stderr, "Window %d moved to %d,%d", + event->window.windowID, event->window.data1, + event->window.data2); + break; + case SDL_WINDOWEVENT_RESIZED: + fprintf(stderr, "Window %d resized to %dx%d", + event->window.windowID, event->window.data1, + event->window.data2); + break; + case SDL_WINDOWEVENT_SIZE_CHANGED: + fprintf(stderr, "Window %d changed size to %dx%d", + event->window.windowID, event->window.data1, + event->window.data2); + break; + case SDL_WINDOWEVENT_MINIMIZED: + fprintf(stderr, "Window %d minimized", event->window.windowID); + break; + case SDL_WINDOWEVENT_MAXIMIZED: + fprintf(stderr, "Window %d maximized", event->window.windowID); + break; + case SDL_WINDOWEVENT_RESTORED: + fprintf(stderr, "Window %d restored", event->window.windowID); + break; + case SDL_WINDOWEVENT_ENTER: + fprintf(stderr, "Mouse entered window %d", + event->window.windowID); + break; + case SDL_WINDOWEVENT_LEAVE: + fprintf(stderr, "Mouse left window %d", event->window.windowID); + break; + case SDL_WINDOWEVENT_FOCUS_GAINED: + fprintf(stderr, "Window %d gained keyboard focus", + event->window.windowID); + break; + case SDL_WINDOWEVENT_FOCUS_LOST: + fprintf(stderr, "Window %d lost keyboard focus", + event->window.windowID); + break; + case SDL_WINDOWEVENT_CLOSE: + fprintf(stderr, "Window %d closed", event->window.windowID); + break; + default: + fprintf(stderr, "Window %d got unknown event %d", + event->window.windowID, event->window.event); + break; + } + break; + case SDL_KEYDOWN: + fprintf(stderr, + "Keyboard: key pressed in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s", + event->key.windowID, + event->key.keysym.scancode, + SDL_GetScancodeName(event->key.keysym.scancode), + event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym)); + break; + case SDL_KEYUP: + fprintf(stderr, + "Keyboard: key released in window %d: scancode 0x%08X = %s, keycode 0x%08X = %s", + event->key.windowID, + event->key.keysym.scancode, + SDL_GetScancodeName(event->key.keysym.scancode), + event->key.keysym.sym, SDL_GetKeyName(event->key.keysym.sym)); + break; + case SDL_TEXTINPUT: + fprintf(stderr, "Keyboard: text input \"%s\" in window %d", + event->text.text, event->text.windowID); + break; + case SDL_MOUSEMOTION: + fprintf(stderr, "Mouse: moved to %d,%d (%d,%d) in window %d", + event->motion.x, event->motion.y, + event->motion.xrel, event->motion.yrel, + event->motion.windowID); + break; + case SDL_MOUSEBUTTONDOWN: + fprintf(stderr, "Mouse: button %d pressed at %d,%d in window %d", + event->button.button, event->button.x, event->button.y, + event->button.windowID); + break; + case SDL_MOUSEBUTTONUP: + fprintf(stderr, "Mouse: button %d released at %d,%d in window %d", + event->button.button, event->button.x, event->button.y, + event->button.windowID); + break; + case SDL_MOUSEWHEEL: + fprintf(stderr, + "Mouse: wheel scrolled %d in x and %d in y in window %d", + event->wheel.x, event->wheel.y, event->wheel.windowID); + break; + case SDL_JOYBALLMOTION: + fprintf(stderr, "Joystick %d: ball %d moved by %d,%d", + event->jball.which, event->jball.ball, event->jball.xrel, + event->jball.yrel); + break; + case SDL_JOYHATMOTION: + fprintf(stderr, "Joystick %d: hat %d moved to ", event->jhat.which, + event->jhat.hat); + switch (event->jhat.value) { + case SDL_HAT_CENTERED: + fprintf(stderr, "CENTER"); + break; + case SDL_HAT_UP: + fprintf(stderr, "UP"); + break; + case SDL_HAT_RIGHTUP: + fprintf(stderr, "RIGHTUP"); + break; + case SDL_HAT_RIGHT: + fprintf(stderr, "RIGHT"); + break; + case SDL_HAT_RIGHTDOWN: + fprintf(stderr, "RIGHTDOWN"); + break; + case SDL_HAT_DOWN: + fprintf(stderr, "DOWN"); + break; + case SDL_HAT_LEFTDOWN: + fprintf(stderr, "LEFTDOWN"); + break; + case SDL_HAT_LEFT: + fprintf(stderr, "LEFT"); + break; + case SDL_HAT_LEFTUP: + fprintf(stderr, "LEFTUP"); + break; + default: + fprintf(stderr, "UNKNOWN"); + break; + } + break; + case SDL_JOYBUTTONDOWN: + fprintf(stderr, "Joystick %d: button %d pressed", + event->jbutton.which, event->jbutton.button); + break; + case SDL_JOYBUTTONUP: + fprintf(stderr, "Joystick %d: button %d released", + event->jbutton.which, event->jbutton.button); + break; + case SDL_CLIPBOARDUPDATE: + fprintf(stderr, "Clipboard updated"); + break; + case SDL_QUIT: + fprintf(stderr, "Quit requested"); + break; + case SDL_USEREVENT: + fprintf(stderr, "User event %d", event->user.code); + break; + default: + fprintf(stderr, "Unknown event %d", event->type); + break; + } + fprintf(stderr, "\n"); +} + +static void +SDLTest_ScreenShot(SDL_Renderer *renderer) +{ + SDL_Rect viewport; + SDL_Surface *surface; + + if (!renderer) { + return; + } + + SDL_RenderGetViewport(renderer, &viewport); + surface = SDL_CreateRGBSurface(0, viewport.w, viewport.h, 24, +#if SDL_BYTEORDER == SDL_LIL_ENDIAN + 0x00FF0000, 0x0000FF00, 0x000000FF, +#else + 0x000000FF, 0x0000FF00, 0x00FF0000, +#endif + 0x00000000); + if (!surface) { + fprintf(stderr, "Couldn't create surface: %s\n", SDL_GetError()); + return; + } + + if (SDL_RenderReadPixels(renderer, NULL, surface->format->format, + surface->pixels, surface->pitch) < 0) { + fprintf(stderr, "Couldn't read screen: %s\n", SDL_GetError()); + return; + } + + if (SDL_SaveBMP(surface, "screenshot.bmp") < 0) { + fprintf(stderr, "Couldn't save screenshot.bmp: %s\n", SDL_GetError()); + return; + } +} + +void +SDLTest_CommonEvent(SDLTest_CommonState * state, SDL_Event * event, int *done) +{ + int i; + + if (state->verbose & VERBOSE_EVENT) { + SDLTest_PrintEvent(event); + } + + switch (event->type) { + case SDL_WINDOWEVENT: + switch (event->window.event) { + case SDL_WINDOWEVENT_SIZE_CHANGED: + { + SDL_Window *window = SDL_GetWindowFromID(event->window.windowID); + if (window) { + for (i = 0; i < state->num_windows; ++i) { + if (window == state->windows[i] && + (state->window_flags & SDL_WINDOW_RESIZABLE)) { + SDL_Rect viewport; + + viewport.x = 0; + viewport.y = 0; + SDL_GetWindowSize(window, &viewport.w, &viewport.h); + SDL_RenderSetViewport(state->renderers[i], &viewport); + } + } + } + } + break; + case SDL_WINDOWEVENT_CLOSE: + { + SDL_Window *window = SDL_GetWindowFromID(event->window.windowID); + if (window) { + SDL_DestroyWindow(window); + } + } + break; + } + break; + case SDL_KEYDOWN: + switch (event->key.keysym.sym) { + /* Add hotkeys here */ + case SDLK_PRINTSCREEN: { + SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); + if (window) { + for (i = 0; i < state->num_windows; ++i) { + if (window == state->windows[i]) { + SDLTest_ScreenShot(state->renderers[i]); + } + } + } + } + break; + case SDLK_EQUALS: + if (event->key.keysym.mod & KMOD_CTRL) { + /* Ctrt-+ double the size of the window */ + SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); + if (window) { + int w, h; + SDL_GetWindowSize(window, &w, &h); + SDL_SetWindowSize(window, w*2, h*2); + } + } + break; + case SDLK_MINUS: + if (event->key.keysym.mod & KMOD_CTRL) { + /* Ctrt-- double the size of the window */ + SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); + if (window) { + int w, h; + SDL_GetWindowSize(window, &w, &h); + SDL_SetWindowSize(window, w/2, h/2); + } + } + break; + case SDLK_c: + if (event->key.keysym.mod & KMOD_CTRL) { + /* Ctrl-C copy awesome text! */ + SDL_SetClipboardText("SDL rocks!\nYou know it!"); + printf("Copied text to clipboard\n"); + } + break; + case SDLK_v: + if (event->key.keysym.mod & KMOD_CTRL) { + /* Ctrl-V paste awesome text! */ + char *text = SDL_GetClipboardText(); + if (*text) { + printf("Clipboard: %s\n", text); + } else { + printf("Clipboard is empty\n"); + } + SDL_free(text); + } + break; + case SDLK_g: + if (event->key.keysym.mod & KMOD_CTRL) { + /* Ctrl-G toggle grab */ + SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); + if (window) { + SDL_SetWindowGrab(window, !SDL_GetWindowGrab(window)); + } + } + break; + case SDLK_m: + if (event->key.keysym.mod & KMOD_CTRL) { + /* Ctrl-M maximize */ + SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); + if (window) { + Uint32 flags = SDL_GetWindowFlags(window); + if (flags & SDL_WINDOW_MAXIMIZED) { + SDL_RestoreWindow(window); + } else { + SDL_MaximizeWindow(window); + } + } + } + break; + case SDLK_r: + if (event->key.keysym.mod & KMOD_CTRL) { + /* Ctrl-R toggle mouse relative mode */ + SDL_SetRelativeMouseMode(!SDL_GetRelativeMouseMode()); + } + break; + case SDLK_z: + if (event->key.keysym.mod & KMOD_CTRL) { + /* Ctrl-Z minimize */ + SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); + if (window) { + SDL_MinimizeWindow(window); + } + } + break; + case SDLK_RETURN: + if (event->key.keysym.mod & KMOD_CTRL) { + /* Ctrl-Enter toggle fullscreen */ + SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); + if (window) { + Uint32 flags = SDL_GetWindowFlags(window); + if (flags & SDL_WINDOW_FULLSCREEN) { + SDL_SetWindowFullscreen(window, SDL_FALSE); + } else { + SDL_SetWindowFullscreen(window, SDL_TRUE); + } + } + } + break; + case SDLK_b: + if (event->key.keysym.mod & KMOD_CTRL) { + /* Ctrl-B toggle window border */ + SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); + if (window) { + const Uint32 flags = SDL_GetWindowFlags(window); + const SDL_bool b = ((flags & SDL_WINDOW_BORDERLESS) != 0); + SDL_SetWindowBordered(window, b); + } + } + break; + case SDLK_1: + if (event->key.keysym.mod & KMOD_CTRL) { + SDL_Window *window = SDL_GetWindowFromID(event->key.windowID); + SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_INFORMATION, "Test Message", "You're awesome!", window); + } + break; + case SDLK_ESCAPE: + *done = 1; + break; + default: + break; + } + break; + case SDL_QUIT: + *done = 1; + break; + } +} + +void +SDLTest_CommonQuit(SDLTest_CommonState * state) +{ + int i; + + if (state->windows) { + SDL_free(state->windows); + } + if (state->renderers) { + for (i = 0; i < state->num_windows; ++i) { + if (state->renderers[i]) { + SDL_DestroyRenderer(state->renderers[i]); + } + } + SDL_free(state->renderers); + } + if (state->flags & SDL_INIT_VIDEO) { + SDL_VideoQuit(); + } + if (state->flags & SDL_INIT_AUDIO) { + SDL_AudioQuit(); + } + SDL_free(state); +} + +/* vi: set ts=4 sw=4 expandtab: */ diff --git a/src/test/SDL_test_harness.c b/src/test/SDL_test_harness.c index ccb8455f4..15b721f86 100644 --- a/src/test/SDL_test_harness.c +++ b/src/test/SDL_test_harness.c @@ -218,6 +218,7 @@ int SDLTest_RunTest(SDLTest_TestSuiteReference *testSuite, SDLTest_TestCaseReference *testCase, Uint64 execKey) { SDL_TimerID timer = 0; + int testResult = 0; if (testSuite==NULL || testCase==NULL || testSuite->name==NULL || testCase->name==NULL) { @@ -243,7 +244,7 @@ SDLTest_RunTest(SDLTest_TestSuiteReference *testSuite, SDLTest_TestCaseReference // Maybe run suite initalizer function if (testSuite->testSetUp) { testSuite->testSetUp(0x0); - if (SDLTest_AssertsFailed > 0) { + if (SDLTest_AssertSummaryToTestResult() == TEST_RESULT_FAILED) { SDLTest_LogError((char *)SDLTest_TestCheckFmt, testSuite->name, "Failed"); return TEST_RESULT_SETUP_FAILURE; } @@ -251,8 +252,9 @@ SDLTest_RunTest(SDLTest_TestSuiteReference *testSuite, SDLTest_TestCaseReference // Run test case function testCase->testCase(0x0); + testResult = SDLTest_AssertSummaryToTestResult(); - // Maybe run suite cleanup function + // Maybe run suite cleanup function (ignore failed asserts) if (testSuite->testTearDown) { testSuite->testTearDown(0x0); } @@ -266,19 +268,17 @@ SDLTest_RunTest(SDLTest_TestSuiteReference *testSuite, SDLTest_TestCaseReference SDLTest_Log("Fuzzer invocations: %d", SDLTest_GetFuzzerInvocationCount()); SDLTest_LogAssertSummary(); - // Analyze assert count to determine test case result - if (SDLTest_AssertsFailed > 0) { - SDLTest_LogError((char *)SDLTest_TestCheckFmt, testCase->name, "Failed"); - return TEST_RESULT_FAILED; - } else { - if (SDLTest_AssertsPassed > 0) { + // Analyze assert count to determine final test case result + switch (testResult) { + case TEST_RESULT_PASSED: + SDLTest_LogError((char *)SDLTest_TestCheckFmt, testCase->name, "Failed"); + case TEST_RESULT_FAILED: SDLTest_Log((char *)SDLTest_TestCheckFmt, testCase->name, "Passed"); - return TEST_RESULT_PASSED; - } else { + case TEST_RESULT_NO_ASSERT: SDLTest_LogError((char *)SDLTest_TestCheckFmt, testCase->name, "No Asserts"); - return TEST_RESULT_NO_ASSERT; - } } + + return testResult; } /* Prints summary of all suites/tests contained in the given reference */ @@ -329,7 +329,7 @@ SDLTest_RunSuites(SDLTest_TestSuiteReference *testSuites, char *userRunSeed, Uin int iterationCounter; SDLTest_TestSuiteReference *testSuite; SDLTest_TestCaseReference *testCase; - char *runSeed; + char *runSeed = NULL; Uint64 execKey; Uint32 runStartTicks; time_t runStartTimestamp;