Merge commit '3a7f96fd99528968c39b5be81db067ca018d432b' into dev
This commit is contained in:
SimoneN64
417
external/SDL/test/testautomation_stdlib.c
vendored
417
external/SDL/test/testautomation_stdlib.c
vendored
@@ -10,8 +10,7 @@
|
||||
/**
|
||||
* Call to SDL_strnlen
|
||||
*/
|
||||
#undef SDL_strnlen
|
||||
static int stdlib_strnlen(void *arg)
|
||||
static int SDLCALL stdlib_strnlen(void *arg)
|
||||
{
|
||||
size_t result;
|
||||
char *text_result;
|
||||
@@ -38,8 +37,7 @@ static int stdlib_strnlen(void *arg)
|
||||
/**
|
||||
* Call to SDL_strlcpy
|
||||
*/
|
||||
#undef SDL_strlcpy
|
||||
static int stdlib_strlcpy(void *arg)
|
||||
static int SDLCALL stdlib_strlcpy(void *arg)
|
||||
{
|
||||
size_t result;
|
||||
char text[1024];
|
||||
@@ -63,7 +61,7 @@ static int stdlib_strlcpy(void *arg)
|
||||
/**
|
||||
* Call to SDL_strstr
|
||||
*/
|
||||
static int stdlib_strstr(void *arg)
|
||||
static int SDLCALL stdlib_strstr(void *arg)
|
||||
{
|
||||
char *result;
|
||||
const char *text = "abcdef";
|
||||
@@ -135,8 +133,7 @@ static int stdlib_strstr(void *arg)
|
||||
/**
|
||||
* Call to SDL_snprintf
|
||||
*/
|
||||
#undef SDL_snprintf
|
||||
static int stdlib_snprintf(void *arg)
|
||||
static int SDLCALL stdlib_snprintf(void *arg)
|
||||
{
|
||||
int result;
|
||||
int predicted;
|
||||
@@ -381,8 +378,7 @@ static int stdlib_snprintf(void *arg)
|
||||
/**
|
||||
* Call to SDL_swprintf
|
||||
*/
|
||||
#undef SDL_swprintf
|
||||
static int stdlib_swprintf(void *arg)
|
||||
static int SDLCALL stdlib_swprintf(void *arg)
|
||||
{
|
||||
int result;
|
||||
int predicted;
|
||||
@@ -546,10 +542,11 @@ static int stdlib_swprintf(void *arg)
|
||||
#endif
|
||||
|
||||
/**
|
||||
* Call to SDL_getenv and SDL_setenv
|
||||
* Call to SDL_GetEnvironmentVariable() and SDL_SetEnvironmentVariable()
|
||||
*/
|
||||
static int stdlib_getsetenv(void *arg)
|
||||
static int SDLCALL stdlib_getsetenv(void *arg)
|
||||
{
|
||||
SDL_Environment *env = SDL_GetEnvironment();
|
||||
const int nameLen = 16;
|
||||
char name[17];
|
||||
int counter;
|
||||
@@ -560,7 +557,7 @@ static int stdlib_getsetenv(void *arg)
|
||||
int overwrite;
|
||||
const char *text;
|
||||
|
||||
/* Create a random name. This tests SDL_getenv, since we need to */
|
||||
/* Create a random name. This tests SDL_GetEnvironmentVariable, since we need to */
|
||||
/* make sure the variable is not set yet (it shouldn't). */
|
||||
do {
|
||||
for (counter = 0; counter < nameLen; counter++) {
|
||||
@@ -568,8 +565,8 @@ static int stdlib_getsetenv(void *arg)
|
||||
}
|
||||
name[nameLen] = '\0';
|
||||
|
||||
text = SDL_getenv(name);
|
||||
SDLTest_AssertPass("Call to SDL_getenv('%s')", name);
|
||||
text = SDL_GetEnvironmentVariable(env, name);
|
||||
SDLTest_AssertPass("Call to SDL_GetEnvironmentVariable(env, '%s')", name);
|
||||
if (text) {
|
||||
SDLTest_Log("Expected: NULL, Got: '%s' (%i)", text, (int)SDL_strlen(text));
|
||||
}
|
||||
@@ -582,13 +579,13 @@ static int stdlib_getsetenv(void *arg)
|
||||
/* Set value 1 without overwrite */
|
||||
overwrite = 0;
|
||||
expected = value1;
|
||||
result = SDL_setenv(name, value1, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_setenv('%s','%s', %i)", name, value1, overwrite);
|
||||
SDLTest_AssertCheck(result == 0, "Check result, expected: 0, got: %i", result);
|
||||
result = SDL_SetEnvironmentVariable(env, name, value1, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_SetEnvironmentVariable(env, '%s','%s', %i)", name, value1, overwrite);
|
||||
SDLTest_AssertCheck(result == true, "Check result, expected: 1, got: %i", result);
|
||||
|
||||
/* Check value */
|
||||
text = SDL_getenv(name);
|
||||
SDLTest_AssertPass("Call to SDL_getenv('%s')", name);
|
||||
text = SDL_GetEnvironmentVariable(env, name);
|
||||
SDLTest_AssertPass("Call to SDL_GetEnvironmentVariable(env, '%s')", name);
|
||||
SDLTest_AssertCheck(text != NULL, "Verify returned text is not NULL");
|
||||
if (text != NULL) {
|
||||
SDLTest_AssertCheck(
|
||||
@@ -601,13 +598,13 @@ static int stdlib_getsetenv(void *arg)
|
||||
/* Set value 2 with overwrite */
|
||||
overwrite = 1;
|
||||
expected = value2;
|
||||
result = SDL_setenv(name, value2, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_setenv('%s','%s', %i)", name, value2, overwrite);
|
||||
SDLTest_AssertCheck(result == 0, "Check result, expected: 0, got: %i", result);
|
||||
result = SDL_SetEnvironmentVariable(env, name, value2, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_SetEnvironmentVariable(env, '%s','%s', %i)", name, value2, overwrite);
|
||||
SDLTest_AssertCheck(result == true, "Check result, expected: 1, got: %i", result);
|
||||
|
||||
/* Check value */
|
||||
text = SDL_getenv(name);
|
||||
SDLTest_AssertPass("Call to SDL_getenv('%s')", name);
|
||||
text = SDL_GetEnvironmentVariable(env, name);
|
||||
SDLTest_AssertPass("Call to SDL_GetEnvironmentVariable(env, '%s')", name);
|
||||
SDLTest_AssertCheck(text != NULL, "Verify returned text is not NULL");
|
||||
if (text != NULL) {
|
||||
SDLTest_AssertCheck(
|
||||
@@ -620,13 +617,13 @@ static int stdlib_getsetenv(void *arg)
|
||||
/* Set value 1 without overwrite */
|
||||
overwrite = 0;
|
||||
expected = value2;
|
||||
result = SDL_setenv(name, value1, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_setenv('%s','%s', %i)", name, value1, overwrite);
|
||||
SDLTest_AssertCheck(result == 0, "Check result, expected: 0, got: %i", result);
|
||||
result = SDL_SetEnvironmentVariable(env, name, value1, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_SetEnvironmentVariable(env, '%s','%s', %i)", name, value1, overwrite);
|
||||
SDLTest_AssertCheck(result == true, "Check result, expected: 1, got: %i", result);
|
||||
|
||||
/* Check value */
|
||||
text = SDL_getenv(name);
|
||||
SDLTest_AssertPass("Call to SDL_getenv('%s')", name);
|
||||
text = SDL_GetEnvironmentVariable(env, name);
|
||||
SDLTest_AssertPass("Call to SDL_GetEnvironmentVariable(env, '%s')", name);
|
||||
SDLTest_AssertCheck(text != NULL, "Verify returned text is not NULL");
|
||||
if (text != NULL) {
|
||||
SDLTest_AssertCheck(
|
||||
@@ -639,13 +636,13 @@ static int stdlib_getsetenv(void *arg)
|
||||
/* Set value 1 with overwrite */
|
||||
overwrite = 1;
|
||||
expected = value1;
|
||||
result = SDL_setenv(name, value1, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_setenv('%s','%s', %i)", name, value1, overwrite);
|
||||
SDLTest_AssertCheck(result == 0, "Check result, expected: 0, got: %i", result);
|
||||
result = SDL_SetEnvironmentVariable(env, name, value1, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_SetEnvironmentVariable(env, '%s','%s', %i)", name, value1, overwrite);
|
||||
SDLTest_AssertCheck(result == true, "Check result, expected: 1, got: %i", result);
|
||||
|
||||
/* Check value */
|
||||
text = SDL_getenv(name);
|
||||
SDLTest_AssertPass("Call to SDL_getenv('%s')", name);
|
||||
text = SDL_GetEnvironmentVariable(env, name);
|
||||
SDLTest_AssertPass("Call to SDL_GetEnvironmentVariable(env, '%s')", name);
|
||||
SDLTest_AssertCheck(text != NULL, "Verify returned text is not NULL");
|
||||
if (text != NULL) {
|
||||
SDLTest_AssertCheck(
|
||||
@@ -656,48 +653,48 @@ static int stdlib_getsetenv(void *arg)
|
||||
}
|
||||
|
||||
/* Verify setenv() with empty string vs unsetenv() */
|
||||
result = SDL_setenv("FOO", "1", 1);
|
||||
SDLTest_AssertPass("Call to SDL_setenv('FOO','1', 1)");
|
||||
SDLTest_AssertCheck(result == 0, "Check result, expected: 0, got: %i", result);
|
||||
result = SDL_SetEnvironmentVariable(env, "FOO", "1", 1);
|
||||
SDLTest_AssertPass("Call to SDL_SetEnvironmentVariable(env, 'FOO','1', 1)");
|
||||
SDLTest_AssertCheck(result == true, "Check result, expected: 1, got: %i", result);
|
||||
expected = "1";
|
||||
text = SDL_getenv("FOO");
|
||||
SDLTest_AssertPass("Call to SDL_getenv('FOO')");
|
||||
text = SDL_GetEnvironmentVariable(env, "FOO");
|
||||
SDLTest_AssertPass("Call to SDL_GetEnvironmentVariable(env, 'FOO')");
|
||||
SDLTest_AssertCheck(text && SDL_strcmp(text, expected) == 0, "Verify returned text, expected: %s, got: %s", expected, text);
|
||||
result = SDL_setenv("FOO", "", 1);
|
||||
SDLTest_AssertPass("Call to SDL_setenv('FOO','', 1)");
|
||||
SDLTest_AssertCheck(result == 0, "Check result, expected: 0, got: %i", result);
|
||||
result = SDL_SetEnvironmentVariable(env, "FOO", "", 1);
|
||||
SDLTest_AssertPass("Call to SDL_SetEnvironmentVariable(env, 'FOO','', 1)");
|
||||
SDLTest_AssertCheck(result == true, "Check result, expected: 1, got: %i", result);
|
||||
expected = "";
|
||||
text = SDL_getenv("FOO");
|
||||
SDLTest_AssertPass("Call to SDL_getenv('FOO')");
|
||||
text = SDL_GetEnvironmentVariable(env, "FOO");
|
||||
SDLTest_AssertPass("Call to SDL_GetEnvironmentVariable(env, 'FOO')");
|
||||
SDLTest_AssertCheck(text && SDL_strcmp(text, expected) == 0, "Verify returned text, expected: '%s', got: '%s'", expected, text);
|
||||
result = SDL_unsetenv("FOO");
|
||||
SDLTest_AssertPass("Call to SDL_unsetenv('FOO')");
|
||||
SDLTest_AssertCheck(result == 0, "Check result, expected: 0, got: %i", result);
|
||||
text = SDL_getenv("FOO");
|
||||
SDLTest_AssertPass("Call to SDL_getenv('FOO')");
|
||||
result = SDL_UnsetEnvironmentVariable(env, "FOO");
|
||||
SDLTest_AssertPass("Call to SDL_UnsetEnvironmentVariable(env, 'FOO')");
|
||||
SDLTest_AssertCheck(result == true, "Check result, expected: 1, got: %i", result);
|
||||
text = SDL_GetEnvironmentVariable(env, "FOO");
|
||||
SDLTest_AssertPass("Call to SDL_GetEnvironmentVariable(env, 'FOO')");
|
||||
SDLTest_AssertCheck(text == NULL, "Verify returned text, expected: (null), got: %s", text);
|
||||
result = SDL_setenv("FOO", "0", 0);
|
||||
SDLTest_AssertPass("Call to SDL_setenv('FOO','0', 0)");
|
||||
SDLTest_AssertCheck(result == 0, "Check result, expected: 0, got: %i", result);
|
||||
result = SDL_SetEnvironmentVariable(env, "FOO", "0", 0);
|
||||
SDLTest_AssertPass("Call to SDL_SetEnvironmentVariable(env, 'FOO','0', 0)");
|
||||
SDLTest_AssertCheck(result == true, "Check result, expected: 1, got: %i", result);
|
||||
expected = "0";
|
||||
text = SDL_getenv("FOO");
|
||||
SDLTest_AssertPass("Call to SDL_getenv('FOO')");
|
||||
text = SDL_GetEnvironmentVariable(env, "FOO");
|
||||
SDLTest_AssertPass("Call to SDL_GetEnvironmentVariable(env, 'FOO')");
|
||||
SDLTest_AssertCheck(text && SDL_strcmp(text, expected) == 0, "Verify returned text, expected: %s, got: %s", expected, text);
|
||||
|
||||
/* Negative cases */
|
||||
for (overwrite = 0; overwrite <= 1; overwrite++) {
|
||||
result = SDL_setenv(NULL, value1, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_setenv(NULL,'%s', %i)", value1, overwrite);
|
||||
SDLTest_AssertCheck(result == -1, "Check result, expected: -1, got: %i", result);
|
||||
result = SDL_setenv("", value1, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_setenv('','%s', %i)", value1, overwrite);
|
||||
SDLTest_AssertCheck(result == -1, "Check result, expected: -1, got: %i", result);
|
||||
result = SDL_setenv("=", value1, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_setenv('=','%s', %i)", value1, overwrite);
|
||||
SDLTest_AssertCheck(result == -1, "Check result, expected: -1, got: %i", result);
|
||||
result = SDL_setenv(name, NULL, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_setenv('%s', NULL, %i)", name, overwrite);
|
||||
SDLTest_AssertCheck(result == -1, "Check result, expected: -1, got: %i", result);
|
||||
result = SDL_SetEnvironmentVariable(env, NULL, value1, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_SetEnvironmentVariable(env, NULL,'%s', %i)", value1, overwrite);
|
||||
SDLTest_AssertCheck(result == false, "Check result, expected: 0, got: %i", result);
|
||||
result = SDL_SetEnvironmentVariable(env, "", value1, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_SetEnvironmentVariable(env, '','%s', %i)", value1, overwrite);
|
||||
SDLTest_AssertCheck(result == false, "Check result, expected: 0, got: %i", result);
|
||||
result = SDL_SetEnvironmentVariable(env, "=", value1, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_SetEnvironmentVariable(env, '=','%s', %i)", value1, overwrite);
|
||||
SDLTest_AssertCheck(result == false, "Check result, expected: 0, got: %i", result);
|
||||
result = SDL_SetEnvironmentVariable(env, name, NULL, overwrite);
|
||||
SDLTest_AssertPass("Call to SDL_SetEnvironmentVariable(env, '%s', NULL, %i)", name, overwrite);
|
||||
SDLTest_AssertCheck(result == false, "Check result, expected: 0, got: %i", result);
|
||||
}
|
||||
|
||||
/* Clean up */
|
||||
@@ -720,8 +717,7 @@ static int stdlib_getsetenv(void *arg)
|
||||
/**
|
||||
* Call to SDL_sscanf
|
||||
*/
|
||||
#undef SDL_sscanf
|
||||
static int stdlib_sscanf(void *arg)
|
||||
static int SDLCALL stdlib_sscanf(void *arg)
|
||||
{
|
||||
int output;
|
||||
int result;
|
||||
@@ -731,6 +727,7 @@ static int stdlib_sscanf(void *arg)
|
||||
long long_output, expected_long_output;
|
||||
long long long_long_output, expected_long_long_output;
|
||||
size_t size_output, expected_size_output;
|
||||
void *ptr_output, *expected_ptr_output;
|
||||
char text[128], text2[128];
|
||||
|
||||
expected_output = output = 123;
|
||||
@@ -795,6 +792,15 @@ static int stdlib_sscanf(void *arg)
|
||||
SDLTest_AssertCheck(expected_size_output == size_output, "Check output, expected: %zu, got: %zu", expected_size_output, size_output);
|
||||
SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
|
||||
|
||||
ptr_output = (void *)123;
|
||||
expected_ptr_output = (void *)0x1234567;
|
||||
expected_result = 1;
|
||||
result = SDL_snprintf(text, sizeof(text), "%p", expected_ptr_output);
|
||||
result = SDL_sscanf(text, "%p", &ptr_output);
|
||||
SDLTest_AssertPass("Call to SDL_sscanf(\"%s\", \"%%p\", &output)", text);
|
||||
SDLTest_AssertCheck(expected_ptr_output == ptr_output, "Check output, expected: %p, got: %p", expected_ptr_output, ptr_output);
|
||||
SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
|
||||
|
||||
expected_result = 1;
|
||||
text[0] = '\0';
|
||||
result = SDL_sscanf("abc def", "%s", text);
|
||||
@@ -889,7 +895,7 @@ static int stdlib_sscanf(void *arg)
|
||||
/**
|
||||
* Call to SDL_aligned_alloc
|
||||
*/
|
||||
static int stdlib_aligned_alloc(void *arg)
|
||||
static int SDLCALL stdlib_aligned_alloc(void *arg)
|
||||
{
|
||||
size_t i, alignment;
|
||||
void *ptr;
|
||||
@@ -917,35 +923,35 @@ typedef struct
|
||||
size_t a;
|
||||
size_t b;
|
||||
size_t result;
|
||||
SDL_bool status;
|
||||
bool status;
|
||||
} overflow_test;
|
||||
|
||||
static const overflow_test multiplications[] = {
|
||||
{ 1, 1, 1, SDL_TRUE },
|
||||
{ 0, 0, 0, SDL_TRUE },
|
||||
{ SDL_SIZE_MAX, 0, 0, SDL_TRUE },
|
||||
{ SDL_SIZE_MAX, 1, SDL_SIZE_MAX, SDL_TRUE },
|
||||
{ SDL_SIZE_MAX / 2, 2, SDL_SIZE_MAX - (SDL_SIZE_MAX % 2), SDL_TRUE },
|
||||
{ SDL_SIZE_MAX / 23, 23, SDL_SIZE_MAX - (SDL_SIZE_MAX % 23), SDL_TRUE },
|
||||
{ 1, 1, 1, true },
|
||||
{ 0, 0, 0, true },
|
||||
{ SDL_SIZE_MAX, 0, 0, true },
|
||||
{ SDL_SIZE_MAX, 1, SDL_SIZE_MAX, true },
|
||||
{ SDL_SIZE_MAX / 2, 2, SDL_SIZE_MAX - (SDL_SIZE_MAX % 2), true },
|
||||
{ SDL_SIZE_MAX / 23, 23, SDL_SIZE_MAX - (SDL_SIZE_MAX % 23), true },
|
||||
|
||||
{ (SDL_SIZE_MAX / 2) + 1, 2, 0, SDL_FALSE },
|
||||
{ (SDL_SIZE_MAX / 23) + 42, 23, 0, SDL_FALSE },
|
||||
{ SDL_SIZE_MAX, SDL_SIZE_MAX, 0, SDL_FALSE },
|
||||
{ (SDL_SIZE_MAX / 2) + 1, 2, 0, false },
|
||||
{ (SDL_SIZE_MAX / 23) + 42, 23, 0, false },
|
||||
{ SDL_SIZE_MAX, SDL_SIZE_MAX, 0, false },
|
||||
};
|
||||
|
||||
static const overflow_test additions[] = {
|
||||
{ 1, 1, 2, SDL_TRUE },
|
||||
{ 0, 0, 0, SDL_TRUE },
|
||||
{ SDL_SIZE_MAX, 0, SDL_SIZE_MAX, SDL_TRUE },
|
||||
{ SDL_SIZE_MAX - 1, 1, SDL_SIZE_MAX, SDL_TRUE },
|
||||
{ SDL_SIZE_MAX - 42, 23, SDL_SIZE_MAX - (42 - 23), SDL_TRUE },
|
||||
{ 1, 1, 2, true },
|
||||
{ 0, 0, 0, true },
|
||||
{ SDL_SIZE_MAX, 0, SDL_SIZE_MAX, true },
|
||||
{ SDL_SIZE_MAX - 1, 1, SDL_SIZE_MAX, true },
|
||||
{ SDL_SIZE_MAX - 42, 23, SDL_SIZE_MAX - (42 - 23), true },
|
||||
|
||||
{ SDL_SIZE_MAX, 1, 0, SDL_FALSE },
|
||||
{ SDL_SIZE_MAX, 23, 0, SDL_FALSE },
|
||||
{ SDL_SIZE_MAX, SDL_SIZE_MAX, 0, SDL_FALSE },
|
||||
{ SDL_SIZE_MAX, 1, 0, false },
|
||||
{ SDL_SIZE_MAX, 23, 0, false },
|
||||
{ SDL_SIZE_MAX, SDL_SIZE_MAX, 0, false },
|
||||
};
|
||||
|
||||
static int
|
||||
static int SDLCALL
|
||||
stdlib_overflow(void *arg)
|
||||
{
|
||||
size_t i;
|
||||
@@ -1012,7 +1018,7 @@ stdlib_overflow(void *arg)
|
||||
|
||||
for (i = 0; i < SDL_arraysize(additions); i++) {
|
||||
const overflow_test *t = &additions[i];
|
||||
SDL_bool status;
|
||||
bool status;
|
||||
size_t result = ~t->result;
|
||||
|
||||
if (useBuiltin) {
|
||||
@@ -1072,22 +1078,22 @@ static void format_for_description(char *buffer, size_t buflen, const char *text
|
||||
}
|
||||
}
|
||||
|
||||
static int
|
||||
static int SDLCALL
|
||||
stdlib_iconv(void *arg)
|
||||
{
|
||||
struct {
|
||||
SDL_bool expect_success;
|
||||
bool expect_success;
|
||||
const char *from_encoding;
|
||||
const char *text;
|
||||
const char *to_encoding;
|
||||
const char *expected;
|
||||
} inputs[] = {
|
||||
{ SDL_FALSE, "bogus-from-encoding", NULL, "bogus-to-encoding", NULL },
|
||||
{ SDL_FALSE, "bogus-from-encoding", "hello world", "bogus-to-encoding", NULL },
|
||||
{ SDL_FALSE, "bogus-from-encoding", "hello world", "ascii", NULL },
|
||||
{ SDL_TRUE, "utf-8", NULL, "ascii", "" },
|
||||
{ SDL_TRUE, "utf-8", "hello world", "ascii", "hello world" },
|
||||
{ SDL_TRUE, "utf-8", "\xe2\x8c\xa8\xf0\x9f\x92\xbb", "utf-16le", "\x28\x23\x3d\xd8\xbb\xdc\x00" },
|
||||
{ false, "bogus-from-encoding", NULL, "bogus-to-encoding", NULL },
|
||||
{ false, "bogus-from-encoding", "hello world", "bogus-to-encoding", NULL },
|
||||
{ false, "bogus-from-encoding", "hello world", "ascii", NULL },
|
||||
{ true, "utf-8", NULL, "ascii", "" },
|
||||
{ true, "utf-8", "hello world", "ascii", "hello world" },
|
||||
{ true, "utf-8", "\xe2\x8c\xa8\xf0\x9f\x92\xbb", "utf-16le", "\x28\x23\x3d\xd8\xbb\xdc\x00" },
|
||||
};
|
||||
SDL_iconv_t cd;
|
||||
size_t i;
|
||||
@@ -1105,7 +1111,7 @@ stdlib_iconv(void *arg)
|
||||
char *output;
|
||||
size_t iconv_result;
|
||||
size_t out_len;
|
||||
SDL_bool is_error;
|
||||
bool is_error;
|
||||
size_t out_pos;
|
||||
|
||||
SDLTest_AssertPass("case %d", (int)i);
|
||||
@@ -1159,7 +1165,7 @@ stdlib_iconv(void *arg)
|
||||
break;
|
||||
}
|
||||
if (count_read == 0) {
|
||||
SDLTest_AssertCheck(SDL_FALSE, "SDL_iconv wrote data, but read no data");
|
||||
SDLTest_AssertCheck(false, "SDL_iconv wrote data, but read no data");
|
||||
break;
|
||||
}
|
||||
} while (!is_error && in_pos < len_text);
|
||||
@@ -1188,6 +1194,191 @@ stdlib_iconv(void *arg)
|
||||
return TEST_COMPLETED;
|
||||
}
|
||||
|
||||
|
||||
static int SDLCALL
|
||||
stdlib_strpbrk(void *arg)
|
||||
{
|
||||
struct {
|
||||
const char *input;
|
||||
const char *accept;
|
||||
int expected[3]; /* negative if NULL */
|
||||
} test_cases[] = {
|
||||
{ "", "", { -1, -1, -1 } },
|
||||
{ "abc", "", { -1, -1, -1 } },
|
||||
{ "Abc", "a", { -1, -1, -1 } },
|
||||
{ "abc", "a", { 0, -1, -1 } },
|
||||
{ "abcbd", "bbbb", { 1, 3, -1 } },
|
||||
{ "a;b;c", ";", { 1, 3, -1 } },
|
||||
{ "a;b;c", ",", { -1, -1, -1 } },
|
||||
{ "a:bbbb;c", ";:", { 1, 6, -1 } },
|
||||
{ "Hello\tS DL\n", " \t\r\n", { 5, 7, 10 } },
|
||||
};
|
||||
int i;
|
||||
|
||||
for (i = 0; i < SDL_arraysize(test_cases); i++) {
|
||||
int j;
|
||||
const char *input = test_cases[i].input;
|
||||
|
||||
for (j = 0; j < SDL_arraysize(test_cases[i].expected); j++) {
|
||||
char *result;
|
||||
|
||||
SDLTest_AssertPass("About to call SDL_strpbrk(\"%s\", \"%s\")", input, test_cases[i].accept);
|
||||
result = SDL_strpbrk(input, test_cases[i].accept);
|
||||
if (test_cases[i].expected[j] < 0) {
|
||||
SDLTest_AssertCheck(result == NULL, "Expected NULL, got %p", result);
|
||||
} else {
|
||||
SDLTest_AssertCheck(result == test_cases[i].input + test_cases[i].expected[j], "Expected %p, got %p", test_cases[i].input + test_cases[i].expected[j], result);
|
||||
input = test_cases[i].input + test_cases[i].expected[j] + 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return TEST_COMPLETED;
|
||||
}
|
||||
|
||||
static int SDLCALL stdlib_wcstol(void *arg)
|
||||
{
|
||||
const long long_max = (~0UL) >> 1;
|
||||
const long long_min = ((~0UL) >> 1) + 1UL;
|
||||
|
||||
#define WCSTOL_TEST_CASE(str, base, expected_result, expected_endp_offset) do { \
|
||||
const wchar_t *s = str; \
|
||||
long r, expected_r = expected_result; \
|
||||
wchar_t *ep, *expected_ep = (wchar_t *)s + expected_endp_offset; \
|
||||
r = SDL_wcstol(s, &ep, base); \
|
||||
SDLTest_AssertPass("Call to SDL_wcstol(" #str ", &endp, " #base ")"); \
|
||||
SDLTest_AssertCheck(r == expected_r, "Check result value, expected: %ld, got: %ld", expected_r, r); \
|
||||
SDLTest_AssertCheck(ep == expected_ep, "Check endp value, expected: %p, got: %p", expected_ep, ep); \
|
||||
} while (0)
|
||||
|
||||
// infer decimal
|
||||
WCSTOL_TEST_CASE(L"\t 123abcxyz", 0, 123, 6); // skip leading space
|
||||
WCSTOL_TEST_CASE(L"+123abcxyz", 0, 123, 4);
|
||||
WCSTOL_TEST_CASE(L"-123abcxyz", 0, -123, 4);
|
||||
WCSTOL_TEST_CASE(L"99999999999999999999abcxyz", 0, long_max, 20);
|
||||
WCSTOL_TEST_CASE(L"-99999999999999999999abcxyz", 0, long_min, 21);
|
||||
|
||||
// infer hexadecimal
|
||||
WCSTOL_TEST_CASE(L"0x123abcxyz", 0, 0x123abc, 8);
|
||||
WCSTOL_TEST_CASE(L"0X123ABCXYZ", 0, 0x123abc, 8); // uppercase X
|
||||
|
||||
// infer octal
|
||||
WCSTOL_TEST_CASE(L"0123abcxyz", 0, 0123, 4);
|
||||
|
||||
// arbitrary bases
|
||||
WCSTOL_TEST_CASE(L"00110011", 2, 51, 8);
|
||||
WCSTOL_TEST_CASE(L"-uvwxyz", 32, -991, 3);
|
||||
WCSTOL_TEST_CASE(L"ZzZzZzZzZzZzZ", 36, long_max, 13);
|
||||
|
||||
WCSTOL_TEST_CASE(L"-0", 10, 0, 2);
|
||||
WCSTOL_TEST_CASE(L" - 1", 0, 0, 0); // invalid input
|
||||
|
||||
// values near the bounds of the type
|
||||
if (sizeof(long) == 4) {
|
||||
WCSTOL_TEST_CASE(L"2147483647", 10, 2147483647, 10);
|
||||
WCSTOL_TEST_CASE(L"2147483648", 10, 2147483647, 10);
|
||||
WCSTOL_TEST_CASE(L"-2147483648", 10, -2147483647L - 1, 11);
|
||||
WCSTOL_TEST_CASE(L"-2147483649", 10, -2147483647L - 1, 11);
|
||||
WCSTOL_TEST_CASE(L"-9999999999999999999999999999999999999999", 10, -2147483647L - 1, 41);
|
||||
}
|
||||
|
||||
#undef WCSTOL_TEST_CASE
|
||||
|
||||
return TEST_COMPLETED;
|
||||
}
|
||||
|
||||
static int SDLCALL stdlib_strtox(void *arg)
|
||||
{
|
||||
const unsigned long long ullong_max = ~0ULL;
|
||||
|
||||
#define STRTOX_TEST_CASE(func_name, type, format_spec, str, base, expected_result, expected_endp_offset) do { \
|
||||
const char *s = str; \
|
||||
type r, expected_r = expected_result; \
|
||||
char *ep, *expected_ep = (char *)s + expected_endp_offset; \
|
||||
r = func_name(s, &ep, base); \
|
||||
SDLTest_AssertPass("Call to " #func_name "(" #str ", &endp, " #base ")"); \
|
||||
SDLTest_AssertCheck(r == expected_r, "Check result value, expected: " format_spec ", got: " format_spec, expected_r, r); \
|
||||
SDLTest_AssertCheck(ep == expected_ep, "Check endp value, expected: %p, got: %p", expected_ep, ep); \
|
||||
} while (0)
|
||||
|
||||
// infer decimal
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "\t 123abcxyz", 0, 123, 6); // skip leading space
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "+123abcxyz", 0, 123, 4);
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "+123abcxyz", 0, 123, 4);
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "-123abcxyz", 0, -123, 4);
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "9999999999999999999999999999999999999999abcxyz", 0, ullong_max, 40);
|
||||
|
||||
// infer hexadecimal
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "0x123abcxyz", 0, 0x123abc, 8);
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "0X123ABCXYZ", 0, 0x123abc, 8); // uppercase X
|
||||
|
||||
// infer octal
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "0123abcxyz", 0, 0123, 4);
|
||||
|
||||
// arbitrary bases
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "00110011", 2, 51, 8);
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "-uvwxyz", 32, -991, 3);
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "ZzZzZzZzZzZzZzZzZzZzZzZzZ", 36, ullong_max, 25);
|
||||
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "-0", 10, 0, 2);
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", " - 1", 0, 0, 0); // invalid input
|
||||
|
||||
// We know that SDL_strtol, SDL_strtoul and SDL_strtoll share the same code path as SDL_strtoull under the hood,
|
||||
// so the most interesting test cases are those close to the bounds of the integer type.
|
||||
|
||||
// For simplicity, we only run long/long long tests when they are 32-bit/64-bit, respectively.
|
||||
// Suppressing warnings would be difficult otherwise.
|
||||
// Since the CI runs the tests against a variety of targets, this should be fine in practice.
|
||||
|
||||
if (sizeof(long) == 4) {
|
||||
STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "2147483647", 10, 2147483647, 10);
|
||||
STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "2147483648", 10, 2147483647, 10);
|
||||
STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "-2147483648", 10, -2147483647L - 1, 11);
|
||||
STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "-2147483649", 10, -2147483647L - 1, 11);
|
||||
STRTOX_TEST_CASE(SDL_strtol, long, "%ld", "-9999999999999999999999999999999999999999", 10, -2147483647L - 1, 41);
|
||||
|
||||
STRTOX_TEST_CASE(SDL_strtoul, unsigned long, "%lu", "4294967295", 10, 4294967295UL, 10);
|
||||
STRTOX_TEST_CASE(SDL_strtoul, unsigned long, "%lu", "4294967296", 10, 4294967295UL, 10);
|
||||
STRTOX_TEST_CASE(SDL_strtoul, unsigned long, "%lu", "-4294967295", 10, 1, 11);
|
||||
}
|
||||
|
||||
if (sizeof(long long) == 8) {
|
||||
STRTOX_TEST_CASE(SDL_strtoll, long long, "%lld", "9223372036854775807", 10, 9223372036854775807LL, 19);
|
||||
STRTOX_TEST_CASE(SDL_strtoll, long long, "%lld", "9223372036854775808", 10, 9223372036854775807LL, 19);
|
||||
STRTOX_TEST_CASE(SDL_strtoll, long long, "%lld", "-9223372036854775808", 10, -9223372036854775807LL - 1, 20);
|
||||
STRTOX_TEST_CASE(SDL_strtoll, long long, "%lld", "-9223372036854775809", 10, -9223372036854775807LL - 1, 20);
|
||||
STRTOX_TEST_CASE(SDL_strtoll, long long, "%lld", "-9999999999999999999999999999999999999999", 10, -9223372036854775807LL - 1, 41);
|
||||
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "18446744073709551615", 10, 18446744073709551615ULL, 20);
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "18446744073709551616", 10, 18446744073709551615ULL, 20);
|
||||
STRTOX_TEST_CASE(SDL_strtoull, unsigned long long, "%llu", "-18446744073709551615", 10, 1, 21);
|
||||
}
|
||||
|
||||
#undef STRTOX_TEST_CASE
|
||||
|
||||
return TEST_COMPLETED;
|
||||
}
|
||||
|
||||
static int SDLCALL stdlib_strtod(void *arg)
|
||||
{
|
||||
#define STRTOD_TEST_CASE(str, expected_result, expected_endp_offset) do { \
|
||||
const char *s = str; \
|
||||
double r, expected_r = expected_result; \
|
||||
char *ep, *expected_ep = (char *)s + expected_endp_offset; \
|
||||
r = SDL_strtod(s, &ep); \
|
||||
SDLTest_AssertPass("Call to SDL_strtod(" #str ", &endp)"); \
|
||||
SDLTest_AssertCheck(r == expected_r, "Check result value, expected: %f, got: %f", expected_r, r); \
|
||||
SDLTest_AssertCheck(ep == expected_ep, "Check endp value, expected: %p, got: %p", expected_ep, ep); \
|
||||
} while (0)
|
||||
|
||||
STRTOD_TEST_CASE("\t 123.75abcxyz", 123.75, 9); // skip leading space
|
||||
STRTOD_TEST_CASE("+999.555", 999.555, 8);
|
||||
STRTOD_TEST_CASE("-999.555", -999.555, 8);
|
||||
|
||||
#undef STRTOD_TEST_CASE
|
||||
|
||||
return TEST_COMPLETED;
|
||||
}
|
||||
|
||||
/* ================= Test References ================== */
|
||||
|
||||
/* Standard C routine test cases */
|
||||
@@ -1212,7 +1403,7 @@ static const SDLTest_TestCaseReference stdlibTest_swprintf = {
|
||||
};
|
||||
|
||||
static const SDLTest_TestCaseReference stdlibTest_getsetenv = {
|
||||
stdlib_getsetenv, "stdlib_getsetenv", "Call to SDL_getenv and SDL_setenv", TEST_ENABLED
|
||||
stdlib_getsetenv, "stdlib_getsetenv", "Call to SDL_GetEnvironmentVariable and SDL_SetEnvironmentVariable", TEST_ENABLED
|
||||
};
|
||||
|
||||
static const SDLTest_TestCaseReference stdlibTest_sscanf = {
|
||||
@@ -1227,8 +1418,24 @@ static const SDLTest_TestCaseReference stdlibTestOverflow = {
|
||||
stdlib_overflow, "stdlib_overflow", "Overflow detection", TEST_ENABLED
|
||||
};
|
||||
|
||||
static const SDLTest_TestCaseReference stdlibIconv = {
|
||||
stdlib_iconv, "stdlib_iconv", "Calls to iconv", TEST_ENABLED
|
||||
static const SDLTest_TestCaseReference stdlibTest_iconv = {
|
||||
stdlib_iconv, "stdlib_iconv", "Calls to SDL_iconv", TEST_ENABLED
|
||||
};
|
||||
|
||||
static const SDLTest_TestCaseReference stdlibTest_strpbrk = {
|
||||
stdlib_strpbrk, "stdlib_strpbrk", "Calls to SDL_strpbrk", TEST_ENABLED
|
||||
};
|
||||
|
||||
static const SDLTest_TestCaseReference stdlibTest_wcstol = {
|
||||
stdlib_wcstol, "stdlib_wcstol", "Calls to SDL_wcstol", TEST_ENABLED
|
||||
};
|
||||
|
||||
static const SDLTest_TestCaseReference stdlibTest_strtox = {
|
||||
stdlib_strtox, "stdlib_strtox", "Calls to SDL_strtol, SDL_strtoul, SDL_strtoll and SDL_strtoull", TEST_ENABLED
|
||||
};
|
||||
|
||||
static const SDLTest_TestCaseReference stdlibTest_strtod = {
|
||||
stdlib_strtod, "stdlib_strtod", "Calls to SDL_strtod", TEST_ENABLED
|
||||
};
|
||||
|
||||
/* Sequence of Standard C routine test cases */
|
||||
@@ -1242,7 +1449,11 @@ static const SDLTest_TestCaseReference *stdlibTests[] = {
|
||||
&stdlibTest_sscanf,
|
||||
&stdlibTest_aligned_alloc,
|
||||
&stdlibTestOverflow,
|
||||
&stdlibIconv,
|
||||
&stdlibTest_iconv,
|
||||
&stdlibTest_strpbrk,
|
||||
&stdlibTest_wcstol,
|
||||
&stdlibTest_strtox,
|
||||
&stdlibTest_strtod,
|
||||
NULL
|
||||
};
|
||||
|
||||
|
||||
Reference in New Issue
Block a user