From 5a079a2d114f96d4847d1ee305d5b7c16eeec50e Mon Sep 17 00:00:00 2001 From: 3gg <3gg@shellblade.net> Date: Sat, 27 Dec 2025 12:03:39 -0800 Subject: Initial commit --- contrib/SDL-3.2.8/src/test/SDL_test_compare.c | 218 ++++++++++++++++++++++++++ 1 file changed, 218 insertions(+) create mode 100644 contrib/SDL-3.2.8/src/test/SDL_test_compare.c (limited to 'contrib/SDL-3.2.8/src/test/SDL_test_compare.c') diff --git a/contrib/SDL-3.2.8/src/test/SDL_test_compare.c b/contrib/SDL-3.2.8/src/test/SDL_test_compare.c new file mode 100644 index 0000000..c3ee039 --- /dev/null +++ b/contrib/SDL-3.2.8/src/test/SDL_test_compare.c @@ -0,0 +1,218 @@ +/* + Simple DirectMedia Layer + Copyright (C) 1997-2025 Sam Lantinga + + This software is provided 'as-is', without any express or implied + warranty. In no event will the authors be held liable for any damages + arising from the use of this software. + + Permission is granted to anyone to use this software for any purpose, + including commercial applications, and to alter it and redistribute it + freely, subject to the following restrictions: + + 1. The origin of this software must not be misrepresented; you must not + claim that you wrote the original software. If you use this software + in a product, an acknowledgment in the product documentation would be + appreciated but is not required. + 2. Altered source versions must be plainly marked as such, and must not be + misrepresented as being the original software. + 3. This notice may not be removed or altered from any source distribution. +*/ + +/* + + Based on automated SDL_Surface tests originally written by Edgar Simo 'bobbens'. + + Rewritten for test lib by Andreas Schiffler. + +*/ +#include + +#define FILENAME_SIZE 128 + +/* Counter for _CompareSurface calls; used for filename creation when comparisons fail */ +static int _CompareSurfaceCount = 0; + +/* Compare surfaces */ +int SDLTest_CompareSurfaces(SDL_Surface *surface, SDL_Surface *referenceSurface, int allowable_error) +{ + int ret; + int i, j; + int dist; + int sampleErrorX = 0, sampleErrorY = 0, sampleDist = 0; + SDL_Color sampleReference = { 0, 0, 0, 0 }; + SDL_Color sampleActual = { 0, 0, 0, 0 }; + Uint8 R, G, B, A; + Uint8 Rd, Gd, Bd, Ad; + char imageFilename[FILENAME_SIZE]; + char referenceFilename[FILENAME_SIZE]; + + /* Validate input surfaces */ + if (!surface) { + SDLTest_LogError("Cannot compare NULL surface"); + return -1; + } + + if (!referenceSurface) { + SDLTest_LogError("Cannot compare NULL reference surface"); + return -1; + } + + /* Make sure surface size is the same. */ + if ((surface->w != referenceSurface->w) || (surface->h != referenceSurface->h)) { + SDLTest_LogError("Expected %dx%d surface, got %dx%d", referenceSurface->w, referenceSurface->h, surface->w, surface->h); + return -2; + } + + /* Sanitize input value */ + if (allowable_error < 0) { + allowable_error = 0; + } + + SDL_LockSurface(surface); + SDL_LockSurface(referenceSurface); + + ret = 0; + /* Compare image - should be same format. */ + for (j = 0; j < surface->h; j++) { + for (i = 0; i < surface->w; i++) { + int temp; + + temp = SDL_ReadSurfacePixel(surface, i, j, &R, &G, &B, &A); + if (!temp) { + SDLTest_LogError("Failed to retrieve pixel (%d,%d): %s", i, j, SDL_GetError()); + ret++; + continue; + } + + temp = SDL_ReadSurfacePixel(referenceSurface, i, j, &Rd, &Gd, &Bd, &Ad); + if (!temp) { + SDLTest_LogError("Failed to retrieve reference pixel (%d,%d): %s", i, j, SDL_GetError()); + ret++; + continue; + } + + dist = 0; + dist += (R - Rd) * (R - Rd); + dist += (G - Gd) * (G - Gd); + dist += (B - Bd) * (B - Bd); + + /* Allow some difference in blending accuracy */ + if (dist > allowable_error) { + ret++; + if (ret == 1) { + sampleErrorX = i; + sampleErrorY = j; + sampleDist = dist; + sampleReference.r = Rd; + sampleReference.g = Gd; + sampleReference.b = Bd; + sampleReference.a = Ad; + sampleActual.r = R; + sampleActual.g = G; + sampleActual.b = B; + sampleActual.a = A; + } + } + } + } + + SDL_UnlockSurface(surface); + SDL_UnlockSurface(referenceSurface); + + /* Save test image and reference for analysis on failures */ + _CompareSurfaceCount++; + if (ret != 0) { + SDLTest_LogError("Comparison of pixels with allowable error of %i failed %i times.", allowable_error, ret); + SDLTest_LogError("Reference surface format: %s", SDL_GetPixelFormatName(referenceSurface->format)); + SDLTest_LogError("Actual surface format: %s", SDL_GetPixelFormatName(surface->format)); + SDLTest_LogError("First detected occurrence at position %i,%i with a squared RGB-difference of %i.", sampleErrorX, sampleErrorY, sampleDist); + SDLTest_LogError("Reference pixel: R=%u G=%u B=%u A=%u", sampleReference.r, sampleReference.g, sampleReference.b, sampleReference.a); + SDLTest_LogError("Actual pixel : R=%u G=%u B=%u A=%u", sampleActual.r, sampleActual.g, sampleActual.b, sampleActual.a); + (void)SDL_snprintf(imageFilename, FILENAME_SIZE - 1, "CompareSurfaces%04d_TestOutput.bmp", _CompareSurfaceCount); + SDL_SaveBMP(surface, imageFilename); + (void)SDL_snprintf(referenceFilename, FILENAME_SIZE - 1, "CompareSurfaces%04d_Reference.bmp", _CompareSurfaceCount); + SDL_SaveBMP(referenceSurface, referenceFilename); + SDLTest_LogError("Surfaces from failed comparison saved as '%s' and '%s'", imageFilename, referenceFilename); + } + + return ret; +} + +int SDLTest_CompareMemory(const void *actual, size_t size_actual, const void *reference, size_t size_reference) { +#define WIDTH 16 + + const size_t size_max = SDL_max(size_actual, size_reference); + size_t i; + struct { + const char *header; + const Uint8 *data; + size_t size; + } columns[] = { + { + "actual", + actual, + size_actual, + }, + { + "reference", + reference, + size_reference, + }, + }; + char line_buffer[16 + SDL_arraysize(columns) * (4 * WIDTH + 1) + (SDL_arraysize(columns) - 1) * 2 + 1]; + + SDLTest_AssertCheck(size_actual == size_reference, "Sizes of memory blocks must be equal (actual=%" SDL_PRIu64 " expected=%" SDL_PRIu64 ")", (Uint64)size_actual, (Uint64)size_reference); + if (size_actual == size_reference) { + int equals; + equals = SDL_memcmp(actual, reference, size_max) == 0; + SDLTest_AssertCheck(equals, "Memory blocks contain the same data"); + if (equals) { + return 0; + } + } + + SDL_memset(line_buffer, ' ', sizeof(line_buffer)); + line_buffer[sizeof(line_buffer) - 1] = '\0'; + for (i = 0; i < SDL_arraysize(columns); i++) { + SDL_memcpy(line_buffer + 16 + 1 + i * (4 * WIDTH + 3), columns[i].header, SDL_strlen(columns[i].header)); + } + SDLTest_LogError("%s", line_buffer); + + for (i = 0; i < size_max; i += WIDTH) { + size_t pos = 0; + size_t col; + + pos += SDL_snprintf(line_buffer + pos, SDL_arraysize(line_buffer) - pos, "%016" SDL_PRIx64 , (Uint64)i); + + for (col = 0; col < SDL_arraysize(columns); col++) { + size_t j; + + for (j = 0; j < WIDTH; j++) { + if (i + j < columns[col].size) { + pos += SDL_snprintf(line_buffer + pos, SDL_arraysize(line_buffer) - pos, " %02x", columns[col].data[i + j]); + } else { + pos += SDL_snprintf(line_buffer + pos, SDL_arraysize(line_buffer) - pos, " "); + } + } + pos += SDL_snprintf(line_buffer + pos, SDL_arraysize(line_buffer) - pos, " "); + for (j = 0; j < WIDTH; j++) { + char c = ' '; + if (i + j < columns[col].size) { + c = columns[col].data[i + j]; + if (!SDL_isprint(c)) { + c = '.'; + } + } + pos += SDL_snprintf(line_buffer + pos, SDL_arraysize(line_buffer) - pos, "%c", c); + } + if (col < SDL_arraysize(columns) - 1) { + pos += SDL_snprintf(line_buffer + pos, SDL_arraysize(line_buffer), " |"); + } + } + SDLTest_LogError("%s", line_buffer); + SDL_assert(pos == SDL_arraysize(line_buffer) - 1); + } +#undef WIDTH + return 1; +} -- cgit v1.2.3