Remove more reserved identifiers (#6925)

include/SDL3/SDL_assert.h

@@ -51,7 +51,7 @@ assert can have unique static variables associated with it.
 /* Don't include intrin.h here because it contains C++ code */
     extern void __cdecl __debugbreak(void);
     #define SDL_TriggerBreakpoint() __debugbreak()
-#elif _SDL_HAS_BUILTIN(__builtin_debugtrap)
+#elif SDL_HAS_BUILTIN(__builtin_debugtrap)
     #define SDL_TriggerBreakpoint() __builtin_debugtrap()
 #elif (defined(__GNUC__) || defined(__clang__)) && (defined(__i386__) || defined(__x86_64__))
     #define SDL_TriggerBreakpoint() __asm__ __volatile__ ( "int $3\n\t" )

include/SDL3/SDL_begin_code.h

@@ -154,18 +154,18 @@
 #define SDL_FALLTHROUGH [[fallthrough]]
 #else
 #if defined(__has_attribute)
-#define _HAS_FALLTHROUGH __has_attribute(__fallthrough__)
+#define SDL_HAS_FALLTHROUGH __has_attribute(__fallthrough__)
 #else
-#define _HAS_FALLTHROUGH 0
+#define SDL_HAS_FALLTHROUGH 0
 #endif /* __has_attribute */
-#if _HAS_FALLTHROUGH && \
+#if SDL_HAS_FALLTHROUGH && \
    ((defined(__GNUC__) && __GNUC__ >= 7) || \
     (defined(__clang_major__) && __clang_major__ >= 10))
 #define SDL_FALLTHROUGH __attribute__((__fallthrough__))
 #else
 #define SDL_FALLTHROUGH do {} while (0) /* fallthrough */
-#endif /* _HAS_FALLTHROUGH */
-#undef _HAS_FALLTHROUGH
+#endif /* SDL_HAS_FALLTHROUGH */
+#undef SDL_HAS_FALLTHROUGH
 #endif /* C++17 or C2x */
 #endif /* SDL_FALLTHROUGH not defined */
 

include/SDL3/SDL_endian.h

@@ -122,11 +122,11 @@ extern "C" {
 
 /* various modern compilers may have builtin swap */
 #if defined(__GNUC__) || defined(__clang__)
-#   define HAS_BUILTIN_BSWAP16 (_SDL_HAS_BUILTIN(__builtin_bswap16)) || \
+#   define HAS_BUILTIN_BSWAP16 (SDL_HAS_BUILTIN(__builtin_bswap16)) || \
         (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 8))
-#   define HAS_BUILTIN_BSWAP32 (_SDL_HAS_BUILTIN(__builtin_bswap32)) || \
+#   define HAS_BUILTIN_BSWAP32 (SDL_HAS_BUILTIN(__builtin_bswap32)) || \
         (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
-#   define HAS_BUILTIN_BSWAP64 (_SDL_HAS_BUILTIN(__builtin_bswap64)) || \
+#   define HAS_BUILTIN_BSWAP64 (SDL_HAS_BUILTIN(__builtin_bswap64)) || \
         (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 3))
 
     /* this one is broken */

include/SDL3/SDL_stdinc.h

@@ -72,9 +72,9 @@ char *alloca();
  * instead of checking the clang version if possible.
  */
 #ifdef __has_builtin
-#define _SDL_HAS_BUILTIN(x) __has_builtin(x)
+#define SDL_HAS_BUILTIN(x) __has_builtin(x)
 #else
-#define _SDL_HAS_BUILTIN(x) 0
+#define SDL_HAS_BUILTIN(x) 0
 #endif
 
 /**
@@ -694,7 +694,7 @@ SDL_FORCE_INLINE int SDL_size_mul_overflow (size_t a,
     return 0;
 }
 
-#if _SDL_HAS_BUILTIN(__builtin_mul_overflow)
+#if SDL_HAS_BUILTIN(__builtin_mul_overflow)
 /* This needs to be wrapped in an inline rather than being a direct #define,
  * because __builtin_mul_overflow() is type-generic, but we want to be
  * consistent about interpreting a and b as size_t. */
@@ -724,7 +724,7 @@ SDL_FORCE_INLINE int SDL_size_add_overflow (size_t a,
     return 0;
 }
 
-#if _SDL_HAS_BUILTIN(__builtin_add_overflow)
+#if SDL_HAS_BUILTIN(__builtin_add_overflow)
 /* This needs to be wrapped in an inline rather than being a direct #define,
  * the same as the call to __builtin_mul_overflow() above. */
 SDL_FORCE_INLINE int SDL_size_add_overflow_builtin (size_t a,

src/audio/SDL_audiodev.c

@@ -31,18 +31,18 @@
 
 #include "SDL_audiodev_c.h"
 
-#ifndef _PATH_DEV_DSP
+#ifndef SDL_PATH_DEV_DSP
 #if defined(__NETBSD__) || defined(__OPENBSD__)
-#define _PATH_DEV_DSP "/dev/audio"
+#define SDL_PATH_DEV_DSP "/dev/audio"
 #else
-#define _PATH_DEV_DSP "/dev/dsp"
+#define SDL_PATH_DEV_DSP "/dev/dsp"
 #endif
 #endif
-#ifndef _PATH_DEV_DSP24
-#define _PATH_DEV_DSP24 "/dev/sound/dsp"
+#ifndef SDL_PATH_DEV_DSP24
+#define SDL_PATH_DEV_DSP24 "/dev/sound/dsp"
 #endif
-#ifndef _PATH_DEV_AUDIO
-#define _PATH_DEV_AUDIO "/dev/audio"
+#ifndef SDL_PATH_DEV_AUDIO
+#define SDL_PATH_DEV_AUDIO "/dev/audio"
 #endif
 
 static void test_device(const int iscapture, const char *fname, int flags, int (*test)(int fd))
@@ -91,15 +91,15 @@ static void SDL_EnumUnixAudioDevices_Internal(const int iscapture, const int cla
     }
     if (audiodev == NULL) {
         if (classic) {
-            audiodev = _PATH_DEV_AUDIO;
+            audiodev = SDL_PATH_DEV_AUDIO;
         } else {
             struct stat sb;
 
             /* Added support for /dev/sound/\* in Linux 2.4 */
-            if (((stat("/dev/sound", &sb) == 0) && S_ISDIR(sb.st_mode)) && ((stat(_PATH_DEV_DSP24, &sb) == 0) && S_ISCHR(sb.st_mode))) {
-                audiodev = _PATH_DEV_DSP24;
+            if (((stat("/dev/sound", &sb) == 0) && S_ISDIR(sb.st_mode)) && ((stat(SDL_PATH_DEV_DSP24, &sb) == 0) && S_ISCHR(sb.st_mode))) {
+                audiodev = SDL_PATH_DEV_DSP24;
             } else {
-                audiodev = _PATH_DEV_DSP;
+                audiodev = SDL_PATH_DEV_DSP;
             }
         }
     }

src/core/linux/SDL_fcitx.c

@@ -41,7 +41,7 @@
 
 #define DBUS_TIMEOUT 500
 
-typedef struct _FcitxClient
+typedef struct FcitxClient
 {
     SDL_DBusContext *dbus;
 

src/core/linux/SDL_ime.c

@@ -24,21 +24,21 @@
 #include "SDL_ibus.h"
 #include "SDL_fcitx.h"
 
-typedef SDL_bool (*_SDL_IME_Init)(void);
-typedef void (*_SDL_IME_Quit)(void);
-typedef void (*_SDL_IME_SetFocus)(SDL_bool);
-typedef void (*_SDL_IME_Reset)(void);
-typedef SDL_bool (*_SDL_IME_ProcessKeyEvent)(Uint32, Uint32, Uint8 state);
-typedef void (*_SDL_IME_UpdateTextRect)(const SDL_Rect *);
-typedef void (*_SDL_IME_PumpEvents)(void);
-
-static _SDL_IME_Init SDL_IME_Init_Real = NULL;
-static _SDL_IME_Quit SDL_IME_Quit_Real = NULL;
-static _SDL_IME_SetFocus SDL_IME_SetFocus_Real = NULL;
-static _SDL_IME_Reset SDL_IME_Reset_Real = NULL;
-static _SDL_IME_ProcessKeyEvent SDL_IME_ProcessKeyEvent_Real = NULL;
-static _SDL_IME_UpdateTextRect SDL_IME_UpdateTextRect_Real = NULL;
-static _SDL_IME_PumpEvents SDL_IME_PumpEvents_Real = NULL;
+typedef SDL_bool (*SDL_IME_Init_t)(void);
+typedef void (*SDL_IME_Quit_t)(void);
+typedef void (*SDL_IME_SetFocus_t)(SDL_bool);
+typedef void (*SDL_IME_Reset_t)(void);
+typedef SDL_bool (*SDL_IME_ProcessKeyEvent_t)(Uint32, Uint32, Uint8 state);
+typedef void (*SDL_IME_UpdateTextRect_t)(const SDL_Rect *);
+typedef void (*SDL_IME_PumpEvents_t)(void);
+
+static SDL_IME_Init_t SDL_IME_Init_Real = NULL;
+static SDL_IME_Quit_t SDL_IME_Quit_Real = NULL;
+static SDL_IME_SetFocus_t SDL_IME_SetFocus_Real = NULL;
+static SDL_IME_Reset_t SDL_IME_Reset_Real = NULL;
+static SDL_IME_ProcessKeyEvent_t SDL_IME_ProcessKeyEvent_Real = NULL;
+static SDL_IME_UpdateTextRect_t SDL_IME_UpdateTextRect_Real = NULL;
+static SDL_IME_PumpEvents_t SDL_IME_PumpEvents_Real = NULL;
 
 static void InitIME()
 {

src/events/SDL_events.c

@@ -68,18 +68,18 @@ static SDL_DisabledEventBlock *SDL_disabled_events[256];
 static Uint32 SDL_userevents = SDL_USEREVENT;
 
 /* Private data -- event queue */
-typedef struct _SDL_EventEntry
+typedef struct SDL_EventEntry
 {
     SDL_Event event;
     SDL_SysWMmsg msg;
-    struct _SDL_EventEntry *prev;
-    struct _SDL_EventEntry *next;
+    struct SDL_EventEntry *prev;
+    struct SDL_EventEntry *next;
 } SDL_EventEntry;
 
-typedef struct _SDL_SysWMEntry
+typedef struct SDL_SysWMEntry
 {
     SDL_SysWMmsg msg;
-    struct _SDL_SysWMEntry *next;
+    struct SDL_SysWMEntry *next;
 } SDL_SysWMEntry;
 
 static struct

src/joystick/apple/SDL_mfijoystick.m

@@ -622,7 +622,7 @@ static void SDLCALL SDL_AppleTVRemoteRotationHintChanged(void *udata, const char
 static int IOS_JoystickInit(void)
 {
 #if defined(__MACOS__)
-#if _SDL_HAS_BUILTIN(__builtin_available)
+#if SDL_HAS_BUILTIN(__builtin_available)
     if (@available(macOS 10.16, *)) {
         /* Continue with initialization on macOS 11+ */
     } else {

src/joystick/hidapi/SDL_hidapijoystick_c.h

@@ -46,9 +46,9 @@
 #define USB_PACKET_LENGTH 64
 
 /* Forward declaration */
-struct _SDL_HIDAPI_DeviceDriver;
+struct SDL_HIDAPI_DeviceDriver;
 
-typedef struct _SDL_HIDAPI_Device
+typedef struct SDL_HIDAPI_Device
 {
     char *name;
     char *path;
@@ -67,7 +67,7 @@ typedef struct _SDL_HIDAPI_Device
     SDL_JoystickType joystick_type;
     SDL_GamepadType type;
 
-    struct _SDL_HIDAPI_DeviceDriver *driver;
+    struct SDL_HIDAPI_DeviceDriver *driver;
     void *context;
     SDL_mutex *dev_lock;
     SDL_hid_device *dev;
@@ -81,14 +81,14 @@ typedef struct _SDL_HIDAPI_Device
     /* Used to flag that the device is being updated */
     SDL_bool updating;
 
-    struct _SDL_HIDAPI_Device *parent;
+    struct SDL_HIDAPI_Device *parent;
     int num_children;
-    struct _SDL_HIDAPI_Device **children;
+    struct SDL_HIDAPI_Device **children;
 
-    struct _SDL_HIDAPI_Device *next;
+    struct SDL_HIDAPI_Device *next;
 } SDL_HIDAPI_Device;
 
-typedef struct _SDL_HIDAPI_DeviceDriver
+typedef struct SDL_HIDAPI_DeviceDriver
 {
     const char *name;
     SDL_bool enabled;

src/joystick/windows/SDL_rawinputjoystick.c

@@ -93,7 +93,7 @@ static int SDL_RAWINPUT_numjoysticks = 0;
 
 static void RAWINPUT_JoystickClose(SDL_Joystick *joystick);
 
-typedef struct _SDL_RAWINPUT_Device
+typedef struct SDL_RAWINPUT_Device
 {
     SDL_atomic_t refcount;
     char *name;
@@ -110,7 +110,7 @@ typedef struct _SDL_RAWINPUT_Device
     SDL_Joystick *joystick;
     SDL_JoystickID joystick_id;
 
-    struct _SDL_RAWINPUT_Device *next;
+    struct SDL_RAWINPUT_Device *next;
 } SDL_RAWINPUT_Device;
 
 struct joystick_hwdata

src/sensor/SDL_sensor_c.h

@@ -23,7 +23,7 @@
 #ifndef SDL_sensor_c_h_
 #define SDL_sensor_c_h_
 
-struct _SDL_SensorDriver;
+struct SDL_SensorDriver;
 
 /* Useful functions and variables from SDL_sensor.c */
 

src/sensor/SDL_syssensor.h

@@ -37,7 +37,7 @@ struct SDL_Sensor
 
     float data[16];             /* The current state of the sensor */
 
-    struct _SDL_SensorDriver *driver;
+    struct SDL_SensorDriver *driver;
 
     struct sensor_hwdata *hwdata; /* Driver dependent information */
 
@@ -46,7 +46,7 @@ struct SDL_Sensor
     struct SDL_Sensor *next; /* pointer to next sensor we have allocated */
 };
 
-typedef struct _SDL_SensorDriver
+typedef struct SDL_SensorDriver
 {
     /* Function to scan the system for sensors.
      * sensor 0 should be the system default sensor.

src/timer/SDL_timer.c

@@ -27,7 +27,7 @@
 
 #if !defined(__EMSCRIPTEN__) || !SDL_THREADS_DISABLED
 
-typedef struct _SDL_Timer
+typedef struct SDL_Timer
 {
     int timerID;
     SDL_TimerCallback callback;
@@ -35,14 +35,14 @@ typedef struct _SDL_Timer
     Uint64 interval;
     Uint64 scheduled;
     SDL_atomic_t canceled;
-    struct _SDL_Timer *next;
+    struct SDL_Timer *next;
 } SDL_Timer;
 
-typedef struct _SDL_TimerMap
+typedef struct SDL_TimerMap
 {
     int timerID;
     SDL_Timer *timer;
-    struct _SDL_TimerMap *next;
+    struct SDL_TimerMap *next;
 } SDL_TimerMap;
 
 /* The timers are kept in a sorted list */
@@ -370,14 +370,14 @@ SDL_bool SDL_RemoveTimer(SDL_TimerID id)
 #include <emscripten/emscripten.h>
 #include <emscripten/eventloop.h>
 
-typedef struct _SDL_TimerMap
+typedef struct SDL_TimerMap
 {
     int timerID;
     int timeoutID;
     Uint32 interval;
     SDL_TimerCallback callback;
     void *param;
-    struct _SDL_TimerMap *next;
+    struct SDL_TimerMap *next;
 } SDL_TimerMap;
 
 typedef struct

src/video/kmsdrm/SDL_kmsdrmmouse.h

@@ -29,7 +29,7 @@
 #define MAX_CURSOR_W 512
 #define MAX_CURSOR_H 512
 
-typedef struct _KMSDRM_CursorData
+typedef struct KMSDRM_CursorData
 {
     int hot_x, hot_y;
     int w, h;

test/testautomation_audio.c

@@ -17,7 +17,7 @@
 
 /* Fixture */
 
-void _audioSetUp(void *arg)
+static void audioSetUp(void *arg)
 {
     /* Start SDL audio subsystem */
     int ret = SDL_InitSubSystem(SDL_INIT_AUDIO);
@@ -28,7 +28,7 @@ void _audioSetUp(void *arg)
     }
 }
 
-void _audioTearDown(void *arg)
+static void audioTearDown(void *arg)
 {
     /* Remove a possibly created file from SDL disk writer audio driver; ignore errors */
     (void)remove("sdlaudio.raw");
@@ -37,17 +37,17 @@ void _audioTearDown(void *arg)
 }
 
 /* Global counter for callback invocation */
-int _audio_testCallbackCounter;
+static int g_audio_testCallbackCounter;
 
 /* Global accumulator for total callback length */
-int _audio_testCallbackLength;
+static int g_audio_testCallbackLength;
 
 /* Test callback function */
-void SDLCALL _audio_testCallback(void *userdata, Uint8 *stream, int len)
+static void SDLCALL audio_testCallback(void *userdata, Uint8 *stream, int len)
 {
     /* track that callback was called */
-    _audio_testCallbackCounter++;
-    _audio_testCallbackLength += len;
+    g_audio_testCallbackCounter++;
+    g_audio_testCallbackLength += len;
 }
 
 /* Test case functions */
@@ -65,7 +65,7 @@ int audio_quitInitAudioSubSystem()
     SDLTest_AssertPass("Call to SDL_QuitSubSystem(SDL_INIT_AUDIO)");
 
     /* Restart audio again */
-    _audioSetUp(NULL);
+    audioSetUp(NULL);
 
     return TEST_COMPLETED;
 }
@@ -121,7 +121,7 @@ int audio_initQuitAudio()
     SDLTest_AssertPass("Call to SDL_QuitSubSystem(SDL_INIT_AUDIO)");
 
     /* Restart audio again */
-    _audioSetUp(NULL);
+    audioSetUp(NULL);
 
     return TEST_COMPLETED;
 }
@@ -173,7 +173,7 @@ int audio_initOpenCloseQuitAudio()
                 desired.format = AUDIO_S16SYS;
                 desired.channels = 2;
                 desired.samples = 4096;
-                desired.callback = _audio_testCallback;
+                desired.callback = audio_testCallback;
                 desired.userdata = NULL;
 
             case 1:
@@ -182,7 +182,7 @@ int audio_initOpenCloseQuitAudio()
                 desired.format = AUDIO_F32SYS;
                 desired.channels = 2;
                 desired.samples = 2048;
-                desired.callback = _audio_testCallback;
+                desired.callback = audio_testCallback;
                 desired.userdata = NULL;
                 break;
             }
@@ -211,7 +211,7 @@ int audio_initOpenCloseQuitAudio()
     }     /* driver loop */
 
     /* Restart audio again */
-    _audioSetUp(NULL);
+    audioSetUp(NULL);
 
     return TEST_COMPLETED;
 }
@@ -263,7 +263,7 @@ int audio_pauseUnpauseAudio()
                 desired.format = AUDIO_S16SYS;
                 desired.channels = 2;
                 desired.samples = 4096;
-                desired.callback = _audio_testCallback;
+                desired.callback = audio_testCallback;
                 desired.userdata = NULL;
 
             case 1:
@@ -272,7 +272,7 @@ int audio_pauseUnpauseAudio()
                 desired.format = AUDIO_F32SYS;
                 desired.channels = 2;
                 desired.samples = 2048;
-                desired.callback = _audio_testCallback;
+                desired.callback = audio_testCallback;
                 desired.userdata = NULL;
                 break;
             }
@@ -287,8 +287,8 @@ int audio_pauseUnpauseAudio()
                 SDLTest_Log("Pause/Unpause iteration: %d", l + 1);
 
                 /* Reset callback counters */
-                _audio_testCallbackCounter = 0;
-                _audio_testCallbackLength = 0;
+                g_audio_testCallbackCounter = 0;
+                g_audio_testCallbackLength = 0;
 
                 /* Un-pause audio to start playing (maybe multiple times) */
                 pause_on = 0;
@@ -302,9 +302,9 @@ int audio_pauseUnpauseAudio()
                 do {
                     SDL_Delay(10);
                     totalDelay += 10;
-                } while (_audio_testCallbackCounter == 0 && totalDelay < 1000);
-                SDLTest_AssertCheck(_audio_testCallbackCounter > 0, "Verify callback counter; expected: >0 got: %d", _audio_testCallbackCounter);
-                SDLTest_AssertCheck(_audio_testCallbackLength > 0, "Verify callback length; expected: >0 got: %d", _audio_testCallbackLength);
+                } while (g_audio_testCallbackCounter == 0 && totalDelay < 1000);
+                SDLTest_AssertCheck(g_audio_testCallbackCounter > 0, "Verify callback counter; expected: >0 got: %d", g_audio_testCallbackCounter);
+                SDLTest_AssertCheck(g_audio_testCallbackLength > 0, "Verify callback length; expected: >0 got: %d", g_audio_testCallbackLength);
 
                 /* Pause audio to stop playing (maybe multiple times) */
                 for (k = 0; k <= j; k++) {
@@ -314,9 +314,9 @@ int audio_pauseUnpauseAudio()
                 }
 
                 /* Ensure callback is not called again */
-                originalCounter = _audio_testCallbackCounter;
+                originalCounter = g_audio_testCallbackCounter;
                 SDL_Delay(totalDelay + 10);
-                SDLTest_AssertCheck(originalCounter == _audio_testCallbackCounter, "Verify callback counter; expected: %d, got: %d", originalCounter, _audio_testCallbackCounter);
+                SDLTest_AssertCheck(originalCounter == g_audio_testCallbackCounter, "Verify callback counter; expected: %d, got: %d", originalCounter, g_audio_testCallbackCounter);
             }
 
             /* Call Close */
@@ -331,7 +331,7 @@ int audio_pauseUnpauseAudio()
     }     /* driver loop */
 
     /* Restart audio again */
-    _audioSetUp(NULL);
+    audioSetUp(NULL);
 
     return TEST_COMPLETED;
 }
@@ -490,17 +490,17 @@ int audio_printCurrentAudioDriver()
 }
 
 /* Definition of all formats, channels, and frequencies used to test audio conversions */
-const int _numAudioFormats = 18;
-SDL_AudioFormat _audioFormats[] = { AUDIO_S8, AUDIO_U8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_S16SYS, AUDIO_S16, AUDIO_U16LSB,
+const int g_numAudioFormats = 18;
+static SDL_AudioFormat g_audioFormats[] = { AUDIO_S8, AUDIO_U8, AUDIO_S16LSB, AUDIO_S16MSB, AUDIO_S16SYS, AUDIO_S16, AUDIO_U16LSB,
                                     AUDIO_U16MSB, AUDIO_U16SYS, AUDIO_U16, AUDIO_S32LSB, AUDIO_S32MSB, AUDIO_S32SYS, AUDIO_S32,
                                     AUDIO_F32LSB, AUDIO_F32MSB, AUDIO_F32SYS, AUDIO_F32 };
-const char *_audioFormatsVerbose[] = { "AUDIO_S8", "AUDIO_U8", "AUDIO_S16LSB", "AUDIO_S16MSB", "AUDIO_S16SYS", "AUDIO_S16", "AUDIO_U16LSB",
+const char *g_audioFormatsVerbose[] = { "AUDIO_S8", "AUDIO_U8", "AUDIO_S16LSB", "AUDIO_S16MSB", "AUDIO_S16SYS", "AUDIO_S16", "AUDIO_U16LSB",
                                        "AUDIO_U16MSB", "AUDIO_U16SYS", "AUDIO_U16", "AUDIO_S32LSB", "AUDIO_S32MSB", "AUDIO_S32SYS", "AUDIO_S32",
                                        "AUDIO_F32LSB", "AUDIO_F32MSB", "AUDIO_F32SYS", "AUDIO_F32" };
-const int _numAudioChannels = 4;
-Uint8 _audioChannels[] = { 1, 2, 4, 6 };
-const int _numAudioFrequencies = 4;
-int _audioFrequencies[] = { 11025, 22050, 44100, 48000 };
+const int g_numAudioChannels = 4;
+Uint8 g_audioChannels[] = { 1, 2, 4, 6 };
+const int g_numAudioFrequencies = 4;
+int g_audioFrequencies[] = { 11025, 22050, 44100, 48000 };
 
 /**
  * \brief Builds various audio conversion structures
@@ -537,22 +537,22 @@ int audio_buildAudioCVT()
     SDLTest_AssertCheck(result == 1, "Verify result value; expected: 1, got: %i", result);
 
     /* All source conversions with random conversion targets, allow 'null' conversions */
-    for (i = 0; i < _numAudioFormats; i++) {
-        for (j = 0; j < _numAudioChannels; j++) {
-            for (k = 0; k < _numAudioFrequencies; k++) {
-                spec1.format = _audioFormats[i];
-                spec1.channels = _audioChannels[j];
-                spec1.freq = _audioFrequencies[k];
-                ii = SDLTest_RandomIntegerInRange(0, _numAudioFormats - 1);
-                jj = SDLTest_RandomIntegerInRange(0, _numAudioChannels - 1);
-                kk = SDLTest_RandomIntegerInRange(0, _numAudioFrequencies - 1);
-                spec2.format = _audioFormats[ii];
-                spec2.channels = _audioChannels[jj];
-                spec2.freq = _audioFrequencies[kk];
+    for (i = 0; i < g_numAudioFormats; i++) {
+        for (j = 0; j < g_numAudioChannels; j++) {
+            for (k = 0; k < g_numAudioFrequencies; k++) {
+                spec1.format = g_audioFormats[i];
+                spec1.channels = g_audioChannels[j];
+                spec1.freq = g_audioFrequencies[k];
+                ii = SDLTest_RandomIntegerInRange(0, g_numAudioFormats - 1);
+                jj = SDLTest_RandomIntegerInRange(0, g_numAudioChannels - 1);
+                kk = SDLTest_RandomIntegerInRange(0, g_numAudioFrequencies - 1);
+                spec2.format = g_audioFormats[ii];
+                spec2.channels = g_audioChannels[jj];
+                spec2.freq = g_audioFrequencies[kk];
                 result = SDL_BuildAudioCVT(&cvt, spec1.format, spec1.channels, spec1.freq,
                                            spec2.format, spec2.channels, spec2.freq);
                 SDLTest_AssertPass("Call to SDL_BuildAudioCVT(format[%i]=%s(%i),channels[%i]=%i,freq[%i]=%i ==> format[%i]=%s(%i),channels[%i]=%i,freq[%i]=%i)",
-                                   i, _audioFormatsVerbose[i], spec1.format, j, spec1.channels, k, spec1.freq, ii, _audioFormatsVerbose[ii], spec2.format, jj, spec2.channels, kk, spec2.freq);
+                                   i, g_audioFormatsVerbose[i], spec1.format, j, spec1.channels, k, spec1.freq, ii, g_audioFormatsVerbose[ii], spec2.format, jj, spec2.channels, kk, spec2.freq);
                 SDLTest_AssertCheck(result == 0 || result == 1, "Verify result value; expected: 0 or 1, got: %i", result);
                 if (result < 0) {
                     SDLTest_LogError("%s", SDL_GetError());
@@ -712,7 +712,7 @@ int audio_openCloseAndGetAudioStatus()
             desired.format = AUDIO_S16SYS;
             desired.channels = 2;
             desired.samples = 4096;
-            desired.callback = _audio_testCallback;
+            desired.callback = audio_testCallback;
             desired.userdata = NULL;
 
             /* Open device */
@@ -772,7 +772,7 @@ int audio_lockUnlockOpenAudioDevice()
             desired.format = AUDIO_S16SYS;
             desired.channels = 2;
             desired.samples = 4096;
-            desired.callback = _audio_testCallback;
+            desired.callback = audio_testCallback;
             desired.userdata = NULL;
 
             /* Open device */
@@ -834,39 +834,39 @@ int audio_convertAudio()
         }
         SDLTest_Log("%s", message);
         /* All source conversions with random conversion targets */
-        for (i = 0; i < _numAudioFormats; i++) {
-            for (j = 0; j < _numAudioChannels; j++) {
-                for (k = 0; k < _numAudioFrequencies; k++) {
-                    spec1.format = _audioFormats[i];
-                    spec1.channels = _audioChannels[j];
-                    spec1.freq = _audioFrequencies[k];
+        for (i = 0; i < g_numAudioFormats; i++) {
+            for (j = 0; j < g_numAudioChannels; j++) {
+                for (k = 0; k < g_numAudioFrequencies; k++) {
+                    spec1.format = g_audioFormats[i];
+                    spec1.channels = g_audioChannels[j];
+                    spec1.freq = g_audioFrequencies[k];
 
                     /* Ensure we have a different target format */
                     do {
                         if (c & 1) {
-                            ii = SDLTest_RandomIntegerInRange(0, _numAudioFormats - 1);
+                            ii = SDLTest_RandomIntegerInRange(0, g_numAudioFormats - 1);
                         } else {
                             ii = 1;
                         }
                         if (c & 2) {
-                            jj = SDLTest_RandomIntegerInRange(0, _numAudioChannels - 1);
+                            jj = SDLTest_RandomIntegerInRange(0, g_numAudioChannels - 1);
                         } else {
                             jj = j;
                         }
                         if (c & 4) {
-                            kk = SDLTest_RandomIntegerInRange(0, _numAudioFrequencies - 1);
+                            kk = SDLTest_RandomIntegerInRange(0, g_numAudioFrequencies - 1);
                         } else {
                             kk = k;
                         }
                     } while ((i == ii) && (j == jj) && (k == kk));
-                    spec2.format = _audioFormats[ii];
-                    spec2.channels = _audioChannels[jj];
-                    spec2.freq = _audioFrequencies[kk];
+                    spec2.format = g_audioFormats[ii];
+                    spec2.channels = g_audioChannels[jj];
+                    spec2.freq = g_audioFrequencies[kk];
 
                     result = SDL_BuildAudioCVT(&cvt, spec1.format, spec1.channels, spec1.freq,
                                                spec2.format, spec2.channels, spec2.freq);
                     SDLTest_AssertPass("Call to SDL_BuildAudioCVT(format[%i]=%s(%i),channels[%i]=%i,freq[%i]=%i ==> format[%i]=%s(%i),channels[%i]=%i,freq[%i]=%i)",
-                                       i, _audioFormatsVerbose[i], spec1.format, j, spec1.channels, k, spec1.freq, ii, _audioFormatsVerbose[ii], spec2.format, jj, spec2.channels, kk, spec2.freq);
+                                       i, g_audioFormatsVerbose[i], spec1.format, j, spec1.channels, k, spec1.freq, ii, g_audioFormatsVerbose[ii], spec2.format, jj, spec2.channels, kk, spec2.freq);
                     SDLTest_AssertCheck(result == 1, "Verify result value; expected: 1, got: %i", result);
                     if (result != 1) {
                         SDLTest_LogError("%s", SDL_GetError());
@@ -938,7 +938,7 @@ int audio_openCloseAudioDeviceConnected()
             desired.format = AUDIO_S16SYS;
             desired.channels = 2;
             desired.samples = 4096;
-            desired.callback = _audio_testCallback;
+            desired.callback = audio_testCallback;
             desired.userdata = NULL;
 
             /* Open device */
@@ -1046,7 +1046,7 @@ static const SDLTest_TestCaseReference *audioTests[] = {
 /* Audio test suite (global) */
 SDLTest_TestSuiteReference audioTestSuite = {
     "Audio",
-    _audioSetUp,
+    audioSetUp,
     audioTests,
-    _audioTearDown
+    audioTearDown
 };

test/testautomation_events.c

@@ -9,27 +9,27 @@
 /* Test case functions */
 
 /* Flag indicating if the userdata should be checked */
-int _userdataCheck = 0;
+static int g_userdataCheck = 0;
 
 /* Userdata value to check */
-int _userdataValue = 0;
+static int g_userdataValue = 0;
 
 /* Flag indicating that the filter was called */
-int _eventFilterCalled = 0;
+static int g_eventFilterCalled = 0;
 
 /* Userdata values for event */
-int _userdataValue1 = 1;
-int _userdataValue2 = 2;
+static int g_userdataValue1 = 1;
+static int g_userdataValue2 = 2;
 
 /* Event filter that sets some flags and optionally checks userdata */
-int SDLCALL _events_sampleNullEventFilter(void *userdata, SDL_Event *event)
+static int SDLCALL events_sampleNullEventFilter(void *userdata, SDL_Event *event)
 {
-    _eventFilterCalled = 1;
+    g_eventFilterCalled = 1;
 
-    if (_userdataCheck != 0) {
+    if (g_userdataCheck != 0) {
         SDLTest_AssertCheck(userdata != NULL, "Check userdata pointer, expected: non-NULL, got: %s", (userdata != NULL) ? "non-NULL" : "NULL");
         if (userdata != NULL) {
-            SDLTest_AssertCheck(*(int *)userdata == _userdataValue, "Check userdata value, expected: %i, got: %i", _userdataValue, *(int *)userdata);
+            SDLTest_AssertCheck(*(int *)userdata == g_userdataValue, "Check userdata value, expected: %i, got: %i", g_userdataValue, *(int *)userdata);
         }
     }
 
@@ -51,8 +51,8 @@ int events_pushPumpAndPollUserevent(void *arg)
     /* Create user event */
     event1.type = SDL_USEREVENT;
     event1.user.code = SDLTest_RandomSint32();
-    event1.user.data1 = (void *)&_userdataValue1;
-    event1.user.data2 = (void *)&_userdataValue2;
+    event1.user.data1 = (void *)&g_userdataValue1;
+    event1.user.data2 = (void *)&g_userdataValue2;
 
     /* Push a user event onto the queue and force queue update */
     SDL_PushEvent(&event1);
@@ -82,17 +82,17 @@ int events_addDelEventWatch(void *arg)
     /* Create user event */
     event.type = SDL_USEREVENT;
     event.user.code = SDLTest_RandomSint32();
-    event.user.data1 = (void *)&_userdataValue1;
-    event.user.data2 = (void *)&_userdataValue2;
+    event.user.data1 = (void *)&g_userdataValue1;
+    event.user.data2 = (void *)&g_userdataValue2;
 
     /* Disable userdata check */
-    _userdataCheck = 0;
+    g_userdataCheck = 0;
 
     /* Reset event filter call tracker */
-    _eventFilterCalled = 0;
+    g_eventFilterCalled = 0;
 
     /* Add watch */
-    SDL_AddEventWatch(_events_sampleNullEventFilter, NULL);
+    SDL_AddEventWatch(events_sampleNullEventFilter, NULL);
     SDLTest_AssertPass("Call to SDL_AddEventWatch()");
 
     /* Push a user event onto the queue and force queue update */
@@ -100,19 +100,19 @@ int events_addDelEventWatch(void *arg)
     SDLTest_AssertPass("Call to SDL_PushEvent()");
     SDL_PumpEvents();
     SDLTest_AssertPass("Call to SDL_PumpEvents()");
-    SDLTest_AssertCheck(_eventFilterCalled == 1, "Check that event filter was called");
+    SDLTest_AssertCheck(g_eventFilterCalled == 1, "Check that event filter was called");
 
     /* Delete watch */
-    SDL_DelEventWatch(_events_sampleNullEventFilter, NULL);
+    SDL_DelEventWatch(events_sampleNullEventFilter, NULL);
     SDLTest_AssertPass("Call to SDL_DelEventWatch()");
 
     /* Push a user event onto the queue and force queue update */
-    _eventFilterCalled = 0;
+    g_eventFilterCalled = 0;
     SDL_PushEvent(&event);
     SDLTest_AssertPass("Call to SDL_PushEvent()");
     SDL_PumpEvents();
     SDLTest_AssertPass("Call to SDL_PumpEvents()");
-    SDLTest_AssertCheck(_eventFilterCalled == 0, "Check that event filter was NOT called");
+    SDLTest_AssertCheck(g_eventFilterCalled == 0, "Check that event filter was NOT called");
 
     return TEST_COMPLETED;
 }
@@ -131,18 +131,18 @@ int events_addDelEventWatchWithUserdata(void *arg)
     /* Create user event */
     event.type = SDL_USEREVENT;
     event.user.code = SDLTest_RandomSint32();
-    event.user.data1 = (void *)&_userdataValue1;
-    event.user.data2 = (void *)&_userdataValue2;
+    event.user.data1 = (void *)&g_userdataValue1;
+    event.user.data2 = (void *)&g_userdataValue2;
 
     /* Enable userdata check and set a value to check */
-    _userdataCheck = 1;
-    _userdataValue = SDLTest_RandomIntegerInRange(-1024, 1024);
+    g_userdataCheck = 1;
+    g_userdataValue = SDLTest_RandomIntegerInRange(-1024, 1024);
 
     /* Reset event filter call tracker */
-    _eventFilterCalled = 0;
+    g_eventFilterCalled = 0;
 
     /* Add watch */
-    SDL_AddEventWatch(_events_sampleNullEventFilter, (void *)&_userdataValue);
+    SDL_AddEventWatch(events_sampleNullEventFilter, (void *)&g_userdataValue);
     SDLTest_AssertPass("Call to SDL_AddEventWatch()");
 
     /* Push a user event onto the queue and force queue update */
@@ -150,19 +150,19 @@ int events_addDelEventWatchWithUserdata(void *arg)
     SDLTest_AssertPass("Call to SDL_PushEvent()");
     SDL_PumpEvents();
     SDLTest_AssertPass("Call to SDL_PumpEvents()");
-    SDLTest_AssertCheck(_eventFilterCalled == 1, "Check that event filter was called");
+    SDLTest_AssertCheck(g_eventFilterCalled == 1, "Check that event filter was called");
 
     /* Delete watch */
-    SDL_DelEventWatch(_events_sampleNullEventFilter, (void *)&_userdataValue);
+    SDL_DelEventWatch(events_sampleNullEventFilter, (void *)&g_userdataValue);
     SDLTest_AssertPass("Call to SDL_DelEventWatch()");
 
     /* Push a user event onto the queue and force queue update */
-    _eventFilterCalled = 0;
+    g_eventFilterCalled = 0;
     SDL_PushEvent(&event);
     SDLTest_AssertPass("Call to SDL_PushEvent()");
     SDL_PumpEvents();
     SDLTest_AssertPass("Call to SDL_PumpEvents()");
-    SDLTest_AssertCheck(_eventFilterCalled == 0, "Check that event filter was NOT called");
+    SDLTest_AssertCheck(g_eventFilterCalled == 0, "Check that event filter was NOT called");
 
     return TEST_COMPLETED;
 }

test/testautomation_hints.c

@@ -5,7 +5,7 @@
 #include <SDL3/SDL.h>
 #include <SDL3/SDL_test.h>
 
-const char *_HintsEnum[] = {
+const char *HintsEnum[] = {
     SDL_HINT_ACCELEROMETER_AS_JOYSTICK,
     SDL_HINT_FRAMEBUFFER_ACCELERATION,
     SDL_HINT_GAMECONTROLLERCONFIG,
@@ -29,7 +29,7 @@ const char *_HintsEnum[] = {
     SDL_HINT_VIDEO_X11_XRANDR,
     SDL_HINT_XINPUT_ENABLED,
 };
-const char *_HintsVerbose[] = {
+const char *HintsVerbose[] = {
     "SDL_ACCELEROMETER_AS_JOYSTICK",
     "SDL_FRAMEBUFFER_ACCELERATION",
     "SDL_GAMECONTROLLERCONFIG",
@@ -54,9 +54,9 @@ const char *_HintsVerbose[] = {
     "SDL_XINPUT_ENABLED"
 };
 
-SDL_COMPILE_TIME_ASSERT(HintsEnum, SDL_arraysize(_HintsEnum) == SDL_arraysize(_HintsVerbose));
+SDL_COMPILE_TIME_ASSERT(HintsEnum, SDL_arraysize(HintsEnum) == SDL_arraysize(HintsVerbose));
 
-const int _numHintsEnum = SDL_arraysize(_HintsEnum);
+const int numHintsEnum = SDL_arraysize(HintsEnum);
 
 /* Test case functions */
 
@@ -69,11 +69,11 @@ int hints_getHint(void *arg)
     const char *result2;
     int i;
 
-    for (i = 0; i < _numHintsEnum; i++) {
-        result1 = SDL_GetHint(_HintsEnum[i]);
-        SDLTest_AssertPass("Call to SDL_GetHint(%s) - using define definition", (char *)_HintsEnum[i]);
-        result2 = SDL_GetHint(_HintsVerbose[i]);
-        SDLTest_AssertPass("Call to SDL_GetHint(%s) - using string definition", (char *)_HintsVerbose[i]);
+    for (i = 0; i < numHintsEnum; i++) {
+        result1 = SDL_GetHint(HintsEnum[i]);
+        SDLTest_AssertPass("Call to SDL_GetHint(%s) - using define definition", (char *)HintsEnum[i]);
+        result2 = SDL_GetHint(HintsVerbose[i]);
+        SDLTest_AssertPass("Call to SDL_GetHint(%s) - using string definition", (char *)HintsVerbose[i]);
         SDLTest_AssertCheck(
             (result1 == NULL && result2 == NULL) || (SDL_strcmp(result1, result2) == 0),
             "Verify returned values are equal; got: result1='%s' result2='%s",
@@ -105,24 +105,24 @@ int hints_setHint(void *arg)
     /* Create random values to set */
     value = SDLTest_RandomAsciiStringOfSize(10);
 
-    for (i = 0; i < _numHintsEnum; i++) {
+    for (i = 0; i < numHintsEnum; i++) {
         /* Capture current value */
-        originalValue = SDL_GetHint(_HintsEnum[i]);
-        SDLTest_AssertPass("Call to SDL_GetHint(%s)", _HintsEnum[i]);
+        originalValue = SDL_GetHint(HintsEnum[i]);
+        SDLTest_AssertPass("Call to SDL_GetHint(%s)", HintsEnum[i]);
 
         /* Copy the original value, since it will be freed when we set it again */
         originalValue = originalValue ? SDL_strdup(originalValue) : NULL;
 
         /* Set value (twice) */
         for (j = 1; j <= 2; j++) {
-            result = SDL_SetHint(_HintsEnum[i], value);
-            SDLTest_AssertPass("Call to SDL_SetHint(%s, %s) (iteration %i)", _HintsEnum[i], value, j);
+            result = SDL_SetHint(HintsEnum[i], value);
+            SDLTest_AssertPass("Call to SDL_SetHint(%s, %s) (iteration %i)", HintsEnum[i], value, j);
             SDLTest_AssertCheck(
                 result == SDL_TRUE || result == SDL_FALSE,
                 "Verify valid result was returned, got: %i",
                 (int)result);
-            testValue = SDL_GetHint(_HintsEnum[i]);
-            SDLTest_AssertPass("Call to SDL_GetHint(%s) - using string definition", _HintsVerbose[i]);
+            testValue = SDL_GetHint(HintsEnum[i]);
+            SDLTest_AssertPass("Call to SDL_GetHint(%s) - using string definition", HintsVerbose[i]);
             SDLTest_AssertCheck(
                 (SDL_strcmp(value, testValue) == 0),
                 "Verify returned value equals set value; got: testValue='%s' value='%s",
@@ -131,8 +131,8 @@ int hints_setHint(void *arg)
         }
 
         /* Reset original value */
-        result = SDL_SetHint(_HintsEnum[i], originalValue);
-        SDLTest_AssertPass("Call to SDL_SetHint(%s, originalValue)", _HintsEnum[i]);
+        result = SDL_SetHint(HintsEnum[i], originalValue);
+        SDLTest_AssertPass("Call to SDL_SetHint(%s, originalValue)", HintsEnum[i]);
         SDLTest_AssertCheck(
             result == SDL_TRUE || result == SDL_FALSE,
             "Verify valid result was returned, got: %i",

test/testautomation_keyboard.c

@@ -98,7 +98,7 @@ int keyboard_getKeyFromName(void *arg)
 /*
  * Local helper to check for the invalid scancode error message
  */
-void _checkInvalidScancodeError()
+static void checkInvalidScancodeError()
 {
     const char *expectedError = "Parameter 'scancode' is invalid";
     const char *error;
@@ -140,13 +140,13 @@ int keyboard_getKeyFromScancode(void *arg)
     result = SDL_GetKeyFromScancode(-999);
     SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(-999)");
     SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %" SDL_PRIs32, SDLK_UNKNOWN, result);
-    _checkInvalidScancodeError();
+    checkInvalidScancodeError();
 
     /* Case where input is invalid (too big) */
     result = SDL_GetKeyFromScancode(999);
     SDLTest_AssertPass("Call to SDL_GetKeyFromScancode(999)");
     SDLTest_AssertCheck(result == SDLK_UNKNOWN, "Verify result from call is UNKNOWN, expected: %i, got: %" SDL_PRIs32, SDLK_UNKNOWN, result);
-    _checkInvalidScancodeError();
+    checkInvalidScancodeError();
 
     return TEST_COMPLETED;
 }
@@ -227,7 +227,7 @@ int keyboard_getScancodeNameNegative(void *arg)
     SDLTest_AssertPass("Call to SDL_GetScancodeName(%d/large)", scancode);
     SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
     SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: '%s', got: '%s'", expected, result);
-    _checkInvalidScancodeError();
+    checkInvalidScancodeError();
 
     return TEST_COMPLETED;
 }
@@ -260,7 +260,7 @@ int keyboard_getKeyNameNegative(void *arg)
     SDLTest_AssertPass("Call to SDL_GetKeyName(%" SDL_PRIs32 "/negative)", keycode);
     SDLTest_AssertCheck(result != NULL, "Verify result from call is not NULL");
     SDLTest_AssertCheck(SDL_strcmp(result, expected) == 0, "Verify result from call is valid, expected: '%s', got: '%s'", expected, result);
-    _checkInvalidScancodeError();
+    checkInvalidScancodeError();
 
     SDL_ClearError();
     SDLTest_AssertPass("Call to SDL_ClearError()");
@@ -359,7 +359,7 @@ int keyboard_startStopTextInput(void *arg)
 }
 
 /* Internal function to test SDL_SetTextInputRect */
-void _testSetTextInputRect(SDL_Rect refRect)
+static void testSetTextInputRect(SDL_Rect refRect)
 {
     SDL_Rect testRect;
 
@@ -387,63 +387,63 @@ int keyboard_setTextInputRect(void *arg)
     refRect.y = SDLTest_RandomIntegerInRange(1, 50);
     refRect.w = SDLTest_RandomIntegerInRange(10, 50);
     refRect.h = SDLTest_RandomIntegerInRange(10, 50);
-    _testSetTextInputRect(refRect);
+    testSetTextInputRect(refRect);
 
     /* Normal visible refRect, origin 0,0 */
     refRect.x = 0;
     refRect.y = 0;
     refRect.w = SDLTest_RandomIntegerInRange(10, 50);
     refRect.h = SDLTest_RandomIntegerInRange(10, 50);
-    _testSetTextInputRect(refRect);
+    testSetTextInputRect(refRect);
 
     /* 1Pixel refRect */
     refRect.x = SDLTest_RandomIntegerInRange(10, 50);
     refRect.y = SDLTest_RandomIntegerInRange(10, 50);
     refRect.w = 1;
     refRect.h = 1;
-    _testSetTextInputRect(refRect);
+    testSetTextInputRect(refRect);
 
     /* 0pixel refRect */
     refRect.x = 1;
     refRect.y = 1;
     refRect.w = 1;
     refRect.h = 0;
-    _testSetTextInputRect(refRect);
+    testSetTextInputRect(refRect);
 
     /* 0pixel refRect */
     refRect.x = 1;
     refRect.y = 1;
     refRect.w = 0;
     refRect.h = 1;
-    _testSetTextInputRect(refRect);
+    testSetTextInputRect(refRect);
 
     /* 0pixel refRect */
     refRect.x = 1;
     refRect.y = 1;
     refRect.w = 0;
     refRect.h = 0;
-    _testSetTextInputRect(refRect);
+    testSetTextInputRect(refRect);
 
     /* 0pixel refRect */
     refRect.x = 0;
     refRect.y = 0;
     refRect.w = 0;
     refRect.h = 0;
-    _testSetTextInputRect(refRect);
+    testSetTextInputRect(refRect);
 
     /* negative refRect */
     refRect.x = SDLTest_RandomIntegerInRange(-200, -100);
     refRect.y = SDLTest_RandomIntegerInRange(-200, -100);
     refRect.w = 50;
     refRect.h = 50;
-    _testSetTextInputRect(refRect);
+    testSetTextInputRect(refRect);
 
     /* oversized refRect */
     refRect.x = SDLTest_RandomIntegerInRange(1, 50);
     refRect.y = SDLTest_RandomIntegerInRange(1, 50);
     refRect.w = 5000;
     refRect.h = 5000;
-    _testSetTextInputRect(refRect);
+    testSetTextInputRect(refRect);
 
     /* NULL refRect */
     SDL_SetTextInputRect(NULL);
@@ -568,7 +568,7 @@ int keyboard_getScancodeFromName(void *arg)
 /*
  * Local helper to check for the invalid scancode error message
  */
-void _checkInvalidNameError()
+static void checkInvalidNameError()
 {
     const char *expectedError = "Parameter 'name' is invalid";
     const char *error;
@@ -608,21 +608,21 @@ int keyboard_getScancodeFromNameNegative(void *arg)
     SDLTest_AssertPass("Call to SDL_GetScancodeFromName('%s')", name);
     SDL_free((void *)name);
     SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
-    _checkInvalidNameError();
+    checkInvalidNameError();
 
     /* Zero length string input */
     name = "";
     scancode = SDL_GetScancodeFromName(name);
     SDLTest_AssertPass("Call to SDL_GetScancodeFromName(NULL)");
     SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
-    _checkInvalidNameError();
+    checkInvalidNameError();
 
     /* NULL input */
     name = NULL;
     scancode = SDL_GetScancodeFromName(name);
     SDLTest_AssertPass("Call to SDL_GetScancodeFromName(NULL)");
     SDLTest_AssertCheck(scancode == SDL_SCANCODE_UNKNOWN, "Validate return value from SDL_GetScancodeFromName, expected: %i, got: %i", SDL_SCANCODE_UNKNOWN, scancode);
-    _checkInvalidNameError();
+    checkInvalidNameError();
 
     return TEST_COMPLETED;
 }

test/testautomation_mouse.c

@@ -11,7 +11,7 @@
 /* Test case functions */
 
 /* Helper to evaluate state returned from SDL_GetMouseState */
-int _mouseStateCheck(Uint32 state)
+static int mouseStateCheck(Uint32 state)
 {
     return (state == 0) ||
            (state == SDL_BUTTON(SDL_BUTTON_LEFT)) ||
@@ -38,21 +38,21 @@ int mouse_getMouseState(void *arg)
     /* Case where x, y pointer is NULL */
     state = SDL_GetMouseState(NULL, NULL);
     SDLTest_AssertPass("Call to SDL_GetMouseState(NULL, NULL)");
-    SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
+    SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
 
     /* Case where x pointer is not NULL */
     x = INT_MIN;
     state = SDL_GetMouseState(&x, NULL);
     SDLTest_AssertPass("Call to SDL_GetMouseState(&x, NULL)");
     SDLTest_AssertCheck(x > INT_MIN, "Validate that value of x is > INT_MIN, got: %i", x);
-    SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
+    SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
 
     /* Case where y pointer is not NULL */
     y = INT_MIN;
     state = SDL_GetMouseState(NULL, &y);
     SDLTest_AssertPass("Call to SDL_GetMouseState(NULL, &y)");
     SDLTest_AssertCheck(y > INT_MIN, "Validate that value of y is > INT_MIN, got: %i", y);
-    SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
+    SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
 
     /* Case where x and y pointer is not NULL */
     x = INT_MIN;
@@ -61,7 +61,7 @@ int mouse_getMouseState(void *arg)
     SDLTest_AssertPass("Call to SDL_GetMouseState(&x, &y)");
     SDLTest_AssertCheck(x > INT_MIN, "Validate that value of x is > INT_MIN, got: %i", x);
     SDLTest_AssertCheck(y > INT_MIN, "Validate that value of y is > INT_MIN, got: %i", y);
-    SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
+    SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
 
     return TEST_COMPLETED;
 }
@@ -83,21 +83,21 @@ int mouse_getRelativeMouseState(void *arg)
     /* Case where x, y pointer is NULL */
     state = SDL_GetRelativeMouseState(NULL, NULL);
     SDLTest_AssertPass("Call to SDL_GetRelativeMouseState(NULL, NULL)");
-    SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
+    SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
 
     /* Case where x pointer is not NULL */
     x = INT_MIN;
     state = SDL_GetRelativeMouseState(&x, NULL);
     SDLTest_AssertPass("Call to SDL_GetRelativeMouseState(&x, NULL)");
     SDLTest_AssertCheck(x > INT_MIN, "Validate that value of x is > INT_MIN, got: %i", x);
-    SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
+    SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
 
     /* Case where y pointer is not NULL */
     y = INT_MIN;
     state = SDL_GetRelativeMouseState(NULL, &y);
     SDLTest_AssertPass("Call to SDL_GetRelativeMouseState(NULL, &y)");
     SDLTest_AssertCheck(y > INT_MIN, "Validate that value of y is > INT_MIN, got: %i", y);
-    SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
+    SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
 
     /* Case where x and y pointer is not NULL */
     x = INT_MIN;
@@ -106,13 +106,13 @@ int mouse_getRelativeMouseState(void *arg)
     SDLTest_AssertPass("Call to SDL_GetRelativeMouseState(&x, &y)");
     SDLTest_AssertCheck(x > INT_MIN, "Validate that value of x is > INT_MIN, got: %i", x);
     SDLTest_AssertCheck(y > INT_MIN, "Validate that value of y is > INT_MIN, got: %i", y);
-    SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
+    SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
 
     return TEST_COMPLETED;
 }
 
 /* XPM definition of mouse Cursor */
-static const char *_mouseArrowData[] = {
+static const char *g_mouseArrowData[] = {
     /* pixels */
     "X                               ",
     "XX                              ",
@@ -149,7 +149,7 @@ static const char *_mouseArrowData[] = {
 };
 
 /* Helper that creates a new mouse cursor from an XPM */
-static SDL_Cursor *_initArrowCursor(const char *image[])
+static SDL_Cursor *initArrowCursor(const char *image[])
 {
     SDL_Cursor *cursor;
     int i, row, col;
@@ -195,7 +195,7 @@ int mouse_createFreeCursor(void *arg)
     SDL_Cursor *cursor;
 
     /* Create a cursor */
-    cursor = _initArrowCursor(_mouseArrowData);
+    cursor = initArrowCursor(g_mouseArrowData);
     SDLTest_AssertPass("Call to SDL_CreateCursor()");
     SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_CreateCursor() is not NULL");
     if (cursor == NULL) {
@@ -247,7 +247,7 @@ int mouse_createFreeColorCursor(void *arg)
 }
 
 /* Helper that changes cursor visibility */
-void _changeCursorVisibility(SDL_bool state)
+static void changeCursorVisibility(SDL_bool state)
 {
     SDL_bool newState;
 
@@ -279,12 +279,12 @@ int mouse_showCursor(void *arg)
     SDLTest_AssertPass("Call to SDL_CursorVisible()");
     if (currentState) {
         /* Hide the cursor, then show it again */
-        _changeCursorVisibility(SDL_FALSE);
-        _changeCursorVisibility(SDL_TRUE);
+        changeCursorVisibility(SDL_FALSE);
+        changeCursorVisibility(SDL_TRUE);
     } else {
         /* Show the cursor, then hide it again */
-        _changeCursorVisibility(SDL_TRUE);
-        _changeCursorVisibility(SDL_FALSE);
+        changeCursorVisibility(SDL_TRUE);
+        changeCursorVisibility(SDL_FALSE);
     }
 
     return TEST_COMPLETED;
@@ -300,7 +300,7 @@ int mouse_setCursor(void *arg)
     SDL_Cursor *cursor;
 
     /* Create a cursor */
-    cursor = _initArrowCursor(_mouseArrowData);
+    cursor = initArrowCursor(g_mouseArrowData);
     SDLTest_AssertPass("Call to SDL_CreateCursor()");
     SDLTest_AssertCheck(cursor != NULL, "Validate result from SDL_CreateCursor() is not NULL");
     if (cursor == NULL) {
@@ -400,11 +400,11 @@ int mouse_getSetRelativeMouseMode(void *arg)
 /**
  * Creates a test window
  */
-SDL_Window *_createMouseSuiteTestWindow()
+static SDL_Window *createMouseSuiteTestWindow()
 {
     int posX = 100, posY = 100, width = MOUSE_TESTWINDOW_WIDTH, height = MOUSE_TESTWINDOW_HEIGHT;
     SDL_Window *window;
-    window = SDL_CreateWindow("mouse_createMouseSuiteTestWindow", posX, posY, width, height, 0);
+    window = SDL_CreateWindow("mousecreateMouseSuiteTestWindow", posX, posY, width, height, 0);
     SDLTest_AssertPass("SDL_CreateWindow()");
     SDLTest_AssertCheck(window != NULL, "Check SDL_CreateWindow result");
     return window;
@@ -413,7 +413,7 @@ SDL_Window *_createMouseSuiteTestWindow()
 /*
  * Destroy test window
  */
-void _destroyMouseSuiteTestWindow(SDL_Window *window)
+static void destroyMouseSuiteTestWindow(SDL_Window *window)
 {
     if (window != NULL) {
         SDL_DestroyWindow(window);
@@ -449,7 +449,7 @@ int mouse_warpMouseInWindow(void *arg)
     yPositions[4] = h;
     yPositions[5] = h + 1;
     /* Create test window */
-    window = _createMouseSuiteTestWindow();
+    window = createMouseSuiteTestWindow();
     if (window == NULL) {
         return TEST_ABORTED;
     }
@@ -479,7 +479,7 @@ int mouse_warpMouseInWindow(void *arg)
     }
 
     /* Clean up test window */
-    _destroyMouseSuiteTestWindow(window);
+    destroyMouseSuiteTestWindow(window);
 
     return TEST_COMPLETED;
 }
@@ -501,7 +501,7 @@ int mouse_getMouseFocus(void *arg)
     SDLTest_AssertPass("SDL_GetMouseFocus()");
 
     /* Create test window */
-    window = _createMouseSuiteTestWindow();
+    window = createMouseSuiteTestWindow();
     if (window == NULL) {
         return TEST_ABORTED;
     }
@@ -530,7 +530,7 @@ int mouse_getMouseFocus(void *arg)
     SDLTest_AssertPass("SDL_WarpMouseInWindow(...,%i,%i)", x, y);
 
     /* Clean up test window */
-    _destroyMouseSuiteTestWindow(window);
+    destroyMouseSuiteTestWindow(window);
 
     /* Pump events to update focus state */
     SDL_PumpEvents();
@@ -580,7 +580,7 @@ int mouse_getGlobalMouseState(void *arg)
     SDLTest_AssertPass("Call to SDL_GetGlobalMouseState()");
     SDLTest_AssertCheck(x > INT_MIN, "Validate that value of x is > INT_MIN, got: %i", x);
     SDLTest_AssertCheck(y > INT_MIN, "Validate that value of y is > INT_MIN, got: %i", y);
-    SDLTest_AssertCheck(_mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
+    SDLTest_AssertCheck(mouseStateCheck(state), "Validate state returned from function, got: %" SDL_PRIu32, state);
 
     return TEST_COMPLETED;
 }

test/testautomation_pixels.c

@@ -7,8 +7,8 @@
 /* Test case functions */
 
 /* Definition of all RGB formats used to test pixel conversions */
-const int _numRGBPixelFormats = 31;
-Uint32 _RGBPixelFormats[] = {
+const int g_numRGBPixelFormats = 31;
+Uint32 g_RGBPixelFormats[] = {
     SDL_PIXELFORMAT_INDEX1LSB,
     SDL_PIXELFORMAT_INDEX1MSB,
     SDL_PIXELFORMAT_INDEX4LSB,
@@ -41,7 +41,7 @@ Uint32 _RGBPixelFormats[] = {
     SDL_PIXELFORMAT_BGRA8888,
     SDL_PIXELFORMAT_ARGB2101010
 };
-const char *_RGBPixelFormatsVerbose[] = {
+const char *g_RGBPixelFormatsVerbose[] = {
     "SDL_PIXELFORMAT_INDEX1LSB",
     "SDL_PIXELFORMAT_INDEX1MSB",
     "SDL_PIXELFORMAT_INDEX4LSB",
@@ -76,8 +76,8 @@ const char *_RGBPixelFormatsVerbose[] = {
 };
 
 /* Definition of all Non-RGB formats used to test pixel conversions */
-const int _numNonRGBPixelFormats = 7;
-Uint32 _nonRGBPixelFormats[] = {
+const int g_numNonRGBPixelFormats = 7;
+static Uint32 g_nonRGBPixelFormats[] = {
     SDL_PIXELFORMAT_YV12,
     SDL_PIXELFORMAT_IYUV,
     SDL_PIXELFORMAT_YUY2,
@@ -86,7 +86,7 @@ Uint32 _nonRGBPixelFormats[] = {
     SDL_PIXELFORMAT_NV12,
     SDL_PIXELFORMAT_NV21
 };
-const char *_nonRGBPixelFormatsVerbose[] = {
+const char *g_nonRGBPixelFormatsVerbose[] = {
     "SDL_PIXELFORMAT_YV12",
     "SDL_PIXELFORMAT_IYUV",
     "SDL_PIXELFORMAT_YUY2",
@@ -97,12 +97,12 @@ const char *_nonRGBPixelFormatsVerbose[] = {
 };
 
 /* Definition of some invalid formats for negative tests */
-const int _numInvalidPixelFormats = 2;
-Uint32 _invalidPixelFormats[] = {
+const int g_numInvalidPixelFormats = 2;
+static Uint32 g_invalidPixelFormats[] = {
     0xfffffffe,
     0xffffffff
 };
-const char *_invalidPixelFormatsVerbose[] = {
+const char *g_invalidPixelFormatsVerbose[] = {
     "SDL_PIXELFORMAT_UNKNOWN",
     "SDL_PIXELFORMAT_UNKNOWN"
 };
@@ -146,9 +146,9 @@ int pixels_allocFreeFormat(void *arg)
     }
 
     /* RGB formats */
-    for (i = 0; i < _numRGBPixelFormats; i++) {
-        format = _RGBPixelFormats[i];
-        SDLTest_Log("RGB Format: %s (%" SDL_PRIu32 ")", _RGBPixelFormatsVerbose[i], format);
+    for (i = 0; i < g_numRGBPixelFormats; i++) {
+        format = g_RGBPixelFormats[i];
+        SDLTest_Log("RGB Format: %s (%" SDL_PRIu32 ")", g_RGBPixelFormatsVerbose[i], format);
 
         /* Allocate format */
         result = SDL_CreatePixelFormat(format);
@@ -170,9 +170,9 @@ int pixels_allocFreeFormat(void *arg)
     }
 
     /* Non-RGB formats */
-    for (i = 0; i < _numNonRGBPixelFormats; i++) {
-        format = _nonRGBPixelFormats[i];
-        SDLTest_Log("non-RGB Format: %s (%" SDL_PRIu32 ")", _nonRGBPixelFormatsVerbose[i], format);
+    for (i = 0; i < g_numNonRGBPixelFormats; i++) {
+        format = g_nonRGBPixelFormats[i];
+        SDLTest_Log("non-RGB Format: %s (%" SDL_PRIu32 ")", g_nonRGBPixelFormatsVerbose[i], format);
 
         /* Try to allocate format */
         result = SDL_CreatePixelFormat(format);
@@ -183,10 +183,10 @@ int pixels_allocFreeFormat(void *arg)
     /* Negative cases */
 
     /* Invalid Formats */
-    for (i = 0; i < _numInvalidPixelFormats; i++) {
+    for (i = 0; i < g_numInvalidPixelFormats; i++) {
         SDL_ClearError();
         SDLTest_AssertPass("Call to SDL_ClearError()");
-        format = _invalidPixelFormats[i];
+        format = g_invalidPixelFormats[i];
         result = SDL_CreatePixelFormat(format);
         SDLTest_AssertPass("Call to SDL_CreatePixelFormat(%" SDL_PRIu32 ")", format);
         SDLTest_AssertCheck(result == NULL, "Verify result is NULL");
@@ -243,9 +243,9 @@ int pixels_getPixelFormatName(void *arg)
     }
 
     /* RGB formats */
-    for (i = 0; i < _numRGBPixelFormats; i++) {
-        format = _RGBPixelFormats[i];
-        SDLTest_Log("RGB Format: %s (%" SDL_PRIu32 ")", _RGBPixelFormatsVerbose[i], format);
+    for (i = 0; i < g_numRGBPixelFormats; i++) {
+        format = g_RGBPixelFormats[i];
+        SDLTest_Log("RGB Format: %s (%" SDL_PRIu32 ")", g_RGBPixelFormatsVerbose[i], format);
 
         /* Get name of format */
         result = SDL_GetPixelFormatName(format);
@@ -253,15 +253,15 @@ int pixels_getPixelFormatName(void *arg)
         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);
+            SDLTest_AssertCheck(SDL_strcmp(result, g_RGBPixelFormatsVerbose[i]) == 0,
+                                "Verify result text; expected: %s, got %s", g_RGBPixelFormatsVerbose[i], result);
         }
     }
 
     /* Non-RGB formats */
-    for (i = 0; i < _numNonRGBPixelFormats; i++) {
-        format = _nonRGBPixelFormats[i];
-        SDLTest_Log("non-RGB Format: %s (%" SDL_PRIu32 ")", _nonRGBPixelFormatsVerbose[i], format);
+    for (i = 0; i < g_numNonRGBPixelFormats; i++) {
+        format = g_nonRGBPixelFormats[i];
+        SDLTest_Log("non-RGB Format: %s (%" SDL_PRIu32 ")", g_nonRGBPixelFormatsVerbose[i], format);
 
         /* Get name of format */
         result = SDL_GetPixelFormatName(format);
@@ -269,8 +269,8 @@ int pixels_getPixelFormatName(void *arg)
         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);
+            SDLTest_AssertCheck(SDL_strcmp(result, g_nonRGBPixelFormatsVerbose[i]) == 0,
+                                "Verify result text; expected: %s, got %s", g_nonRGBPixelFormatsVerbose[i], result);
         }
     }
 
@@ -279,16 +279,16 @@ int pixels_getPixelFormatName(void *arg)
     /* Invalid Formats */
     SDL_ClearError();
     SDLTest_AssertPass("Call to SDL_ClearError()");
-    for (i = 0; i < _numInvalidPixelFormats; i++) {
-        format = _invalidPixelFormats[i];
+    for (i = 0; i < g_numInvalidPixelFormats; i++) {
+        format = g_invalidPixelFormats[i];
         result = SDL_GetPixelFormatName(format);
         SDLTest_AssertPass("Call to SDL_GetPixelFormatName(%" SDL_PRIu32 ")", 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);
+            SDLTest_AssertCheck(SDL_strcmp(result, g_invalidPixelFormatsVerbose[i]) == 0,
+                                "Validate name is UNKNOWN, expected: '%s', got: '%s'", g_invalidPixelFormatsVerbose[i], result);
         }
         error = SDL_GetError();
         SDLTest_AssertPass("Call to SDL_GetError()");

test/testautomation_platform.c

@@ -16,7 +16,7 @@
  *  compare them directly, so we push it through a function to keep the
  *  compiler quiet.  --ryan.
  */
-static int _compareSizeOfType(size_t sizeoftype, size_t hardcodetype)
+static int compareSizeOfType(size_t sizeoftype, size_t hardcodetype)
 {
     return sizeoftype != hardcodetype;
 }
@@ -30,16 +30,16 @@ int platform_testTypes(void *arg)
 {
     int ret;
 
-    ret = _compareSizeOfType(sizeof(Uint8), 1);
+    ret = compareSizeOfType(sizeof(Uint8), 1);
     SDLTest_AssertCheck(ret == 0, "sizeof(Uint8) = %u, expected  1", (unsigned int)sizeof(Uint8));
 
-    ret = _compareSizeOfType(sizeof(Uint16), 2);
+    ret = compareSizeOfType(sizeof(Uint16), 2);
     SDLTest_AssertCheck(ret == 0, "sizeof(Uint16) = %u, expected 2", (unsigned int)sizeof(Uint16));
 
-    ret = _compareSizeOfType(sizeof(Uint32), 4);
+    ret = compareSizeOfType(sizeof(Uint32), 4);
     SDLTest_AssertCheck(ret == 0, "sizeof(Uint32) = %u, expected 4", (unsigned int)sizeof(Uint32));
 
-    ret = _compareSizeOfType(sizeof(Uint64), 8);
+    ret = compareSizeOfType(sizeof(Uint64), 8);
     SDLTest_AssertCheck(ret == 0, "sizeof(Uint64) = %u, expected 8", (unsigned int)sizeof(Uint64));
 
     return TEST_COMPLETED;

test/testautomation_rect.c

@@ -12,7 +12,7 @@
 /* !
  * \brief Private helper to check SDL_GetRectAndLineIntersection results
  */
-void _validateIntersectRectAndLineResults(
+static void validateIntersectRectAndLineResults(
     SDL_bool intersection, SDL_bool expectedIntersection,
     SDL_Rect *rect, SDL_Rect *refRect,
     int x1, int y1, int x2, int y2,
@@ -61,7 +61,7 @@ int rect_testIntersectRectAndLine(void *arg)
     y2 = 15;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 0, 15, 31, 15);
+    validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 0, 15, 31, 15);
 
     x1 = 15;
     y1 = yTop;
@@ -69,7 +69,7 @@ int rect_testIntersectRectAndLine(void *arg)
     y2 = yBottom;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 15, 0, 15, 31);
+    validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 15, 0, 15, 31);
 
     x1 = -refRect.w;
     y1 = -refRect.h;
@@ -77,7 +77,7 @@ int rect_testIntersectRectAndLine(void *arg)
     y2 = 2 * refRect.h;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 0, 0, 31, 31);
+    validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 0, 0, 31, 31);
 
     x1 = 2 * refRect.w;
     y1 = 2 * refRect.h;
@@ -85,7 +85,7 @@ int rect_testIntersectRectAndLine(void *arg)
     y2 = -refRect.h;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 31, 31, 0, 0);
+    validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 31, 31, 0, 0);
 
     x1 = -1;
     y1 = 32;
@@ -93,7 +93,7 @@ int rect_testIntersectRectAndLine(void *arg)
     y2 = -1;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 0, 31, 31, 0);
+    validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 0, 31, 31, 0);
 
     x1 = 32;
     y1 = -1;
@@ -101,7 +101,7 @@ int rect_testIntersectRectAndLine(void *arg)
     y2 = 32;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 31, 0, 0, 31);
+    validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, 31, 0, 0, 31);
 
     return TEST_COMPLETED;
 }
@@ -135,7 +135,7 @@ int rect_testIntersectRectAndLineInside(void *arg)
     y2 = y2Ref;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, x2Ref, y2Ref);
+    validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, x2Ref, y2Ref);
 
     x1 = x1Ref;
     y1 = y1Ref;
@@ -143,7 +143,7 @@ int rect_testIntersectRectAndLineInside(void *arg)
     y2 = ymax;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, xmax, ymax);
+    validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, xmax, ymax);
 
     x1 = xmin;
     y1 = ymin;
@@ -151,7 +151,7 @@ int rect_testIntersectRectAndLineInside(void *arg)
     y2 = y2Ref;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, xmin, ymin, x2Ref, y2Ref);
+    validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, xmin, ymin, x2Ref, y2Ref);
 
     x1 = xmin;
     y1 = ymin;
@@ -159,7 +159,7 @@ int rect_testIntersectRectAndLineInside(void *arg)
     y2 = ymax;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, xmin, ymin, xmax, ymax);
+    validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, xmin, ymin, xmax, ymax);
 
     x1 = xmin;
     y1 = ymax;
@@ -167,7 +167,7 @@ int rect_testIntersectRectAndLineInside(void *arg)
     y2 = ymin;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, xmin, ymax, xmax, ymin);
+    validateIntersectRectAndLineResults(intersected, SDL_TRUE, &rect, &refRect, x1, y1, x2, y2, xmin, ymax, xmax, ymin);
 
     return TEST_COMPLETED;
 }
@@ -197,7 +197,7 @@ int rect_testIntersectRectAndLineOutside(void *arg)
     y2 = 31;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, xLeft, 0, xLeft, 31);
+    validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, xLeft, 0, xLeft, 31);
 
     x1 = xRight;
     y1 = 0;
@@ -205,7 +205,7 @@ int rect_testIntersectRectAndLineOutside(void *arg)
     y2 = 31;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, xRight, 0, xRight, 31);
+    validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, xRight, 0, xRight, 31);
 
     x1 = 0;
     y1 = yTop;
@@ -213,7 +213,7 @@ int rect_testIntersectRectAndLineOutside(void *arg)
     y2 = yTop;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, 0, yTop, 31, yTop);
+    validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, 0, yTop, 31, yTop);
 
     x1 = 0;
     y1 = yBottom;
@@ -221,7 +221,7 @@ int rect_testIntersectRectAndLineOutside(void *arg)
     y2 = yBottom;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, 0, yBottom, 31, yBottom);
+    validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, 0, yBottom, 31, yBottom);
 
     return TEST_COMPLETED;
 }
@@ -255,7 +255,7 @@ int rect_testIntersectRectAndLineEmpty(void *arg)
     y2 = y2Ref;
     rect = refRect;
     intersected = SDL_GetRectAndLineIntersection(&rect, &x1, &y1, &x2, &y2);
-    _validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, x2Ref, y2Ref);
+    validateIntersectRectAndLineResults(intersected, SDL_FALSE, &rect, &refRect, x1, y1, x2, y2, x1Ref, y1Ref, x2Ref, y2Ref);
 
     return TEST_COMPLETED;
 }
@@ -297,7 +297,7 @@ int rect_testIntersectRectAndLineParam(void *arg)
 /* !
  * \brief Private helper to check SDL_HasRectIntersection results
  */
-void _validateHasIntersectionResults(
+static void validateHasIntersectionResults(
     SDL_bool intersection, SDL_bool expectedIntersection,
     SDL_Rect *rectA, SDL_Rect *rectB, SDL_Rect *refRectA, SDL_Rect *refRectB)
 {
@@ -320,12 +320,12 @@ void _validateHasIntersectionResults(
 /* !
  * \brief Private helper to check SDL_GetRectIntersection results
  */
-void _validateIntersectRectResults(
+static void validateIntersectRectResults(
     SDL_bool intersection, SDL_bool expectedIntersection,
     SDL_Rect *rectA, SDL_Rect *rectB, SDL_Rect *refRectA, SDL_Rect *refRectB,
     SDL_Rect *result, SDL_Rect *expectedResult)
 {
-    _validateHasIntersectionResults(intersection, expectedIntersection, rectA, rectB, refRectA, refRectB);
+    validateHasIntersectionResults(intersection, expectedIntersection, rectA, rectB, refRectA, refRectB);
     if (result && expectedResult) {
         SDLTest_AssertCheck(result->x == expectedResult->x && result->y == expectedResult->y && result->w == expectedResult->w && result->h == expectedResult->h,
                             "Check that intersection of rectangles A (%d,%d,%d,%d) and B (%d,%d,%d,%d) was correctly calculated, got (%d,%d,%d,%d) expected (%d,%d,%d,%d)",
@@ -339,7 +339,7 @@ void _validateIntersectRectResults(
 /* !
  * \brief Private helper to check SDL_GetRectUnion results
  */
-void _validateUnionRectResults(
+static void validateUnionRectResults(
     SDL_Rect *rectA, SDL_Rect *rectB, SDL_Rect *refRectA, SDL_Rect *refRectB,
     SDL_Rect *result, SDL_Rect *expectedResult)
 {
@@ -362,7 +362,7 @@ void _validateUnionRectResults(
 /* !
  * \brief Private helper to check SDL_RectEmpty results
  */
-void _validateRectEmptyResults(
+static void validateRectEmptyResults(
     SDL_bool empty, SDL_bool expectedEmpty,
     SDL_Rect *rect, SDL_Rect *refRect)
 {
@@ -380,7 +380,7 @@ void _validateRectEmptyResults(
 /* !
  * \brief Private helper to check SDL_RectsEqual results
  */
-void _validateRectEqualsResults(
+static void validateRectEqualsResults(
     SDL_bool equals, SDL_bool expectedEquals,
     SDL_Rect *rectA, SDL_Rect *rectB, SDL_Rect *refRectA, SDL_Rect *refRectB)
 {
@@ -403,7 +403,7 @@ void _validateRectEqualsResults(
 /* !
  * \brief Private helper to check SDL_RectsEqualF results
  */
-void _validateFRectEqualsResults(
+static void validateFRectEqualsResults(
     SDL_bool equals, SDL_bool expectedEquals,
     SDL_FRect *rectA, SDL_FRect *rectB, SDL_FRect *refRectA, SDL_FRect *refRectB)
 {
@@ -449,7 +449,7 @@ int rect_testIntersectRectInside(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
-    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &refRectB);
+    validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &refRectB);
 
     return TEST_COMPLETED;
 }
@@ -477,7 +477,7 @@ int rect_testIntersectRectOutside(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
-    _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
+    validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
 
     return TEST_COMPLETED;
 }
@@ -510,7 +510,7 @@ int rect_testIntersectRectPartial(void *arg)
     expectedResult.w = refRectA.w - refRectB.x;
     expectedResult.h = refRectA.h - refRectB.y;
     intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
-    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
+    validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
 
     /* rectB right edge */
     refRectB.x = rectA.w - 1;
@@ -524,7 +524,7 @@ int rect_testIntersectRectPartial(void *arg)
     expectedResult.w = 1;
     expectedResult.h = refRectB.h;
     intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
-    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
+    validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
 
     /* rectB left edge */
     refRectB.x = 1 - rectA.w;
@@ -538,7 +538,7 @@ int rect_testIntersectRectPartial(void *arg)
     expectedResult.w = 1;
     expectedResult.h = refRectB.h;
     intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
-    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
+    validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
 
     /* rectB bottom edge */
     refRectB.x = rectA.x;
@@ -552,7 +552,7 @@ int rect_testIntersectRectPartial(void *arg)
     expectedResult.w = refRectB.w;
     expectedResult.h = 1;
     intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
-    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
+    validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
 
     /* rectB top edge */
     refRectB.x = rectA.x;
@@ -566,7 +566,7 @@ int rect_testIntersectRectPartial(void *arg)
     expectedResult.w = refRectB.w;
     expectedResult.h = 1;
     intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
-    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
+    validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
 
     return TEST_COMPLETED;
 }
@@ -595,7 +595,7 @@ int rect_testIntersectRectPoint(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
-    _validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &refRectA);
+    validateIntersectRectResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB, &result, &refRectA);
 
     /* non-intersecting pixels cases */
     for (offsetX = -1; offsetX <= 1; offsetX++) {
@@ -610,7 +610,7 @@ int rect_testIntersectRectPoint(void *arg)
                 rectA = refRectA;
                 rectB = refRectB;
                 intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
-                _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
+                validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
             }
         }
     }
@@ -647,7 +647,7 @@ int rect_testIntersectRectEmpty(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
-    _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
+    validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
     empty = SDL_RectEmpty(&result);
     SDLTest_AssertCheck(empty == SDL_TRUE, "Validate result is empty Rect; got: %s", (empty == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE");
 
@@ -664,7 +664,7 @@ int rect_testIntersectRectEmpty(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
-    _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
+    validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
     empty = SDL_RectEmpty(&result);
     SDLTest_AssertCheck(empty == SDL_TRUE, "Validate result is empty Rect; got: %s", (empty == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE");
 
@@ -683,7 +683,7 @@ int rect_testIntersectRectEmpty(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_GetRectIntersection(&rectA, &rectB, &result);
-    _validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
+    validateIntersectRectResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB, (SDL_Rect *)NULL, (SDL_Rect *)NULL);
     empty = SDL_RectEmpty(&result);
     SDLTest_AssertCheck(empty == SDL_TRUE, "Validate result is empty Rect; got: %s", (empty == SDL_TRUE) ? "SDL_TRUE" : "SDL_FALSE");
 
@@ -742,7 +742,7 @@ int rect_testHasIntersectionInside(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_HasRectIntersection(&rectA, &rectB);
-    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
+    validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
 
     return TEST_COMPLETED;
 }
@@ -769,7 +769,7 @@ int rect_testHasIntersectionOutside(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_HasRectIntersection(&rectA, &rectB);
-    _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
+    validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
 
     return TEST_COMPLETED;
 }
@@ -796,7 +796,7 @@ int rect_testHasIntersectionPartial(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_HasRectIntersection(&rectA, &rectB);
-    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
+    validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
 
     /* rectB right edge */
     refRectB.x = rectA.w - 1;
@@ -806,7 +806,7 @@ int rect_testHasIntersectionPartial(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_HasRectIntersection(&rectA, &rectB);
-    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
+    validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
 
     /* rectB left edge */
     refRectB.x = 1 - rectA.w;
@@ -816,7 +816,7 @@ int rect_testHasIntersectionPartial(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_HasRectIntersection(&rectA, &rectB);
-    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
+    validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
 
     /* rectB bottom edge */
     refRectB.x = rectA.x;
@@ -826,7 +826,7 @@ int rect_testHasIntersectionPartial(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_HasRectIntersection(&rectA, &rectB);
-    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
+    validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
 
     /* rectB top edge */
     refRectB.x = rectA.x;
@@ -836,7 +836,7 @@ int rect_testHasIntersectionPartial(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_HasRectIntersection(&rectA, &rectB);
-    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
+    validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
 
     return TEST_COMPLETED;
 }
@@ -864,7 +864,7 @@ int rect_testHasIntersectionPoint(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_HasRectIntersection(&rectA, &rectB);
-    _validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
+    validateHasIntersectionResults(intersection, SDL_TRUE, &rectA, &rectB, &refRectA, &refRectB);
 
     /* non-intersecting pixels cases */
     for (offsetX = -1; offsetX <= 1; offsetX++) {
@@ -879,7 +879,7 @@ int rect_testHasIntersectionPoint(void *arg)
                 rectA = refRectA;
                 rectB = refRectB;
                 intersection = SDL_HasRectIntersection(&rectA, &rectB);
-                _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
+                validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
             }
         }
     }
@@ -912,7 +912,7 @@ int rect_testHasIntersectionEmpty(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_HasRectIntersection(&rectA, &rectB);
-    _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
+    validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
 
     /* Rect B empty */
     refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
@@ -925,7 +925,7 @@ int rect_testHasIntersectionEmpty(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_HasRectIntersection(&rectA, &rectB);
-    _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
+    validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
 
     /* Rect A and B empty */
     refRectA.x = SDLTest_RandomIntegerInRange(1, 100);
@@ -940,7 +940,7 @@ int rect_testHasIntersectionEmpty(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     intersection = SDL_HasRectIntersection(&rectA, &rectB);
-    _validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
+    validateHasIntersectionResults(intersection, SDL_FALSE, &rectA, &rectB, &refRectA, &refRectB);
 
     return TEST_COMPLETED;
 }
@@ -1303,7 +1303,7 @@ int rect_testUnionRectOutside(void *arg)
                 rectA = refRectA;
                 rectB = refRectB;
                 SDL_GetRectUnion(&rectA, &rectB, &result);
-                _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
+                validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
             }
         }
     }
@@ -1336,7 +1336,7 @@ int rect_testUnionRectOutside(void *arg)
                 rectA = refRectA;
                 rectB = refRectB;
                 SDL_GetRectUnion(&rectA, &rectB, &result);
-                _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
+                validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
             }
         }
     }
@@ -1370,7 +1370,7 @@ int rect_testUnionRectEmpty(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     SDL_GetRectUnion(&rectA, &rectB, &result);
-    _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
+    validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
 
     /* B empty */
     refRectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
@@ -1385,7 +1385,7 @@ int rect_testUnionRectEmpty(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     SDL_GetRectUnion(&rectA, &rectB, &result);
-    _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
+    validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
 
     /* A and B empty */
     refRectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
@@ -1404,7 +1404,7 @@ int rect_testUnionRectEmpty(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     SDL_GetRectUnion(&rectA, &rectB, &result);
-    _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
+    validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
 
     return TEST_COMPLETED;
 }
@@ -1431,7 +1431,7 @@ int rect_testUnionRectInside(void *arg)
     expectedResult = refRectA;
     rectA = refRectA;
     SDL_GetRectUnion(&rectA, &rectA, &result);
-    _validateUnionRectResults(&rectA, &rectA, &refRectA, &refRectA, &result, &expectedResult);
+    validateUnionRectResults(&rectA, &rectA, &refRectA, &refRectA, &result, &expectedResult);
 
     /* Union 1x1 somewhere inside */
     refRectA.x = SDLTest_RandomIntegerInRange(-1024, 1024);
@@ -1446,7 +1446,7 @@ int rect_testUnionRectInside(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     SDL_GetRectUnion(&rectA, &rectB, &result);
-    _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
+    validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
 
     /* Union inside with edges modified */
     for (dx = -1; dx < 2; dx++) {
@@ -1473,7 +1473,7 @@ int rect_testUnionRectInside(void *arg)
                 rectA = refRectA;
                 rectB = refRectB;
                 SDL_GetRectUnion(&rectA, &rectB, &result);
-                _validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
+                validateUnionRectResults(&rectA, &rectB, &refRectA, &refRectB, &result, &expectedResult);
             }
         }
     }
@@ -1531,7 +1531,7 @@ int rect_testRectEmpty(void *arg)
     expectedResult = SDL_FALSE;
     rect = refRect;
     result = SDL_RectEmpty(&rect);
-    _validateRectEmptyResults(result, expectedResult, &rect, &refRect);
+    validateRectEmptyResults(result, expectedResult, &rect, &refRect);
 
     /* Empty case */
     for (w = -1; w < 2; w++) {
@@ -1544,7 +1544,7 @@ int rect_testRectEmpty(void *arg)
                 expectedResult = SDL_TRUE;
                 rect = refRect;
                 result = SDL_RectEmpty(&rect);
-                _validateRectEmptyResults(result, expectedResult, &rect, &refRect);
+                validateRectEmptyResults(result, expectedResult, &rect, &refRect);
             }
         }
     }
@@ -1594,7 +1594,7 @@ int rect_testRectEquals(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     result = SDL_RectsEqual(&rectA, &rectB);
-    _validateRectEqualsResults(result, expectedResult, &rectA, &rectB, &refRectA, &refRectB);
+    validateRectEqualsResults(result, expectedResult, &rectA, &rectB, &refRectA, &refRectB);
 
     return TEST_COMPLETED;
 }
@@ -1657,7 +1657,7 @@ int rect_testFRectEquals(void *arg)
     rectA = refRectA;
     rectB = refRectB;
     result = SDL_RectsEqualF(&rectA, &rectB);
-    _validateFRectEqualsResults(result, expectedResult, &rectA, &rectB, &refRectA, &refRectB);
+    validateFRectEqualsResults(result, expectedResult, &rectA, &rectB, &refRectA, &refRectB);
 
     return TEST_COMPLETED;
 }

test/testautomation_render.c

@@ -22,14 +22,14 @@ SDL_Renderer *renderer = NULL;
 
 /* Prototypes for helper functions */
 
-static int _clearScreen(void);
-static void _compare(SDL_Surface *reference, int allowable_error);
-static int _hasTexAlpha(void);
-static int _hasTexColor(void);
-static SDL_Texture *_loadTestFace(void);
-static int _hasBlendModes(void);
-static int _hasDrawColor(void);
-static int _isSupported(int code);
+static int clearScreen(void);
+static void compare(SDL_Surface *reference, int allowable_error);
+static int hasTexAlpha(void);
+static int hasTexColor(void);
+static SDL_Texture *loadTestFace(void);
+static int hasBlendModes(void);
+static int hasDrawColor(void);
+static int isSupported(int code);
 
 /**
  * Create software renderer for tests
@@ -105,10 +105,10 @@ int render_testPrimitives(void *arg)
     int checkFailCount2;
 
     /* Clear surface. */
-    _clearScreen();
+    clearScreen();
 
     /* Need drawcolor or just skip test. */
-    SDLTest_AssertCheck(_hasDrawColor(), "_hasDrawColor");
+    SDLTest_AssertCheck(hasDrawColor(), "_hasDrawColor");
 
     /* Draw a rectangle. */
     rect.x = 40;
@@ -185,7 +185,7 @@ int render_testPrimitives(void *arg)
 
     /* See if it's the same. */
     referenceSurface = SDLTest_ImagePrimitives();
-    _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE);
+    compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE);
 
     /* Make current */
     SDL_RenderPresent(renderer);
@@ -216,11 +216,11 @@ int render_testPrimitivesBlend(void *arg)
     int checkFailCount3;
 
     /* Clear surface. */
-    _clearScreen();
+    clearScreen();
 
     /* Need drawcolor and blendmode or just skip test. */
-    SDLTest_AssertCheck(_hasDrawColor(), "_hasDrawColor");
-    SDLTest_AssertCheck(_hasBlendModes(), "_hasBlendModes");
+    SDLTest_AssertCheck(hasDrawColor(), "_hasDrawColor");
+    SDLTest_AssertCheck(hasBlendModes(), "_hasBlendModes");
 
     /* Create some rectangles for each blend mode. */
     ret = SDL_SetRenderDrawColor(renderer, 255, 255, 255, 0);
@@ -349,7 +349,7 @@ int render_testPrimitivesBlend(void *arg)
 
     /* See if it's the same. */
     referenceSurface = SDLTest_ImagePrimitivesBlend();
-    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
+    compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
 
     /* Make current */
     SDL_RenderPresent(renderer);
@@ -380,14 +380,14 @@ int render_testBlit(void *arg)
     int checkFailCount1;
 
     /* Clear surface. */
-    _clearScreen();
+    clearScreen();
 
     /* Need drawcolor or just skip test. */
-    SDLTest_AssertCheck(_hasDrawColor(), "_hasDrawColor)");
+    SDLTest_AssertCheck(hasDrawColor(), "_hasDrawColor)");
 
     /* Create face surface. */
-    tface = _loadTestFace();
-    SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
+    tface = loadTestFace();
+    SDLTest_AssertCheck(tface != NULL, "Verify loadTestFace() result");
     if (tface == NULL) {
         return TEST_ABORTED;
     }
@@ -417,7 +417,7 @@ int render_testBlit(void *arg)
 
     /* See if it's the same */
     referenceSurface = SDLTest_ImageBlit();
-    _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE);
+    compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE);
 
     /* Make current */
     SDL_RenderPresent(renderer);
@@ -451,11 +451,11 @@ int render_testBlitColor(void *arg)
     int checkFailCount2;
 
     /* Clear surface. */
-    _clearScreen();
+    clearScreen();
 
     /* Create face surface. */
-    tface = _loadTestFace();
-    SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
+    tface = loadTestFace();
+    SDLTest_AssertCheck(tface != NULL, "Verify loadTestFace() result");
     if (tface == NULL) {
         return TEST_ABORTED;
     }
@@ -493,7 +493,7 @@ int render_testBlitColor(void *arg)
 
     /* See if it's the same. */
     referenceSurface = SDLTest_ImageBlitColor();
-    _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE);
+    compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE);
 
     /* Make current */
     SDL_RenderPresent(renderer);
@@ -527,14 +527,14 @@ int render_testBlitAlpha(void *arg)
     int checkFailCount2;
 
     /* Clear surface. */
-    _clearScreen();
+    clearScreen();
 
     /* Need alpha or just skip test. */
-    SDLTest_AssertCheck(_hasTexAlpha(), "_hasTexAlpha");
+    SDLTest_AssertCheck(hasTexAlpha(), "_hasTexAlpha");
 
     /* Create face surface. */
-    tface = _loadTestFace();
-    SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
+    tface = loadTestFace();
+    SDLTest_AssertCheck(tface != NULL, "Verify loadTestFace() result");
     if (tface == NULL) {
         return TEST_ABORTED;
     }
@@ -572,7 +572,7 @@ int render_testBlitAlpha(void *arg)
 
     /* See if it's the same. */
     referenceSurface = SDLTest_ImageBlitAlpha();
-    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
+    compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
 
     /* Make current */
     SDL_RenderPresent(renderer);
@@ -595,7 +595,7 @@ int render_testBlitAlpha(void *arg)
  * http://wiki.libsdl.org/SDL_RenderTexture
  */
 static void
-_testBlitBlendMode(SDL_Texture *tface, int mode)
+testBlitBlendMode(SDL_Texture *tface, int mode)
 {
     int ret;
     Uint32 tformat;
@@ -606,7 +606,7 @@ _testBlitBlendMode(SDL_Texture *tface, int mode)
     int checkFailCount2;
 
     /* Clear surface. */
-    _clearScreen();
+    clearScreen();
 
     /* Constant values. */
     ret = SDL_QueryTexture(tface, &tformat, &taccess, &tw, &th);
@@ -664,13 +664,13 @@ int render_testBlitBlend(void *arg)
     int checkFailCount3;
     int checkFailCount4;
 
-    SDLTest_AssertCheck(_hasBlendModes(), "_hasBlendModes");
-    SDLTest_AssertCheck(_hasTexColor(), "_hasTexColor");
-    SDLTest_AssertCheck(_hasTexAlpha(), "_hasTexAlpha");
+    SDLTest_AssertCheck(hasBlendModes(), "_hasBlendModes");
+    SDLTest_AssertCheck(hasTexColor(), "_hasTexColor");
+    SDLTest_AssertCheck(hasTexAlpha(), "_hasTexAlpha");
 
     /* Create face surface. */
-    tface = _loadTestFace();
-    SDLTest_AssertCheck(tface != NULL, "Verify _loadTestFace() result");
+    tface = loadTestFace();
+    SDLTest_AssertCheck(tface != NULL, "Verify loadTestFace() result");
     if (tface == NULL) {
         return TEST_ABORTED;
     }
@@ -688,51 +688,51 @@ int render_testBlitBlend(void *arg)
     SDLTest_AssertCheck(ret == 0, "Validate result from SDL_SetTextureAlphaMod, expected: 0, got: %i", ret);
 
     /* Test None. */
-    _testBlitBlendMode(tface, SDL_BLENDMODE_NONE);
+    testBlitBlendMode(tface, SDL_BLENDMODE_NONE);
     referenceSurface = SDLTest_ImageBlitBlendNone();
 
     /* Compare, then Present */
-    _compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE);
+    compare(referenceSurface, ALLOWABLE_ERROR_OPAQUE);
     SDL_RenderPresent(renderer);
 
     SDL_DestroySurface(referenceSurface);
     referenceSurface = NULL;
 
     /* Test Blend. */
-    _testBlitBlendMode(tface, SDL_BLENDMODE_BLEND);
+    testBlitBlendMode(tface, SDL_BLENDMODE_BLEND);
     referenceSurface = SDLTest_ImageBlitBlend();
 
     /* Compare, then Present */
-    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
+    compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
     SDL_RenderPresent(renderer);
 
     SDL_DestroySurface(referenceSurface);
     referenceSurface = NULL;
 
     /* Test Add. */
-    _testBlitBlendMode(tface, SDL_BLENDMODE_ADD);
+    testBlitBlendMode(tface, SDL_BLENDMODE_ADD);
     referenceSurface = SDLTest_ImageBlitBlendAdd();
 
     /* Compare, then Present */
-    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
+    compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
     SDL_RenderPresent(renderer);
 
     SDL_DestroySurface(referenceSurface);
     referenceSurface = NULL;
 
     /* Test Mod. */
-    _testBlitBlendMode(tface, SDL_BLENDMODE_MOD);
+    testBlitBlendMode(tface, SDL_BLENDMODE_MOD);
     referenceSurface = SDLTest_ImageBlitBlendMod();
 
     /* Compare, then Present */
-    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
+    compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
     SDL_RenderPresent(renderer);
 
     SDL_DestroySurface(referenceSurface);
     referenceSurface = NULL;
 
     /* Clear surface. */
-    _clearScreen();
+    clearScreen();
 
     /* Loop blit. */
     checkFailCount1 = 0;
@@ -789,7 +789,7 @@ int render_testBlitBlend(void *arg)
 
     /* Check to see if final image matches. */
     referenceSurface = SDLTest_ImageBlitBlendAll();
-    _compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
+    compare(referenceSurface, ALLOWABLE_ERROR_BLENDED);
 
     /* Make current */
     SDL_RenderPresent(renderer);
@@ -804,7 +804,7 @@ int render_testBlitBlend(void *arg)
  * @brief Checks to see if functionality is supported. Helper function.
  */
 static int
-_isSupported(int code)
+isSupported(int code)
 {
     return code == 0;
 }
@@ -817,7 +817,7 @@ _isSupported(int code)
  * http://wiki.libsdl.org/SDL_GetRenderDrawColor
  */
 static int
-_hasDrawColor(void)
+hasDrawColor(void)
 {
     int ret, fail;
     Uint8 r, g, b, a;
@@ -826,17 +826,17 @@ _hasDrawColor(void)
 
     /* Set color. */
     ret = SDL_SetRenderDrawColor(renderer, 100, 100, 100, 100);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = SDL_GetRenderDrawColor(renderer, &r, &g, &b, &a);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
 
     /* Restore natural. */
     ret = SDL_SetRenderDrawColor(renderer, 0, 0, 0, SDL_ALPHA_OPAQUE);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
 
@@ -859,7 +859,7 @@ _hasDrawColor(void)
  * http://wiki.libsdl.org/SDL_GetRenderDrawBlendMode
  */
 static int
-_hasBlendModes(void)
+hasBlendModes(void)
 {
     int fail;
     int ret;
@@ -868,51 +868,51 @@ _hasBlendModes(void)
     fail = 0;
 
     ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_BLEND);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = SDL_GetRenderDrawBlendMode(renderer, &mode);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = (mode != SDL_BLENDMODE_BLEND);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_ADD);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = SDL_GetRenderDrawBlendMode(renderer, &mode);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = (mode != SDL_BLENDMODE_ADD);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_MOD);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = SDL_GetRenderDrawBlendMode(renderer, &mode);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = (mode != SDL_BLENDMODE_MOD);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = SDL_SetRenderDrawBlendMode(renderer, SDL_BLENDMODE_NONE);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = SDL_GetRenderDrawBlendMode(renderer, &mode);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = (mode != SDL_BLENDMODE_NONE);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
 
@@ -926,7 +926,7 @@ _hasBlendModes(void)
  * http://wiki.libsdl.org/SDL_CreateTextureFromSurface
  */
 static SDL_Texture *
-_loadTestFace(void)
+loadTestFace(void)
 {
     SDL_Surface *face;
     SDL_Texture *tface;
@@ -955,7 +955,7 @@ _loadTestFace(void)
  * http://wiki.libsdl.org/SDL_DestroyTexture
  */
 static int
-_hasTexColor(void)
+hasTexColor(void)
 {
     int fail;
     int ret;
@@ -963,7 +963,7 @@ _hasTexColor(void)
     Uint8 r, g, b;
 
     /* Get test face. */
-    tface = _loadTestFace();
+    tface = loadTestFace();
     if (tface == NULL) {
         return 0;
     }
@@ -971,11 +971,11 @@ _hasTexColor(void)
     /* See if supported. */
     fail = 0;
     ret = SDL_SetTextureColorMod(tface, 100, 100, 100);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = SDL_GetTextureColorMod(tface, &r, &g, &b);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
 
@@ -999,7 +999,7 @@ _hasTexColor(void)
  *  http://wiki.libsdl.org/SDL_DestroyTexture
  */
 static int
-_hasTexAlpha(void)
+hasTexAlpha(void)
 {
     int fail;
     int ret;
@@ -1007,7 +1007,7 @@ _hasTexAlpha(void)
     Uint8 a;
 
     /* Get test face. */
-    tface = _loadTestFace();
+    tface = loadTestFace();
     if (tface == NULL) {
         return 0;
     }
@@ -1015,11 +1015,11 @@ _hasTexAlpha(void)
     /* See if supported. */
     fail = 0;
     ret = SDL_SetTextureAlphaMod(tface, 100);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
     ret = SDL_GetTextureAlphaMod(tface, &a);
-    if (!_isSupported(ret)) {
+    if (!isSupported(ret)) {
         fail = 1;
     }
 
@@ -1045,7 +1045,7 @@ _hasTexAlpha(void)
  * http://wiki.libsdl.org/SDL_DestroySurface
  */
 static void
-_compare(SDL_Surface *referenceSurface, int allowable_error)
+compare(SDL_Surface *referenceSurface, int allowable_error)
 {
    int result;
    SDL_Rect rect;
@@ -1090,7 +1090,7 @@ _compare(SDL_Surface *referenceSurface, int allowable_error)
  * http://wiki.libsdl.org/SDL_SetRenderDrawBlendMode
  */
 static int
-_clearScreen(void)
+clearScreen(void)
 {
     int ret;
 

test/testautomation_rwops.c

@@ -95,7 +95,7 @@ void RWopsTearDown(void *arg)
  * http://wiki.libsdl.org/SDL_RWseek
  * http://wiki.libsdl.org/SDL_RWread
  */
-void _testGenericRWopsValidations(SDL_RWops *rw, int write)
+static void testGenericRWopsValidations(SDL_RWops *rw, int write)
 {
     char buf[sizeof(RWopsHelloWorldTestString)];
     Sint64 i;
@@ -242,7 +242,7 @@ int rwops_testMem(void)
     SDLTest_AssertCheck(rw->type == SDL_RWOPS_MEMORY, "Verify RWops type is SDL_RWOPS_MEMORY; expected: %d, got: %" SDL_PRIu32, SDL_RWOPS_MEMORY, rw->type);
 
     /* Run generic tests */
-    _testGenericRWopsValidations(rw, 1);
+    testGenericRWopsValidations(rw, 1);
 
     /* Close */
     result = SDL_RWclose(rw);
@@ -278,7 +278,7 @@ int rwops_testConstMem(void)
     SDLTest_AssertCheck(rw->type == SDL_RWOPS_MEMORY_RO, "Verify RWops type is SDL_RWOPS_MEMORY_RO; expected: %d, got: %" SDL_PRIu32, SDL_RWOPS_MEMORY_RO, rw->type);
 
     /* Run generic tests */
-    _testGenericRWopsValidations(rw, 0);
+    testGenericRWopsValidations(rw, 0);
 
     /* Close handle */
     result = SDL_RWclose(rw);
@@ -326,7 +326,7 @@ int rwops_testFileRead(void)
 #endif
 
     /* Run generic tests */
-    _testGenericRWopsValidations(rw, 0);
+    testGenericRWopsValidations(rw, 0);
 
     /* Close handle */
     result = SDL_RWclose(rw);
@@ -374,7 +374,7 @@ int rwops_testFileWrite(void)
 #endif
 
     /* Run generic tests */
-    _testGenericRWopsValidations(rw, 1);
+    testGenericRWopsValidations(rw, 1);
 
     /* Close handle */
     result = SDL_RWclose(rw);

test/testautomation_surface.c

@@ -35,12 +35,12 @@ static SDL_Surface *testSurface = NULL;
 /* Fixture */
 
 /* Create a 32-bit writable surface for blitting tests */
-void _surfaceSetUp(void *arg)
+static void surfaceSetUp(void *arg)
 {
     int result;
     SDL_BlendMode blendMode = SDL_BLENDMODE_NONE;
     SDL_BlendMode currentBlendMode;
-    
+
     referenceSurface = SDLTest_ImageBlit(); /* For size info */
     testSurface = SDL_CreateSurface(referenceSurface->w, referenceSurface->h, SDL_PIXELFORMAT_RGBA32);
     SDLTest_AssertCheck(testSurface != NULL, "Check that testSurface is not NULL");
@@ -54,7 +54,7 @@ void _surfaceSetUp(void *arg)
     }
 }
 
-void _surfaceTearDown(void *arg)
+static void surfaceTearDown(void *arg)
 {
     SDL_DestroySurface(referenceSurface);
     referenceSurface = NULL;
@@ -65,7 +65,7 @@ void _surfaceTearDown(void *arg)
 /**
  * Helper that clears the test surface
  */
-void _clearTestSurface()
+static void clearTestSurface()
 {
     int ret;
     Uint32 color;
@@ -81,7 +81,7 @@ void _clearTestSurface()
 /**
  * Helper that blits in a specific blend mode, -1 for basic blitting, -2 for color mod, -3 for alpha mod, -4 for mixed blend modes.
  */
-void _testBlitBlendMode(int mode)
+static void testBlitBlendMode(int mode)
 {
     int ret;
     int i, j, ni, nj;
@@ -123,7 +123,7 @@ void _testBlitBlendMode(int mode)
     SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SetSurfaceColorKey(), expected: 0, got: %i", ret);
 
     /* Clear the test surface */
-    _clearTestSurface();
+    clearTestSurface();
 
     /* Target rect size */
     rect.w = face->w;
@@ -201,7 +201,7 @@ void _testBlitBlendMode(int mode)
 }
 
 /* Helper to check that a file exists */
-void _AssertFileExist(const char *filename)
+static void AssertFileExist(const char *filename)
 {
     struct stat st;
     int ret = stat(filename, &st);
@@ -235,7 +235,7 @@ int surface_testSaveLoadBitmap(void *arg)
     ret = SDL_SaveBMP(face, sampleFilename);
     SDLTest_AssertPass("Call to SDL_SaveBMP()");
     SDLTest_AssertCheck(ret == 0, "Verify result from SDL_SaveBMP, expected: 0, got: %i", ret);
-    _AssertFileExist(sampleFilename);
+    AssertFileExist(sampleFilename);
 
     /* Load a surface */
     rface = SDL_LoadBMP(sampleFilename);
@@ -408,7 +408,7 @@ int surface_testBlit(void *arg)
     SDL_Surface *compareSurface;
 
     /* Basic blitting */
-    _testBlitBlendMode(-1);
+    testBlitBlendMode(-1);
 
     /* Verify result by comparing surfaces */
     compareSurface = SDLTest_ImageBlit();
@@ -430,7 +430,7 @@ int surface_testBlitColorMod(void *arg)
     SDL_Surface *compareSurface;
 
     /* Basic blitting with color mod */
-    _testBlitBlendMode(-2);
+    testBlitBlendMode(-2);
 
     /* Verify result by comparing surfaces */
     compareSurface = SDLTest_ImageBlitColor();
@@ -452,7 +452,7 @@ int surface_testBlitAlphaMod(void *arg)
     SDL_Surface *compareSurface;
 
     /* Basic blitting with alpha mod */
-    _testBlitBlendMode(-3);
+    testBlitBlendMode(-3);
 
     /* Verify result by comparing surfaces */
     compareSurface = SDLTest_ImageBlitAlpha();
@@ -474,7 +474,7 @@ int surface_testBlitBlendNone(void *arg)
     SDL_Surface *compareSurface;
 
     /* Basic blitting */
-    _testBlitBlendMode(SDL_BLENDMODE_NONE);
+    testBlitBlendMode(SDL_BLENDMODE_NONE);
 
     /* Verify result by comparing surfaces */
     compareSurface = SDLTest_ImageBlitBlendNone();
@@ -496,7 +496,7 @@ int surface_testBlitBlendBlend(void *arg)
     SDL_Surface *compareSurface;
 
     /* Blend blitting */
-    _testBlitBlendMode(SDL_BLENDMODE_BLEND);
+    testBlitBlendMode(SDL_BLENDMODE_BLEND);
 
     /* Verify result by comparing surfaces */
     compareSurface = SDLTest_ImageBlitBlend();
@@ -518,7 +518,7 @@ int surface_testBlitBlendAdd(void *arg)
     SDL_Surface *compareSurface;
 
     /* Add blitting */
-    _testBlitBlendMode(SDL_BLENDMODE_ADD);
+    testBlitBlendMode(SDL_BLENDMODE_ADD);
 
     /* Verify result by comparing surfaces */
     compareSurface = SDLTest_ImageBlitBlendAdd();
@@ -540,7 +540,7 @@ int surface_testBlitBlendMod(void *arg)
     SDL_Surface *compareSurface;
 
     /* Mod blitting */
-    _testBlitBlendMode(SDL_BLENDMODE_MOD);
+    testBlitBlendMode(SDL_BLENDMODE_MOD);
 
     /* Verify result by comparing surfaces */
     compareSurface = SDLTest_ImageBlitBlendMod();
@@ -563,7 +563,7 @@ int surface_testBlitBlendLoop(void *arg)
     SDL_Surface *compareSurface;
 
     /* All blitting modes */
-    _testBlitBlendMode(-4);
+    testBlitBlendMode(-4);
 
     /* Verify result by comparing surfaces */
     compareSurface = SDLTest_ImageBlitBlendAll();
@@ -813,8 +813,8 @@ static const SDLTest_TestCaseReference *surfaceTests[] = {
 /* Surface test suite (global) */
 SDLTest_TestSuiteReference surfaceTestSuite = {
     "Surface",
-    _surfaceSetUp,
+    surfaceSetUp,
     surfaceTests,
-    _surfaceTearDown
+    surfaceTearDown
 
 };

test/testautomation_timer.c

@@ -5,17 +5,17 @@
 #include <SDL3/SDL_test.h>
 
 /* Flag indicating if the param should be checked */
-int _paramCheck = 0;
+static int g_paramCheck = 0;
 
 /* Userdata value to check */
-int _paramValue = 0;
+static int g_paramValue = 0;
 
 /* Flag indicating that the callback was called */
-int _timerCallbackCalled = 0;
+static int g_timerCallbackCalled = 0;
 
 /* Fixture */
 
-void _timerSetUp(void *arg)
+static void timerSetUp(void *arg)
 {
     /* Start SDL timer subsystem */
     int ret = SDL_InitSubSystem(SDL_INIT_TIMER);
@@ -97,14 +97,14 @@ int timer_delayAndGetTicks(void *arg)
 }
 
 /* Test callback */
-Uint32 SDLCALL _timerTestCallback(Uint32 interval, void *param)
+static Uint32 SDLCALL timerTestCallback(Uint32 interval, void *param)
 {
-    _timerCallbackCalled = 1;
+    g_timerCallbackCalled = 1;
 
-    if (_paramCheck != 0) {
+    if (g_paramCheck != 0) {
         SDLTest_AssertCheck(param != NULL, "Check param pointer, expected: non-NULL, got: %s", (param != NULL) ? "non-NULL" : "NULL");
         if (param != NULL) {
-            SDLTest_AssertCheck(*(int *)param == _paramValue, "Check param value, expected: %i, got: %i", _paramValue, *(int *)param);
+            SDLTest_AssertCheck(*(int *)param == g_paramValue, "Check param value, expected: %i, got: %i", g_paramValue, *(int *)param);
         }
     }
 
@@ -121,11 +121,11 @@ int timer_addRemoveTimer(void *arg)
     int param;
 
     /* Reset state */
-    _paramCheck = 0;
-    _timerCallbackCalled = 0;
+    g_paramCheck = 0;
+    g_timerCallbackCalled = 0;
 
     /* Set timer with a long delay */
-    id = SDL_AddTimer(10000, _timerTestCallback, NULL);
+    id = SDL_AddTimer(10000, timerTestCallback, NULL);
     SDLTest_AssertPass("Call to SDL_AddTimer(10000,...)");
     SDLTest_AssertCheck(id > 0, "Check result value, expected: >0, got: %d", id);
 
@@ -133,7 +133,7 @@ int timer_addRemoveTimer(void *arg)
     result = SDL_RemoveTimer(id);
     SDLTest_AssertPass("Call to SDL_RemoveTimer()");
     SDLTest_AssertCheck(result == SDL_TRUE, "Check result value, expected: %i, got: %i", SDL_TRUE, result);
-    SDLTest_AssertCheck(_timerCallbackCalled == 0, "Check callback WAS NOT called, expected: 0, got: %i", _timerCallbackCalled);
+    SDLTest_AssertCheck(g_timerCallbackCalled == 0, "Check callback WAS NOT called, expected: 0, got: %i", g_timerCallbackCalled);
 
     /* Try to remove timer again (should be a NOOP) */
     result = SDL_RemoveTimer(id);
@@ -142,12 +142,12 @@ int timer_addRemoveTimer(void *arg)
 
     /* Reset state */
     param = SDLTest_RandomIntegerInRange(-1024, 1024);
-    _paramCheck = 1;
-    _paramValue = param;
-    _timerCallbackCalled = 0;
+    g_paramCheck = 1;
+    g_paramValue = param;
+    g_timerCallbackCalled = 0;
 
     /* Set timer with a short delay */
-    id = SDL_AddTimer(10, _timerTestCallback, (void *)&param);
+    id = SDL_AddTimer(10, timerTestCallback, (void *)&param);
     SDLTest_AssertPass("Call to SDL_AddTimer(10, param)");
     SDLTest_AssertCheck(id > 0, "Check result value, expected: >0, got: %d", id);
 
@@ -159,7 +159,7 @@ int timer_addRemoveTimer(void *arg)
     result = SDL_RemoveTimer(id);
     SDLTest_AssertPass("Call to SDL_RemoveTimer()");
     SDLTest_AssertCheck(result == SDL_FALSE, "Check result value, expected: %i, got: %i", SDL_FALSE, result);
-    SDLTest_AssertCheck(_timerCallbackCalled == 1, "Check callback WAS called, expected: 1, got: %i", _timerCallbackCalled);
+    SDLTest_AssertCheck(g_timerCallbackCalled == 1, "Check callback WAS called, expected: 1, got: %i", g_timerCallbackCalled);
 
     return TEST_COMPLETED;
 }
@@ -191,7 +191,7 @@ static const SDLTest_TestCaseReference *timerTests[] = {
 /* Timer test suite (global) */
 SDLTest_TestSuiteReference timerTestSuite = {
     "Timer",
-    _timerSetUp,
+    timerSetUp,
     timerTests,
     NULL
 };

test/testautomation_video.c

@@ -9,7 +9,7 @@
 /*
  * Create a test window
  */
-SDL_Window *_createVideoSuiteTestWindow(const char *title)
+static SDL_Window *createVideoSuiteTestWindow(const char *title)
 {
     SDL_Window *window;
     int x, y, w, h;
@@ -32,7 +32,7 @@ SDL_Window *_createVideoSuiteTestWindow(const char *title)
 /*
  * Destroy test window
  */
-void _destroyVideoSuiteTestWindow(SDL_Window *window)
+static void destroyVideoSuiteTestWindow(SDL_Window *window)
 {
     if (window != NULL) {
         SDL_DestroyWindow(window);
@@ -169,7 +169,7 @@ int video_createWindowVariousPositions(void *arg)
             SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL");
 
             /* Clean up */
-            _destroyVideoSuiteTestWindow(window);
+            destroyVideoSuiteTestWindow(window);
         }
     }
 
@@ -225,7 +225,7 @@ int video_createWindowVariousSizes(void *arg)
             SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL");
 
             /* Clean up */
-            _destroyVideoSuiteTestWindow(window);
+            destroyVideoSuiteTestWindow(window);
         }
     }
 
@@ -305,7 +305,7 @@ int video_createWindowVariousFlags(void *arg)
         SDLTest_AssertCheck(window != NULL, "Validate that returned window struct is not NULL");
 
         /* Clean up */
-        _destroyVideoSuiteTestWindow(window);
+        destroyVideoSuiteTestWindow(window);
     }
 
     return TEST_COMPLETED;
@@ -325,7 +325,7 @@ int video_getWindowFlags(void *arg)
     flags = 0;
 
     /* Call against new test window */
-    window = _createVideoSuiteTestWindow(title);
+    window = createVideoSuiteTestWindow(title);
     if (window != NULL) {
         actualFlags = SDL_GetWindowFlags(window);
         SDLTest_AssertPass("Call to SDL_GetWindowFlags()");
@@ -333,7 +333,7 @@ int video_getWindowFlags(void *arg)
     }
 
     /* Clean up */
-    _destroyVideoSuiteTestWindow(window);
+    destroyVideoSuiteTestWindow(window);
 
     return TEST_COMPLETED;
 }
@@ -506,7 +506,7 @@ int video_getWindowDisplayMode(void *arg)
     mode.refresh_rate = -1;
 
     /* Call against new test window */
-    window = _createVideoSuiteTestWindow(title);
+    window = createVideoSuiteTestWindow(title);
     if (window != NULL) {
         result = SDL_GetWindowDisplayMode(window, &mode);
         SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode()");
@@ -517,13 +517,13 @@ int video_getWindowDisplayMode(void *arg)
     }
 
     /* Clean up */
-    _destroyVideoSuiteTestWindow(window);
+    destroyVideoSuiteTestWindow(window);
 
     return TEST_COMPLETED;
 }
 
 /* Helper function that checks for an 'Invalid window' error */
-void _checkInvalidWindowError()
+static void checkInvalidWindowError()
 {
     const char *invalidWindowError = "Invalid window";
     char *lastError;
@@ -556,7 +556,7 @@ int video_getWindowDisplayModeNegative(void *arg)
     int result;
 
     /* Call against new test window */
-    window = _createVideoSuiteTestWindow(title);
+    window = createVideoSuiteTestWindow(title);
     if (window != NULL) {
         result = SDL_GetWindowDisplayMode(window, NULL);
         SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode(...,mode=NULL)");
@@ -573,19 +573,19 @@ int video_getWindowDisplayModeNegative(void *arg)
     }
 
     /* Clean up */
-    _destroyVideoSuiteTestWindow(window);
+    destroyVideoSuiteTestWindow(window);
 
     /* Call against invalid window */
     result = SDL_GetWindowDisplayMode(NULL, &mode);
     SDLTest_AssertPass("Call to SDL_GetWindowDisplayMode(window=NULL,...)");
     SDLTest_AssertCheck(result == -1, "Validate result value; expected: -1, got: %d", result);
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     return TEST_COMPLETED;
 }
 
 /* Helper for setting and checking the window mouse grab state */
-void _setAndCheckWindowMouseGrabState(SDL_Window *window, SDL_bool desiredState)
+static void setAndCheckWindowMouseGrabState(SDL_Window *window, SDL_bool desiredState)
 {
     SDL_bool currentState;
 
@@ -620,7 +620,7 @@ void _setAndCheckWindowMouseGrabState(SDL_Window *window, SDL_bool desiredState)
 }
 
 /* Helper for setting and checking the window keyboard grab state */
-void _setAndCheckWindowKeyboardGrabState(SDL_Window *window, SDL_bool desiredState)
+static void setAndCheckWindowKeyboardGrabState(SDL_Window *window, SDL_bool desiredState)
 {
     SDL_bool currentState;
 
@@ -667,7 +667,7 @@ int video_getSetWindowGrab(void *arg)
     SDL_bool originalMouseState, originalKeyboardState;
 
     /* Call against new test window */
-    window = _createVideoSuiteTestWindow(title);
+    window = createVideoSuiteTestWindow(title);
     if (window == NULL) {
         return TEST_ABORTED;
     }
@@ -679,49 +679,49 @@ int video_getSetWindowGrab(void *arg)
     SDLTest_AssertPass("Call to SDL_GetWindowKeyboardGrab()");
 
     /* F */
-    _setAndCheckWindowKeyboardGrabState(window, SDL_FALSE);
-    _setAndCheckWindowMouseGrabState(window, SDL_FALSE);
+    setAndCheckWindowKeyboardGrabState(window, SDL_FALSE);
+    setAndCheckWindowMouseGrabState(window, SDL_FALSE);
     SDLTest_AssertCheck(!SDL_GetWindowGrab(window),
                         "SDL_GetWindowGrab should return SDL_FALSE");
     SDLTest_AssertCheck(SDL_GetGrabbedWindow() == NULL,
                         "Expected NULL grabbed window");
 
     /* F --> F */
-    _setAndCheckWindowMouseGrabState(window, SDL_FALSE);
-    _setAndCheckWindowKeyboardGrabState(window, SDL_FALSE);
+    setAndCheckWindowMouseGrabState(window, SDL_FALSE);
+    setAndCheckWindowKeyboardGrabState(window, SDL_FALSE);
     SDLTest_AssertCheck(SDL_GetGrabbedWindow() == NULL,
                         "Expected NULL grabbed window");
 
     /* F --> T */
-    _setAndCheckWindowMouseGrabState(window, SDL_TRUE);
-    _setAndCheckWindowKeyboardGrabState(window, SDL_TRUE);
+    setAndCheckWindowMouseGrabState(window, SDL_TRUE);
+    setAndCheckWindowKeyboardGrabState(window, SDL_TRUE);
     SDLTest_AssertCheck(SDL_GetWindowGrab(window),
                         "SDL_GetWindowGrab() should return SDL_TRUE");
 
     /* T --> T */
-    _setAndCheckWindowKeyboardGrabState(window, SDL_TRUE);
-    _setAndCheckWindowMouseGrabState(window, SDL_TRUE);
+    setAndCheckWindowKeyboardGrabState(window, SDL_TRUE);
+    setAndCheckWindowMouseGrabState(window, SDL_TRUE);
     SDLTest_AssertCheck(SDL_GetWindowGrab(window),
                         "SDL_GetWindowGrab() should return SDL_TRUE");
 
     /* M: T --> F */
     /* K: T --> T */
-    _setAndCheckWindowKeyboardGrabState(window, SDL_TRUE);
-    _setAndCheckWindowMouseGrabState(window, SDL_FALSE);
+    setAndCheckWindowKeyboardGrabState(window, SDL_TRUE);
+    setAndCheckWindowMouseGrabState(window, SDL_FALSE);
     SDLTest_AssertCheck(SDL_GetWindowGrab(window),
                         "SDL_GetWindowGrab() should return SDL_TRUE");
 
     /* M: F --> T */
     /* K: T --> F */
-    _setAndCheckWindowMouseGrabState(window, SDL_TRUE);
-    _setAndCheckWindowKeyboardGrabState(window, SDL_FALSE);
+    setAndCheckWindowMouseGrabState(window, SDL_TRUE);
+    setAndCheckWindowKeyboardGrabState(window, SDL_FALSE);
     SDLTest_AssertCheck(SDL_GetWindowGrab(window),
                         "SDL_GetWindowGrab() should return SDL_TRUE");
 
     /* M: T --> F */
     /* K: F --> F */
-    _setAndCheckWindowMouseGrabState(window, SDL_FALSE);
-    _setAndCheckWindowKeyboardGrabState(window, SDL_FALSE);
+    setAndCheckWindowMouseGrabState(window, SDL_FALSE);
+    setAndCheckWindowKeyboardGrabState(window, SDL_FALSE);
     SDLTest_AssertCheck(!SDL_GetWindowGrab(window),
                         "SDL_GetWindowGrab() should return SDL_FALSE");
     SDLTest_AssertCheck(SDL_GetGrabbedWindow() == NULL,
@@ -765,34 +765,34 @@ int video_getSetWindowGrab(void *arg)
     /* Negative tests */
     SDL_GetWindowGrab(NULL);
     SDLTest_AssertPass("Call to SDL_GetWindowGrab(window=NULL)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_GetWindowKeyboardGrab(NULL);
     SDLTest_AssertPass("Call to SDL_GetWindowKeyboardGrab(window=NULL)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_SetWindowGrab(NULL, SDL_FALSE);
     SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_FALSE)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_SetWindowKeyboardGrab(NULL, SDL_FALSE);
     SDLTest_AssertPass("Call to SDL_SetWindowKeyboardGrab(window=NULL,SDL_FALSE)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_SetWindowGrab(NULL, SDL_TRUE);
     SDLTest_AssertPass("Call to SDL_SetWindowGrab(window=NULL,SDL_TRUE)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_SetWindowKeyboardGrab(NULL, SDL_TRUE);
     SDLTest_AssertPass("Call to SDL_SetWindowKeyboardGrab(window=NULL,SDL_TRUE)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     /* Restore state */
-    _setAndCheckWindowMouseGrabState(window, originalMouseState);
-    _setAndCheckWindowKeyboardGrabState(window, originalKeyboardState);
+    setAndCheckWindowMouseGrabState(window, originalMouseState);
+    setAndCheckWindowKeyboardGrabState(window, originalKeyboardState);
 
     /* Clean up */
-    _destroyVideoSuiteTestWindow(window);
+    destroyVideoSuiteTestWindow(window);
 
     return TEST_COMPLETED;
 }
@@ -811,7 +811,7 @@ int video_getWindowId(void *arg)
     Uint32 id, randomId;
 
     /* Call against new test window */
-    window = _createVideoSuiteTestWindow(title);
+    window = createVideoSuiteTestWindow(title);
     if (window == NULL) {
         return TEST_ABORTED;
     }
@@ -837,7 +837,7 @@ int video_getWindowId(void *arg)
     SDLTest_AssertPass("Call to SDL_GetWindowID(UINT32_MAX)");
 
     /* Clean up */
-    _destroyVideoSuiteTestWindow(window);
+    destroyVideoSuiteTestWindow(window);
 
     /* Get window from ID for closed window */
     result = SDL_GetWindowFromID(id);
@@ -849,7 +849,7 @@ int video_getWindowId(void *arg)
     SDLTest_AssertPass("Call to SDL_ClearError()");
     id = SDL_GetWindowID(NULL);
     SDLTest_AssertPass("Call to SDL_GetWindowID(window=NULL)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     return TEST_COMPLETED;
 }
@@ -866,7 +866,7 @@ int video_getWindowPixelFormat(void *arg)
     Uint32 format;
 
     /* Call against new test window */
-    window = _createVideoSuiteTestWindow(title);
+    window = createVideoSuiteTestWindow(title);
     if (window == NULL) {
         return TEST_ABORTED;
     }
@@ -877,14 +877,14 @@ int video_getWindowPixelFormat(void *arg)
     SDLTest_AssertCheck(format != SDL_PIXELFORMAT_UNKNOWN, "Verify that returned format is valid; expected: != %d, got: %" SDL_PRIu32, SDL_PIXELFORMAT_UNKNOWN, format);
 
     /* Clean up */
-    _destroyVideoSuiteTestWindow(window);
+    destroyVideoSuiteTestWindow(window);
 
     /* Negative test */
     SDL_ClearError();
     SDLTest_AssertPass("Call to SDL_ClearError()");
     format = SDL_GetWindowPixelFormat(NULL);
     SDLTest_AssertPass("Call to SDL_GetWindowPixelFormat(window=NULL)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     return TEST_COMPLETED;
 }
@@ -905,7 +905,7 @@ int video_getSetWindowPosition(void *arg)
     int desiredX, desiredY;
 
     /* Call against new test window */
-    window = _createVideoSuiteTestWindow(title);
+    window = createVideoSuiteTestWindow(title);
     if (window == NULL) {
         return TEST_ABORTED;
     }
@@ -983,7 +983,7 @@ int video_getSetWindowPosition(void *arg)
     SDLTest_AssertPass("Call to SDL_GetWindowPosition(&x=NULL,&y=NULL)");
 
     /* Clean up */
-    _destroyVideoSuiteTestWindow(window);
+    destroyVideoSuiteTestWindow(window);
 
     /* Set some 'magic' value for later check that nothing was changed */
     referenceX = SDLTest_RandomSint32();
@@ -1003,21 +1003,21 @@ int video_getSetWindowPosition(void *arg)
         "Verify that content of X and Y pointers has not been modified; expected: %d,%d; got: %d,%d",
         referenceX, referenceY,
         currentX, currentY);
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_GetWindowPosition(NULL, NULL, NULL);
     SDLTest_AssertPass("Call to SDL_GetWindowPosition(NULL, NULL, NULL)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_SetWindowPosition(NULL, desiredX, desiredY);
     SDLTest_AssertPass("Call to SDL_SetWindowPosition(window=NULL)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     return TEST_COMPLETED;
 }
 
 /* Helper function that checks for an 'Invalid parameter' error */
-void _checkInvalidParameterError()
+static void checkInvalidParameterError()
 {
     const char *invalidParameterError = "Parameter";
     char *lastError;
@@ -1062,7 +1062,7 @@ int video_getSetWindowSize(void *arg)
     }
 
     /* Call against new test window */
-    window = _createVideoSuiteTestWindow(title);
+    window = createVideoSuiteTestWindow(title);
     if (window == NULL) {
         return TEST_ABORTED;
     }
@@ -1165,13 +1165,13 @@ int video_getSetWindowSize(void *arg)
             if (desiredW <= 0 || desiredH <= 0) {
                 SDL_SetWindowSize(window, desiredW, desiredH);
                 SDLTest_AssertPass("Call to SDL_SetWindowSize(...,%d,%d)", desiredW, desiredH);
-                _checkInvalidParameterError();
+                checkInvalidParameterError();
             }
         }
     }
 
     /* Clean up */
-    _destroyVideoSuiteTestWindow(window);
+    destroyVideoSuiteTestWindow(window);
 
     /* Set some 'magic' value for later check that nothing was changed */
     referenceW = SDLTest_RandomSint32();
@@ -1191,15 +1191,15 @@ int video_getSetWindowSize(void *arg)
         "Verify that content of W and H pointers has not been modified; expected: %d,%d; got: %d,%d",
         referenceW, referenceH,
         currentW, currentH);
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_GetWindowSize(NULL, NULL, NULL);
     SDLTest_AssertPass("Call to SDL_GetWindowSize(NULL, NULL, NULL)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_SetWindowSize(NULL, desiredW, desiredH);
     SDLTest_AssertPass("Call to SDL_SetWindowSize(window=NULL)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     return TEST_COMPLETED;
 }
@@ -1229,7 +1229,7 @@ int video_getSetWindowMinimumSize(void *arg)
     }
 
     /* Call against new test window */
-    window = _createVideoSuiteTestWindow(title);
+    window = createVideoSuiteTestWindow(title);
     if (window == NULL) {
         return TEST_ABORTED;
     }
@@ -1308,13 +1308,13 @@ int video_getSetWindowMinimumSize(void *arg)
             if (desiredW <= 0 || desiredH <= 0) {
                 SDL_SetWindowMinimumSize(window, desiredW, desiredH);
                 SDLTest_AssertPass("Call to SDL_SetWindowMinimumSize(...,%d,%d)", desiredW, desiredH);
-                _checkInvalidParameterError();
+                checkInvalidParameterError();
             }
         }
     }
 
     /* Clean up */
-    _destroyVideoSuiteTestWindow(window);
+    destroyVideoSuiteTestWindow(window);
 
     /* Set some 'magic' value for later check that nothing was changed */
     referenceW = SDLTest_RandomSint32();
@@ -1334,15 +1334,15 @@ int video_getSetWindowMinimumSize(void *arg)
         "Verify that content of W and H pointers has not been modified; expected: %d,%d; got: %d,%d",
         referenceW, referenceH,
         currentW, currentH);
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_GetWindowMinimumSize(NULL, NULL, NULL);
     SDLTest_AssertPass("Call to SDL_GetWindowMinimumSize(NULL, NULL, NULL)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_SetWindowMinimumSize(NULL, desiredW, desiredH);
     SDLTest_AssertPass("Call to SDL_SetWindowMinimumSize(window=NULL)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     return TEST_COMPLETED;
 }
@@ -1371,7 +1371,7 @@ int video_getSetWindowMaximumSize(void *arg)
     }
 
     /* Call against new test window */
-    window = _createVideoSuiteTestWindow(title);
+    window = createVideoSuiteTestWindow(title);
     if (window == NULL) {
         return TEST_ABORTED;
     }
@@ -1446,13 +1446,13 @@ int video_getSetWindowMaximumSize(void *arg)
             if (desiredW <= 0 || desiredH <= 0) {
                 SDL_SetWindowMaximumSize(window, desiredW, desiredH);
                 SDLTest_AssertPass("Call to SDL_SetWindowMaximumSize(...,%d,%d)", desiredW, desiredH);
-                _checkInvalidParameterError();
+                checkInvalidParameterError();
             }
         }
     }
 
     /* Clean up */
-    _destroyVideoSuiteTestWindow(window);
+    destroyVideoSuiteTestWindow(window);
 
     /* Set some 'magic' value for later check that nothing was changed */
     referenceW = SDLTest_RandomSint32();
@@ -1472,15 +1472,15 @@ int video_getSetWindowMaximumSize(void *arg)
         "Verify that content of W and H pointers has not been modified; expected: %d,%d; got: %d,%d",
         referenceW, referenceH,
         currentW, currentH);
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_GetWindowMaximumSize(NULL, NULL, NULL);
     SDLTest_AssertPass("Call to SDL_GetWindowMaximumSize(NULL, NULL, NULL)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     SDL_SetWindowMaximumSize(NULL, desiredW, desiredH);
     SDLTest_AssertPass("Call to SDL_SetWindowMaximumSize(window=NULL)");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     return TEST_COMPLETED;
 }
@@ -1509,7 +1509,7 @@ int video_getSetWindowData(void *arg)
     int iteration;
 
     /* Call against new test window */
-    window = _createVideoSuiteTestWindow(title);
+    window = createVideoSuiteTestWindow(title);
     if (window == NULL) {
         return TEST_ABORTED;
     }
@@ -1645,52 +1645,52 @@ int video_getSetWindowData(void *arg)
     result = (char *)SDL_SetWindowData(NULL, name, userdata);
     SDLTest_AssertPass("Call to SDL_SetWindowData(window=NULL)");
     SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     /* Set data with NULL name, valid userdata */
     result = (char *)SDL_SetWindowData(window, NULL, userdata);
     SDLTest_AssertPass("Call to SDL_SetWindowData(name=NULL)");
     SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
-    _checkInvalidParameterError();
+    checkInvalidParameterError();
 
     /* Set data with empty name, valid userdata */
     result = (char *)SDL_SetWindowData(window, "", userdata);
     SDLTest_AssertPass("Call to SDL_SetWindowData(name='')");
     SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
-    _checkInvalidParameterError();
+    checkInvalidParameterError();
 
     /* Set data with NULL name, NULL userdata */
     result = (char *)SDL_SetWindowData(window, NULL, NULL);
     SDLTest_AssertPass("Call to SDL_SetWindowData(name=NULL,userdata=NULL)");
     SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
-    _checkInvalidParameterError();
+    checkInvalidParameterError();
 
     /* Set data with empty name, NULL userdata */
     result = (char *)SDL_SetWindowData(window, "", NULL);
     SDLTest_AssertPass("Call to SDL_SetWindowData(name='',userdata=NULL)");
     SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
-    _checkInvalidParameterError();
+    checkInvalidParameterError();
 
     /* Get with invalid window */
     result = (char *)SDL_GetWindowData(NULL, name);
     SDLTest_AssertPass("Call to SDL_GetWindowData(window=NULL)");
     SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
-    _checkInvalidWindowError();
+    checkInvalidWindowError();
 
     /* Get data with NULL name */
     result = (char *)SDL_GetWindowData(window, NULL);
     SDLTest_AssertPass("Call to SDL_GetWindowData(name=NULL)");
     SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
-    _checkInvalidParameterError();
+    checkInvalidParameterError();
 
     /* Get data with empty name */
     result = (char *)SDL_GetWindowData(window, "");
     SDLTest_AssertPass("Call to SDL_GetWindowData(name='')");
     SDLTest_AssertCheck(result == NULL, "Validate that result is NULL");
-    _checkInvalidParameterError();
+    checkInvalidParameterError();
 
     /* Clean up */
-    _destroyVideoSuiteTestWindow(window);
+    destroyVideoSuiteTestWindow(window);
 
 cleanup:
     SDL_free(referenceUserdata);
@@ -1819,7 +1819,7 @@ int video_setWindowCenteredOnDisplay(void *arg)
             SDLTest_AssertCheck(currentY == expectedY, "Validate y (current: %d, expected: %d)", currentY, expectedY);
 
             /* Clean up */
-            _destroyVideoSuiteTestWindow(window);
+            destroyVideoSuiteTestWindow(window);
         }
     }
 

test/testgles2.c

@@ -262,7 +262,7 @@ link_program(struct shader_data *data)
 
 /* 3D data. Vertex range -0.5..0.5 in all axes.
  * Z -0.5 is near, 0.5 is far. */
-const float _vertices[] = {
+const float g_vertices[] = {
     /* Front face. */
     /* Bottom left */
     -0.5,
@@ -391,7 +391,7 @@ const float _vertices[] = {
     0.5,
 };
 
-const float _colors[] = {
+const float g_colors[] = {
     /* Front face */
     /* Bottom left */
     1.0, 0.0, 0.0, /* red */
@@ -448,7 +448,7 @@ const float _colors[] = {
     1.0, 0.0, 1.0, /* magenta */
 };
 
-const char *_shader_vert_src =
+const char *g_shader_vert_src =
     " attribute vec4 av4position; "
     " attribute vec3 av3color; "
     " uniform mat4 mvp; "
@@ -458,7 +458,7 @@ const char *_shader_vert_src =
     "    gl_Position = mvp * av4position; "
     " } ";
 
-const char *_shader_frag_src =
+const char *g_shader_frag_src =
     " precision lowp float; "
     " varying vec3 vv3color; "
     " void main() { "
@@ -801,8 +801,8 @@ int main(int argc, char *argv[])
         data->angle_z = 0;
 
         /* Shader Initialization */
-        process_shader(&data->shader_vert, _shader_vert_src, GL_VERTEX_SHADER);
-        process_shader(&data->shader_frag, _shader_frag_src, GL_FRAGMENT_SHADER);
+        process_shader(&data->shader_vert, g_shader_vert_src, GL_VERTEX_SHADER);
+        process_shader(&data->shader_frag, g_shader_frag_src, GL_FRAGMENT_SHADER);
 
         /* Create shader_program (ready to attach shaders) */
         data->shader_program = GL_CHECK(ctx.glCreateProgram());
@@ -827,13 +827,13 @@ int main(int argc, char *argv[])
 
         GL_CHECK(ctx.glGenBuffers(1, &data->position_buffer));
         GL_CHECK(ctx.glBindBuffer(GL_ARRAY_BUFFER, data->position_buffer));
-        GL_CHECK(ctx.glBufferData(GL_ARRAY_BUFFER, sizeof(_vertices), _vertices, GL_STATIC_DRAW));
+        GL_CHECK(ctx.glBufferData(GL_ARRAY_BUFFER, sizeof(g_vertices), g_vertices, GL_STATIC_DRAW));
         GL_CHECK(ctx.glVertexAttribPointer(data->attr_position, 3, GL_FLOAT, GL_FALSE, 0, 0));
         GL_CHECK(ctx.glBindBuffer(GL_ARRAY_BUFFER, 0));
 
         GL_CHECK(ctx.glGenBuffers(1, &data->color_buffer));
         GL_CHECK(ctx.glBindBuffer(GL_ARRAY_BUFFER, data->color_buffer));
-        GL_CHECK(ctx.glBufferData(GL_ARRAY_BUFFER, sizeof(_colors), _colors, GL_STATIC_DRAW));
+        GL_CHECK(ctx.glBufferData(GL_ARRAY_BUFFER, sizeof(g_colors), g_colors, GL_STATIC_DRAW));
         GL_CHECK(ctx.glVertexAttribPointer(data->attr_color, 3, GL_FLOAT, GL_FALSE, 0, 0));
         GL_CHECK(ctx.glBindBuffer(GL_ARRAY_BUFFER, 0));