Code style: changed "sizeof foo" to "sizeof(foo)" (thanks @sezero!)

(cherry picked from commit c6443d86c9)

test/checkkeys.c

@@ -161,7 +161,7 @@ PrintText(const char *eventtype, const char *text)
     expanded[0] = '\0';
     for (spot = text; *spot; ++spot) {
         size_t length = SDL_strlen(expanded);
-        (void)SDL_snprintf(expanded + length, sizeof expanded - length, "\\x%.2x", (unsigned char)*spot);
+        (void)SDL_snprintf(expanded + length, sizeof(expanded) - length, "\\x%.2x", (unsigned char)*spot);
     }
     SDL_Log("%s Text (%s): \"%s%s\"\n", eventtype, expanded, *text == '"' ? "\\" : "", text);
 }

test/checkkeysthreads.c

@@ -157,7 +157,7 @@ PrintText(const char *eventtype, const char *text)
     expanded[0] = '\0';
     for (spot = text; *spot; ++spot) {
         size_t length = SDL_strlen(expanded);
-        (void)SDL_snprintf(expanded + length, sizeof expanded - length, "\\x%.2x", (unsigned char)*spot);
+        (void)SDL_snprintf(expanded + length, sizeof(expanded) - length, "\\x%.2x", (unsigned char)*spot);
     }
     SDL_Log("%s Text (%s): \"%s%s\"\n", eventtype, expanded, *text == '"' ? "\\" : "", text);
 }

test/controllermap.c

@@ -591,7 +591,7 @@ WatchJoystick(SDL_Joystick *joystick)
             char crc_string[5];
 
             SDL_strlcat(mapping, "crc:", SDL_arraysize(mapping));
-            (void)SDL_snprintf(crc_string, sizeof crc_string, "%.4x", crc);
+            (void)SDL_snprintf(crc_string, sizeof(crc_string), "%.4x", crc);
             SDL_strlcat(mapping, crc_string, SDL_arraysize(mapping));
             SDL_strlcat(mapping, ",", SDL_arraysize(mapping));
         }
@@ -664,17 +664,17 @@ WatchJoystick(SDL_Joystick *joystick)
             pszElement[0] = '\0';
             switch (pBinding->bindType) {
             case SDL_CONTROLLER_BINDTYPE_BUTTON:
-                (void)SDL_snprintf(pszElement, sizeof pszElement, "b%d", pBinding->value.button);
+                (void)SDL_snprintf(pszElement, sizeof(pszElement), "b%d", pBinding->value.button);
                 break;
             case SDL_CONTROLLER_BINDTYPE_AXIS:
                 if (pBinding->value.axis.axis_min == 0 && pBinding->value.axis.axis_max == SDL_JOYSTICK_AXIS_MIN) {
                     /* The negative half axis */
-                    (void)SDL_snprintf(pszElement, sizeof pszElement, "-a%d", pBinding->value.axis.axis);
+                    (void)SDL_snprintf(pszElement, sizeof(pszElement), "-a%d", pBinding->value.axis.axis);
                 } else if (pBinding->value.axis.axis_min == 0 && pBinding->value.axis.axis_max == SDL_JOYSTICK_AXIS_MAX) {
                     /* The positive half axis */
-                    (void)SDL_snprintf(pszElement, sizeof pszElement, "+a%d", pBinding->value.axis.axis);
+                    (void)SDL_snprintf(pszElement, sizeof(pszElement), "+a%d", pBinding->value.axis.axis);
                 } else {
-                    (void)SDL_snprintf(pszElement, sizeof pszElement, "a%d", pBinding->value.axis.axis);
+                    (void)SDL_snprintf(pszElement, sizeof(pszElement), "a%d", pBinding->value.axis.axis);
                     if (pBinding->value.axis.axis_min > pBinding->value.axis.axis_max) {
                         /* Invert the axis */
                         SDL_strlcat(pszElement, "~", SDL_arraysize(pszElement));
@@ -682,7 +682,7 @@ WatchJoystick(SDL_Joystick *joystick)
                 }
                 break;
             case SDL_CONTROLLER_BINDTYPE_HAT:
-                (void)SDL_snprintf(pszElement, sizeof pszElement, "h%d.%d", pBinding->value.hat.hat, pBinding->value.hat.hat_mask);
+                (void)SDL_snprintf(pszElement, sizeof(pszElement), "h%d.%d", pBinding->value.hat.hat, pBinding->value.hat.hat_mask);
                 break;
             default:
                 SDL_assert(!"Unknown bind type");

test/testatomic.c

@@ -617,7 +617,7 @@ static void RunFIFOTest(SDL_bool lock_free)
     SDL_zeroa(readerData);
     for (i = 0; i < NUM_READERS; ++i) {
         char name[64];
-        (void)SDL_snprintf(name, sizeof name, "FIFOReader%d", i);
+        (void)SDL_snprintf(name, sizeof(name), "FIFOReader%d", i);
         readerData[i].queue = &queue;
         readerData[i].lock_free = lock_free;
         readerData[i].thread = SDL_CreateThread(FIFO_Reader, name, &readerData[i]);
@@ -628,7 +628,7 @@ static void RunFIFOTest(SDL_bool lock_free)
     SDL_zeroa(writerData);
     for (i = 0; i < NUM_WRITERS; ++i) {
         char name[64];
-        (void)SDL_snprintf(name, sizeof name, "FIFOWriter%d", i);
+        (void)SDL_snprintf(name, sizeof(name), "FIFOWriter%d", i);
         writerData[i].queue = &queue;
         writerData[i].index = i;
         writerData[i].lock_free = lock_free;
@@ -677,17 +677,17 @@ static void RunFIFOTest(SDL_bool lock_free)
         }
         grand_total += total;
         SDL_Log("Reader %d read %d events, had %d waits\n", i, total, readerData[i].waits);
-        (void)SDL_snprintf(textBuffer, sizeof textBuffer, "  { ");
+        (void)SDL_snprintf(textBuffer, sizeof(textBuffer), "  { ");
         for (j = 0; j < NUM_WRITERS; ++j) {
             if (j > 0) {
                 len = SDL_strlen(textBuffer);
-                (void)SDL_snprintf(textBuffer + len, sizeof textBuffer - len, ", ");
+                (void)SDL_snprintf(textBuffer + len, sizeof(textBuffer) - len, ", ");
             }
             len = SDL_strlen(textBuffer);
-            (void)SDL_snprintf(textBuffer + len, sizeof textBuffer - len, "%d", readerData[i].counters[j]);
+            (void)SDL_snprintf(textBuffer + len, sizeof(textBuffer) - len, "%d", readerData[i].counters[j]);
         }
         len = SDL_strlen(textBuffer);
-        (void)SDL_snprintf(textBuffer + len, sizeof textBuffer - len, " }\n");
+        (void)SDL_snprintf(textBuffer + len, sizeof(textBuffer) - len, " }\n");
         SDL_Log("%s", textBuffer);
     }
     SDL_Log("Readers read %d total events\n", grand_total);

test/testdisplayinfo.c

@@ -80,7 +80,7 @@ int main(int argc, char *argv[])
                 SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "    MODE %d: failed to query (%s)\n", m, SDL_GetError());
             } else {
                 char prefix[64];
-                (void)SDL_snprintf(prefix, sizeof prefix, "    MODE %d", m);
+                (void)SDL_snprintf(prefix, sizeof(prefix), "    MODE %d", m);
                 print_mode(prefix, &mode);
             }
         }

test/testlock.c

@@ -27,7 +27,7 @@ static SDL_atomic_t doterminate;
 
 /*
  * SDL_Quit() shouldn't be used with atexit() directly because
- *  calling conventions may differ...
+ * calling conventions may differ...
  */
 static void
 SDL_Quit_Wrapper(void)
@@ -116,7 +116,7 @@ int main(int argc, char *argv[])
     (void)atexit(printid);
     for (i = 0; i < maxproc; ++i) {
         char name[64];
-        (void)SDL_snprintf(name, sizeof name, "Worker%d", i);
+        (void)SDL_snprintf(name, sizeof(name), "Worker%d", i);
         threads[i] = SDL_CreateThread(Run, name, NULL);
         if (threads[i] == NULL) {
             SDL_LogError(SDL_LOG_CATEGORY_APPLICATION, "Couldn't create thread!\n");

test/testoffscreen.c

@@ -116,8 +116,7 @@ int main(int argc, char *argv[])
                               width, height, 0);
 
     if (window == NULL) {
-        SDL_Log("Couldn't create window: %s\n",
-                SDL_GetError());
+        SDL_Log("Couldn't create window: %s\n", SDL_GetError());
         return SDL_FALSE;
     }
 

test/testsem.c

@@ -76,7 +76,7 @@ TestRealWorld(int init_sem)
     /* Create all the threads */
     for (i = 0; i < NUM_THREADS; ++i) {
         char name[64];
-        (void)SDL_snprintf(name, sizeof name, "Thread%u", (unsigned int)i);
+        (void)SDL_snprintf(name, sizeof(name), "Thread%u", (unsigned int)i);
         thread_states[i].number = i;
         thread_states[i].thread = SDL_CreateThread(ThreadFuncRealWorld, name, (void *)&thread_states[i]);
     }
@@ -198,7 +198,7 @@ TestOverheadContended(SDL_bool try_wait)
     /* Create multiple threads to starve the semaphore and cause contention */
     for (i = 0; i < NUM_THREADS; ++i) {
         char name[64];
-        (void)SDL_snprintf(name, sizeof name, "Thread%u", (unsigned int)i);
+        (void)SDL_snprintf(name, sizeof(name), "Thread%u", (unsigned int)i);
         thread_states[i].flag = try_wait;
         thread_states[i].thread = SDL_CreateThread(ThreadFuncOverheadContended, name, (void *)&thread_states[i]);
     }
@@ -231,17 +231,17 @@ TestOverheadContended(SDL_bool try_wait)
             duration, try_wait ? "where contended" : "timed out", content_count,
             loop_count, ((float)content_count * 100) / loop_count);
     /* Print how many semaphores where consumed per thread */
-    (void)SDL_snprintf(textBuffer, sizeof textBuffer, "{ ");
+    (void)SDL_snprintf(textBuffer, sizeof(textBuffer), "{ ");
     for (i = 0; i < NUM_THREADS; ++i) {
         if (i > 0) {
             len = SDL_strlen(textBuffer);
-            (void)SDL_snprintf(textBuffer + len, sizeof textBuffer - len, ", ");
+            (void)SDL_snprintf(textBuffer + len, sizeof(textBuffer) - len, ", ");
         }
         len = SDL_strlen(textBuffer);
-        (void)SDL_snprintf(textBuffer + len, sizeof textBuffer - len, "%d", thread_states[i].loop_count - thread_states[i].content_count);
+        (void)SDL_snprintf(textBuffer + len, sizeof(textBuffer) - len, "%d", thread_states[i].loop_count - thread_states[i].content_count);
     }
     len = SDL_strlen(textBuffer);
-    (void)SDL_snprintf(textBuffer + len, sizeof textBuffer - len, " }\n");
+    (void)SDL_snprintf(textBuffer + len, sizeof(textBuffer) - len, " }\n");
     SDL_Log("%s\n", textBuffer);
 
     SDL_DestroySemaphore(sem);

test/testsensor.c

@@ -28,7 +28,7 @@ static const char *GetSensorTypeString(SDL_SensorType type)
     case SDL_SENSOR_GYRO:
         return "SDL_SENSOR_GYRO";
     default:
-        (void)SDL_snprintf(unknown_type, sizeof unknown_type, "UNKNOWN (%d)", type);
+        (void)SDL_snprintf(unknown_type, sizeof(unknown_type), "UNKNOWN (%d)", type);
         return unknown_type;
     }
 }

test/testwm.c

@@ -0,0 +1,301 @@
+/*
+  Copyright (C) 1997-2023 Sam Lantinga <slouken@libsdl.org>
+
+  This software is provided 'as-is', without any express or implied
+  warranty.  In no event will the authors be held liable for any damages
+  arising from the use of this software.
+
+  Permission is granted to anyone to use this software for any purpose,
+  including commercial applications, and to alter it and redistribute it
+  freely.
+*/
+
+#include <stdlib.h>
+
+#ifdef __EMSCRIPTEN__
+#include <emscripten/emscripten.h>
+#endif
+
+#include <SDL3/SDL_test_common.h>
+#include <SDL3/SDL_test_font.h>
+#include <SDL3/SDL_main.h>
+
+static SDLTest_CommonState *state;
+static int done;
+
+static const char *cursorNames[] = {
+    "arrow",
+    "ibeam",
+    "wait",
+    "crosshair",
+    "waitarrow",
+    "sizeNWSE",
+    "sizeNESW",
+    "sizeWE",
+    "sizeNS",
+    "sizeALL",
+    "NO",
+    "hand",
+};
+static int system_cursor = -1;
+static SDL_Cursor *cursor = NULL;
+static SDL_bool relative_mode = SDL_FALSE;
+static const SDL_DisplayMode *highlighted_mode = NULL;
+
+/* Call this instead of exit(), so we can clean up SDL: atexit() is evil. */
+static void
+quit(int rc)
+{
+    SDLTest_CommonQuit(state);
+    exit(rc);
+}
+
+/* Draws the modes menu, and stores the mode index under the mouse in highlighted_mode */
+static void
+draw_modes_menu(SDL_Window *window, SDL_Renderer *renderer, SDL_FRect viewport)
+{
+    const SDL_DisplayMode **modes;
+    char text[1024];
+    const int lineHeight = 10;
+    int i, j;
+    int column_chars = 0;
+    int text_length;
+    float x, y;
+    float table_top;
+    SDL_FPoint mouse_pos = { -1.0f, -1.0f };
+    SDL_DisplayID *display_ids;
+
+    /* Get mouse position */
+    if (SDL_GetMouseFocus() == window) {
+        float window_x, window_y;
+        float logical_x, logical_y;
+
+        SDL_GetMouseState(&window_x, &window_y);
+        SDL_RenderCoordinatesFromWindow(renderer, window_x, window_y, &logical_x, &logical_y);
+
+        mouse_pos.x = logical_x;
+        mouse_pos.y = logical_y;
+    }
+
+    x = 0.0f;
+    y = viewport.y;
+
+    y += lineHeight;
+
+    SDL_strlcpy(text, "Click on a mode to set it with SDL_SetWindowFullscreenMode", sizeof(text));
+    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+    SDLTest_DrawString(renderer, x, y, text);
+    y += lineHeight;
+
+    SDL_strlcpy(text, "Press Ctrl+Enter to toggle SDL_WINDOW_FULLSCREEN", sizeof(text));
+    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+    SDLTest_DrawString(renderer, x, y, text);
+    y += lineHeight;
+
+    table_top = y;
+
+    /* Clear the cached mode under the mouse */
+    if (window == SDL_GetMouseFocus()) {
+        highlighted_mode = NULL;
+    }
+
+    display_ids = SDL_GetDisplays(NULL);
+
+    if (display_ids) {
+        for (i = 0; display_ids[i]; ++i) {
+            const SDL_DisplayID display_id = display_ids[i];
+            modes = SDL_GetFullscreenDisplayModes(display_id, NULL);
+            for (j = 0; modes[j]; ++j) {
+                SDL_FRect cell_rect;
+                const SDL_DisplayMode *mode = modes[j];
+
+                (void)SDL_snprintf(text, sizeof(text), "%s mode %d: %dx%d@%gHz",
+                                   SDL_GetDisplayName(display_id),
+                                   j, mode->pixel_w, mode->pixel_h, mode->refresh_rate);
+
+                /* Update column width */
+                text_length = (int)SDL_strlen(text);
+                column_chars = SDL_max(column_chars, text_length);
+
+                /* Check if under mouse */
+                cell_rect.x = x;
+                cell_rect.y = y;
+                cell_rect.w = (float)(text_length * FONT_CHARACTER_SIZE);
+                cell_rect.h = (float)lineHeight;
+
+                if (SDL_PointInRectFloat(&mouse_pos, &cell_rect)) {
+                    SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+
+                    /* Update cached mode under the mouse */
+                    if (window == SDL_GetMouseFocus()) {
+                        highlighted_mode = mode;
+                    }
+                } else {
+                    SDL_SetRenderDrawColor(renderer, 170, 170, 170, 255);
+                }
+
+                SDLTest_DrawString(renderer, x, y, text);
+                y += lineHeight;
+
+                if ((y + lineHeight) > (viewport.y + viewport.h)) {
+                    /* Advance to next column */
+                    x += (column_chars + 1) * FONT_CHARACTER_SIZE;
+                    y = table_top;
+                    column_chars = 0;
+                }
+            }
+            SDL_free((void *)modes);
+        }
+        SDL_free(display_ids);
+    }
+}
+
+static void loop(void)
+{
+    int i;
+    SDL_Event event;
+    /* Check for events */
+    while (SDL_PollEvent(&event)) {
+        SDLTest_CommonEvent(state, &event, &done);
+
+        if (event.type == SDL_EVENT_WINDOW_RESIZED) {
+            SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
+            if (window) {
+                SDL_Log("Window %" SDL_PRIu32 " resized to %" SDL_PRIs32 "x%" SDL_PRIs32 "\n",
+                        event.window.windowID,
+                        event.window.data1,
+                        event.window.data2);
+            }
+        }
+        if (event.type == SDL_EVENT_WINDOW_MOVED) {
+            SDL_Window *window = SDL_GetWindowFromID(event.window.windowID);
+            if (window) {
+                SDL_Log("Window %" SDL_PRIu32 " moved to %" SDL_PRIs32 ",%" SDL_PRIs32 " (display %s)\n",
+                        event.window.windowID,
+                        event.window.data1,
+                        event.window.data2,
+                        SDL_GetDisplayName(SDL_GetDisplayForWindow(window)));
+            }
+        }
+        if (event.type == SDL_EVENT_WINDOW_FOCUS_LOST) {
+            relative_mode = SDL_GetRelativeMouseMode();
+            if (relative_mode) {
+                SDL_SetRelativeMouseMode(SDL_FALSE);
+            }
+        }
+        if (event.type == SDL_EVENT_WINDOW_FOCUS_GAINED) {
+            if (relative_mode) {
+                SDL_SetRelativeMouseMode(SDL_TRUE);
+            }
+        }
+        if (event.type == SDL_EVENT_KEY_UP) {
+            SDL_bool updateCursor = SDL_FALSE;
+
+            if (event.key.keysym.sym == SDLK_a) {
+                SDL_assert(!"Keyboard generated assert");
+            } else if (event.key.keysym.sym == SDLK_LEFT) {
+                --system_cursor;
+                if (system_cursor < 0) {
+                    system_cursor = SDL_NUM_SYSTEM_CURSORS - 1;
+                }
+                updateCursor = SDL_TRUE;
+            } else if (event.key.keysym.sym == SDLK_RIGHT) {
+                ++system_cursor;
+                if (system_cursor >= SDL_NUM_SYSTEM_CURSORS) {
+                    system_cursor = 0;
+                }
+                updateCursor = SDL_TRUE;
+            }
+            if (updateCursor) {
+                SDL_Log("Changing cursor to \"%s\"", cursorNames[system_cursor]);
+                SDL_DestroyCursor(cursor);
+                cursor = SDL_CreateSystemCursor((SDL_SystemCursor)system_cursor);
+                SDL_SetCursor(cursor);
+            }
+        }
+        if (event.type == SDL_EVENT_MOUSE_BUTTON_UP) {
+            SDL_Window *window = SDL_GetMouseFocus();
+            if (highlighted_mode != NULL && window != NULL) {
+                SDL_memcpy(&state->fullscreen_mode, highlighted_mode, sizeof(state->fullscreen_mode));
+                SDL_SetWindowFullscreenMode(window, highlighted_mode);
+            }
+        }
+    }
+
+    for (i = 0; i < state->num_windows; ++i) {
+        SDL_Window *window = state->windows[i];
+        SDL_Renderer *renderer = state->renderers[i];
+        if (window != NULL && renderer != NULL) {
+            float y = 0.0f;
+            SDL_Rect viewport;
+            SDL_FRect menurect;
+
+            SDL_GetRenderViewport(renderer, &viewport);
+
+            SDL_SetRenderDrawColor(renderer, 0, 0, 0, 255);
+            SDL_RenderClear(renderer);
+
+            SDL_SetRenderDrawColor(renderer, 255, 255, 255, 255);
+            SDLTest_CommonDrawWindowInfo(renderer, state->windows[i], &y);
+
+            menurect.x = 0.0f;
+            menurect.y = y;
+            menurect.w = (float)viewport.w;
+            menurect.h = (float)viewport.h - y;
+            draw_modes_menu(window, renderer, menurect);
+
+            SDL_Delay(16);
+            SDL_RenderPresent(renderer);
+        }
+    }
+#ifdef __EMSCRIPTEN__
+    if (done) {
+        emscripten_cancel_main_loop();
+    }
+#endif
+}
+
+int main(int argc, char *argv[])
+{
+    int i;
+
+    /* Enable standard application logging */
+    SDL_LogSetPriority(SDL_LOG_CATEGORY_APPLICATION, SDL_LOG_PRIORITY_INFO);
+
+    SDL_assert(SDL_arraysize(cursorNames) == SDL_NUM_SYSTEM_CURSORS);
+
+    /* Initialize test framework */
+    state = SDLTest_CommonCreateState(argv, SDL_INIT_VIDEO);
+    if (state == NULL) {
+        return 1;
+    }
+
+    if (!SDLTest_CommonDefaultArgs(state, argc, argv) || !SDLTest_CommonInit(state)) {
+        SDLTest_CommonQuit(state);
+        return 1;
+    }
+
+    SDL_SetEventEnabled(SDL_EVENT_DROP_FILE, SDL_TRUE);
+    SDL_SetEventEnabled(SDL_EVENT_DROP_TEXT, SDL_TRUE);
+
+    for (i = 0; i < state->num_windows; ++i) {
+        SDL_Renderer *renderer = state->renderers[i];
+        SDL_SetRenderDrawColor(renderer, 0xA0, 0xA0, 0xA0, 0xFF);
+        SDL_RenderClear(renderer);
+    }
+
+    /* Main render loop */
+    done = 0;
+#ifdef __EMSCRIPTEN__
+    emscripten_set_main_loop(loop, 0, 1);
+#else
+    while (!done) {
+        loop();
+    }
+#endif
+    SDL_DestroyCursor(cursor);
+
+    quit(0);
+    /* keep the compiler happy ... */
+    return 0;
+}

test/testyuv.c

@@ -436,7 +436,7 @@ int main(int argc, char **argv)
             if (current == 0) {
                 SDLTest_DrawString(renderer, 4, 4, titles[current]);
             } else {
-                (void)SDL_snprintf(title, sizeof title, "%s %s %s", titles[current], yuv_name, yuv_mode);
+                (void)SDL_snprintf(title, sizeof(title), "%s %s %s", titles[current], yuv_name, yuv_mode);
                 SDLTest_DrawString(renderer, 4, 4, title);
             }
             SDL_RenderPresent(renderer);

test/torturethread.c

@@ -52,7 +52,7 @@ ThreadFunc(void *data)
 
     for (i = 0; i < NUMTHREADS; i++) {
         char name[64];
-        (void)SDL_snprintf(name, sizeof name, "Child%d_%d", tid, i);
+        (void)SDL_snprintf(name, sizeof(name), "Child%d_%d", tid, i);
         flags[i] = 0;
         sub_threads[i] = SDL_CreateThread(SubThreadFunc, name, &flags[i]);
     }
@@ -90,7 +90,7 @@ int main(int argc, char *argv[])
     (void)signal(SIGSEGV, SIG_DFL);
     for (i = 0; i < NUMTHREADS; i++) {
         char name[64];
-        (void)SDL_snprintf(name, sizeof name, "Parent%d", i);
+        (void)SDL_snprintf(name, sizeof(name), "Parent%d", i);
         SDL_AtomicSet(&time_for_threads_to_die[i], 0);
         threads[i] = SDL_CreateThread(ThreadFunc, name, (void *)(uintptr_t)i);