testautomation_stdlib.c 32 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688
  1. /**
  2. * Standard C library routine test suite
  3. */
  4. #include <stdio.h>
  5. #include "SDL.h"
  6. #include "SDL_test.h"
  7. /* Test case functions */
  8. /**
  9. * @brief Call to SDL_strlcpy
  10. */
  11. #undef SDL_strlcpy
  12. int stdlib_strlcpy(void *arg)
  13. {
  14. size_t result;
  15. char text[1024];
  16. const char *expected;
  17. result = SDL_strlcpy(text, "foo", sizeof(text));
  18. expected = "foo";
  19. SDLTest_AssertPass("Call to SDL_strlcpy(\"foo\")");
  20. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  21. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), (int)result);
  22. result = SDL_strlcpy(text, "foo", 2);
  23. expected = "f";
  24. SDLTest_AssertPass("Call to SDL_strlcpy(\"foo\") with buffer size 2");
  25. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  26. SDLTest_AssertCheck(result == 3, "Check result value, expected: 3, got: %d", (int)result);
  27. return TEST_COMPLETED;
  28. }
  29. #if defined(HAVE_WFORMAT) || defined(HAVE_WFORMAT_EXTRA_ARGS)
  30. #pragma GCC diagnostic push
  31. #if defined(HAVE_WFORMAT)
  32. #pragma GCC diagnostic ignored "-Wformat"
  33. #endif
  34. #if defined(HAVE_WFORMAT_EXTRA_ARGS)
  35. #pragma GCC diagnostic ignored "-Wformat-extra-args"
  36. #endif
  37. #endif
  38. /**
  39. * @brief Call to SDL_snprintf
  40. */
  41. #undef SDL_snprintf
  42. int stdlib_snprintf(void *arg)
  43. {
  44. int result;
  45. int predicted;
  46. char text[1024];
  47. const char *expected;
  48. size_t size;
  49. result = SDL_snprintf(text, sizeof(text), "%s", "foo");
  50. expected = "foo";
  51. SDLTest_AssertPass("Call to SDL_snprintf(\"%%s\", \"foo\")");
  52. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  53. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), result);
  54. result = SDL_snprintf(text, sizeof(text), "%S", L"foo");
  55. expected = "foo";
  56. SDLTest_AssertPass("Call to SDL_snprintf(\"%%S\", \"foo\")");
  57. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  58. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), result);
  59. result = SDL_snprintf(text, sizeof(text), "%ls", L"foo");
  60. expected = "foo";
  61. SDLTest_AssertPass("Call to SDL_snprintf(\"%%ls\", \"foo\")");
  62. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  63. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), result);
  64. result = SDL_snprintf(text, 2, "%s", "foo");
  65. expected = "f";
  66. SDLTest_AssertPass("Call to SDL_snprintf(\"%%s\", \"foo\") with buffer size 2");
  67. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  68. SDLTest_AssertCheck(result == 3, "Check result value, expected: 3, got: %d", result);
  69. result = SDL_snprintf(NULL, 0, "%s", "foo");
  70. SDLTest_AssertPass("Call to SDL_snprintf(NULL, 0, \"%%s\", \"foo\")");
  71. SDLTest_AssertCheck(result == 3, "Check result value, expected: 3, got: %d", result);
  72. result = SDL_snprintf(text, 2, "%s\n", "foo");
  73. expected = "f";
  74. SDLTest_AssertPass("Call to SDL_snprintf(\"%%s\\n\", \"foo\") with buffer size 2");
  75. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  76. SDLTest_AssertCheck(result == 4, "Check result value, expected: 4, got: %d", result);
  77. result = SDL_snprintf(text, sizeof(text), "%f", 0.0);
  78. predicted = SDL_snprintf(NULL, 0, "%f", 0.0);
  79. expected = "0.000000";
  80. SDLTest_AssertPass("Call to SDL_snprintf(\"%%f\", 0.0)");
  81. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  82. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), result);
  83. SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
  84. result = SDL_snprintf(text, sizeof(text), "%f", 1.0);
  85. predicted = SDL_snprintf(NULL, 0, "%f", 1.0);
  86. expected = "1.000000";
  87. SDLTest_AssertPass("Call to SDL_snprintf(\"%%f\", 1.0)");
  88. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  89. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), result);
  90. SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
  91. result = SDL_snprintf(text, sizeof(text), "%.f", 1.0);
  92. predicted = SDL_snprintf(NULL, 0, "%.f", 1.0);
  93. expected = "1";
  94. SDLTest_AssertPass("Call to SDL_snprintf(\"%%.f\", 1.0)");
  95. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  96. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), result);
  97. SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
  98. result = SDL_snprintf(text, sizeof(text), "%#.f", 1.0);
  99. predicted = SDL_snprintf(NULL, 0, "%#.f", 1.0);
  100. expected = "1.";
  101. SDLTest_AssertPass("Call to SDL_snprintf(\"%%#.f\", 1.0)");
  102. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  103. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), result);
  104. SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
  105. result = SDL_snprintf(text, sizeof(text), "%f", 1.0 + 1.0 / 3.0);
  106. predicted = SDL_snprintf(NULL, 0, "%f", 1.0 + 1.0 / 3.0);
  107. expected = "1.333333";
  108. SDLTest_AssertPass("Call to SDL_snprintf(\"%%f\", 1.0 + 1.0 / 3.0)");
  109. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  110. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), result);
  111. SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
  112. result = SDL_snprintf(text, sizeof(text), "%+f", 1.0 + 1.0 / 3.0);
  113. predicted = SDL_snprintf(NULL, 0, "%+f", 1.0 + 1.0 / 3.0);
  114. expected = "+1.333333";
  115. SDLTest_AssertPass("Call to SDL_snprintf(\"%%+f\", 1.0 + 1.0 / 3.0)");
  116. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  117. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), result);
  118. SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
  119. result = SDL_snprintf(text, sizeof(text), "%.2f", 1.0 + 1.0 / 3.0);
  120. predicted = SDL_snprintf(NULL, 0, "%.2f", 1.0 + 1.0 / 3.0);
  121. expected = "1.33";
  122. SDLTest_AssertPass("Call to SDL_snprintf(\"%%.2f\", 1.0 + 1.0 / 3.0)");
  123. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: %s, got: %s", expected, text);
  124. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), result);
  125. SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
  126. result = SDL_snprintf(text, sizeof(text), "%6.2f", 1.0 + 1.0 / 3.0);
  127. predicted = SDL_snprintf(NULL, 0, "%6.2f", 1.0 + 1.0 / 3.0);
  128. expected = " 1.33";
  129. SDLTest_AssertPass("Call to SDL_snprintf(\"%%6.2f\", 1.0 + 1.0 / 3.0)");
  130. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: '%s', got: '%s'", expected, text);
  131. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), result);
  132. SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
  133. result = SDL_snprintf(text, sizeof(text), "%06.2f", 1.0 + 1.0 / 3.0);
  134. predicted = SDL_snprintf(NULL, 0, "%06.2f", 1.0 + 1.0 / 3.0);
  135. expected = "001.33";
  136. SDLTest_AssertPass("Call to SDL_snprintf(\"%%06.2f\", 1.0 + 1.0 / 3.0)");
  137. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: '%s', got: '%s'", expected, text);
  138. SDLTest_AssertCheck(result == SDL_strlen(text), "Check result value, expected: %d, got: %d", (int)SDL_strlen(text), result);
  139. SDLTest_AssertCheck(predicted == result, "Check predicted value, expected: %d, got: %d", result, predicted);
  140. result = SDL_snprintf(text, 5, "%06.2f", 1.0 + 1.0 / 3.0);
  141. expected = "001.";
  142. SDLTest_AssertPass("Call to SDL_snprintf(\"%%06.2f\", 1.0 + 1.0 / 3.0) with buffer size 5");
  143. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: '%s', got: '%s'", expected, text);
  144. SDLTest_AssertCheck(result == 6, "Check result value, expected: 6, got: %d", result);
  145. size = 64;
  146. result = SDL_snprintf(text, sizeof(text), "%zu %s", size, "test");
  147. expected = "64 test";
  148. SDLTest_AssertPass("Call to SDL_snprintf(text, sizeof(text), \"%%zu %%s\", size, \"test\")");
  149. SDLTest_AssertCheck(SDL_strcmp(text, expected) == 0, "Check text, expected: '%s', got: '%s'", expected, text);
  150. SDLTest_AssertCheck(result == 7, "Check result value, expected: 7, got: %d", result);
  151. return TEST_COMPLETED;
  152. }
  153. #if defined(HAVE_WFORMAT) || defined(HAVE_WFORMAT_EXTRA_ARGS)
  154. #pragma GCC diagnostic pop
  155. #endif
  156. /**
  157. * @brief Call to SDL_getenv and SDL_setenv
  158. */
  159. int stdlib_getsetenv(void *arg)
  160. {
  161. const int nameLen = 16;
  162. char name[17];
  163. int counter;
  164. int result;
  165. char *value1;
  166. char *value2;
  167. char *expected;
  168. int overwrite;
  169. char *text;
  170. /* Create a random name. This tests SDL_getenv, since we need to */
  171. /* make sure the variable is not set yet (it shouldn't). */
  172. do {
  173. for (counter = 0; counter < nameLen; counter++) {
  174. name[counter] = (char)SDLTest_RandomIntegerInRange(65, 90);
  175. }
  176. name[nameLen] = '\0';
  177. text = SDL_getenv(name);
  178. SDLTest_AssertPass("Call to SDL_getenv('%s')", name);
  179. if (text != NULL) {
  180. SDLTest_Log("Expected: NULL, Got: '%s' (%i)", text, (int)SDL_strlen(text));
  181. }
  182. } while (text != NULL);
  183. /* Create random values to set */
  184. value1 = SDLTest_RandomAsciiStringOfSize(10);
  185. value2 = SDLTest_RandomAsciiStringOfSize(10);
  186. /* Set value 1 without overwrite */
  187. overwrite = 0;
  188. expected = value1;
  189. result = SDL_setenv(name, value1, overwrite);
  190. SDLTest_AssertPass("Call to SDL_setenv('%s','%s', %i)", name, value1, overwrite);
  191. SDLTest_AssertCheck(result == 0, "Check result, expected: 0, got: %i", result);
  192. /* Check value */
  193. text = SDL_getenv(name);
  194. SDLTest_AssertPass("Call to SDL_getenv('%s')", name);
  195. SDLTest_AssertCheck(text != NULL, "Verify returned text is not NULL");
  196. if (text != NULL) {
  197. SDLTest_AssertCheck(
  198. SDL_strcmp(text, expected) == 0,
  199. "Verify returned text, expected: %s, got: %s",
  200. expected,
  201. text);
  202. }
  203. /* Set value 2 with overwrite */
  204. overwrite = 1;
  205. expected = value2;
  206. result = SDL_setenv(name, value2, overwrite);
  207. SDLTest_AssertPass("Call to SDL_setenv('%s','%s', %i)", name, value2, overwrite);
  208. SDLTest_AssertCheck(result == 0, "Check result, expected: 0, got: %i", result);
  209. /* Check value */
  210. text = SDL_getenv(name);
  211. SDLTest_AssertPass("Call to SDL_getenv('%s')", name);
  212. SDLTest_AssertCheck(text != NULL, "Verify returned text is not NULL");
  213. if (text != NULL) {
  214. SDLTest_AssertCheck(
  215. SDL_strcmp(text, expected) == 0,
  216. "Verify returned text, expected: %s, got: %s",
  217. expected,
  218. text);
  219. }
  220. /* Set value 1 without overwrite */
  221. overwrite = 0;
  222. expected = value2;
  223. result = SDL_setenv(name, value1, overwrite);
  224. SDLTest_AssertPass("Call to SDL_setenv('%s','%s', %i)", name, value1, overwrite);
  225. SDLTest_AssertCheck(result == 0, "Check result, expected: 0, got: %i", result);
  226. /* Check value */
  227. text = SDL_getenv(name);
  228. SDLTest_AssertPass("Call to SDL_getenv('%s')", name);
  229. SDLTest_AssertCheck(text != NULL, "Verify returned text is not NULL");
  230. if (text != NULL) {
  231. SDLTest_AssertCheck(
  232. SDL_strcmp(text, expected) == 0,
  233. "Verify returned text, expected: %s, got: %s",
  234. expected,
  235. text);
  236. }
  237. /* Set value 1 without overwrite */
  238. overwrite = 1;
  239. expected = value1;
  240. result = SDL_setenv(name, value1, overwrite);
  241. SDLTest_AssertPass("Call to SDL_setenv('%s','%s', %i)", name, value1, overwrite);
  242. SDLTest_AssertCheck(result == 0, "Check result, expected: 0, got: %i", result);
  243. /* Check value */
  244. text = SDL_getenv(name);
  245. SDLTest_AssertPass("Call to SDL_getenv('%s')", name);
  246. SDLTest_AssertCheck(text != NULL, "Verify returned text is not NULL");
  247. if (text != NULL) {
  248. SDLTest_AssertCheck(
  249. SDL_strcmp(text, expected) == 0,
  250. "Verify returned text, expected: %s, got: %s",
  251. expected,
  252. text);
  253. }
  254. /* Negative cases */
  255. for (overwrite = 0; overwrite <= 1; overwrite++) {
  256. result = SDL_setenv(NULL, value1, overwrite);
  257. SDLTest_AssertPass("Call to SDL_setenv(NULL,'%s', %i)", value1, overwrite);
  258. SDLTest_AssertCheck(result == -1, "Check result, expected: -1, got: %i", result);
  259. result = SDL_setenv("", value1, overwrite);
  260. SDLTest_AssertPass("Call to SDL_setenv('','%s', %i)", value1, overwrite);
  261. SDLTest_AssertCheck(result == -1, "Check result, expected: -1, got: %i", result);
  262. result = SDL_setenv("=", value1, overwrite);
  263. SDLTest_AssertPass("Call to SDL_setenv('=','%s', %i)", value1, overwrite);
  264. SDLTest_AssertCheck(result == -1, "Check result, expected: -1, got: %i", result);
  265. result = SDL_setenv(name, NULL, overwrite);
  266. SDLTest_AssertPass("Call to SDL_setenv('%s', NULL, %i)", name, overwrite);
  267. SDLTest_AssertCheck(result == -1, "Check result, expected: -1, got: %i", result);
  268. }
  269. /* Clean up */
  270. SDL_free(value1);
  271. SDL_free(value2);
  272. return TEST_COMPLETED;
  273. }
  274. #if defined(HAVE_WFORMAT) || defined(HAVE_WFORMAT_EXTRA_ARGS)
  275. #pragma GCC diagnostic push
  276. #if defined(HAVE_WFORMAT)
  277. #pragma GCC diagnostic ignored "-Wformat"
  278. #endif
  279. #if defined(HAVE_WFORMAT_EXTRA_ARGS)
  280. #pragma GCC diagnostic ignored "-Wformat-extra-args"
  281. #endif
  282. #endif
  283. /**
  284. * @brief Call to SDL_sscanf
  285. */
  286. #undef SDL_sscanf
  287. int stdlib_sscanf(void *arg)
  288. {
  289. int output;
  290. int result;
  291. int expected_output;
  292. int expected_result;
  293. short short_output, expected_short_output;
  294. long long_output, expected_long_output;
  295. long long long_long_output, expected_long_long_output;
  296. size_t size_output, expected_size_output;
  297. char text[128], text2[128];
  298. expected_output = output = 123;
  299. expected_result = -1;
  300. result = SDL_sscanf("", "%i", &output);
  301. SDLTest_AssertPass("Call to SDL_sscanf(\"\", \"%%i\", &output)");
  302. SDLTest_AssertCheck(expected_output == output, "Check output, expected: %i, got: %i", expected_output, output);
  303. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  304. expected_output = output = 123;
  305. expected_result = 0;
  306. result = SDL_sscanf("a", "%i", &output);
  307. SDLTest_AssertPass("Call to SDL_sscanf(\"a\", \"%%i\", &output)");
  308. SDLTest_AssertCheck(expected_output == output, "Check output, expected: %i, got: %i", expected_output, output);
  309. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  310. output = 123;
  311. expected_output = 2;
  312. expected_result = 1;
  313. result = SDL_sscanf("2", "%i", &output);
  314. SDLTest_AssertPass("Call to SDL_sscanf(\"2\", \"%%i\", &output)");
  315. SDLTest_AssertCheck(expected_output == output, "Check output, expected: %i, got: %i", expected_output, output);
  316. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  317. output = 123;
  318. expected_output = 0xa;
  319. expected_result = 1;
  320. result = SDL_sscanf("aa", "%1x", &output);
  321. SDLTest_AssertPass("Call to SDL_sscanf(\"aa\", \"%%1x\", &output)");
  322. SDLTest_AssertCheck(expected_output == output, "Check output, expected: %i, got: %i", expected_output, output);
  323. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  324. #define SIZED_TEST_CASE(type, var, format_specifier) \
  325. var##_output = 123; \
  326. expected_##var##_output = (type)(((unsigned type)(~0)) >> 1); \
  327. expected_result = 1; \
  328. result = SDL_snprintf(text, sizeof(text), format_specifier, expected_##var##_output); \
  329. result = SDL_sscanf(text, format_specifier, &var##_output); \
  330. SDLTest_AssertPass("Call to SDL_sscanf(\"%s\", \"%s\", &output)", text, #format_specifier); \
  331. SDLTest_AssertCheck(expected_##var##_output == var##_output, "Check output, expected: " format_specifier ", got: " format_specifier, expected_##var##_output, var##_output); \
  332. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result); \
  333. \
  334. var##_output = 123; \
  335. expected_##var##_output = ~(type)(((unsigned type)(~0)) >> 1); \
  336. expected_result = 1; \
  337. result = SDL_snprintf(text, sizeof(text), format_specifier, expected_##var##_output); \
  338. result = SDL_sscanf(text, format_specifier, &var##_output); \
  339. SDLTest_AssertPass("Call to SDL_sscanf(\"%s\", \"%s\", &output)", text, #format_specifier); \
  340. SDLTest_AssertCheck(expected_##var##_output == var##_output, "Check output, expected: " format_specifier ", got: " format_specifier, expected_##var##_output, var##_output); \
  341. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  342. SIZED_TEST_CASE(short, short, "%hd")
  343. SIZED_TEST_CASE(long, long, "%ld")
  344. SIZED_TEST_CASE(long long, long_long, "%lld")
  345. size_output = 123;
  346. expected_size_output = ~((size_t)0);
  347. expected_result = 1;
  348. result = SDL_snprintf(text, sizeof(text), "%zu", expected_size_output);
  349. result = SDL_sscanf(text, "%zu", &size_output);
  350. SDLTest_AssertPass("Call to SDL_sscanf(\"%s\", \"%%zu\", &output)", text);
  351. SDLTest_AssertCheck(expected_size_output == size_output, "Check output, expected: %zu, got: %zu", expected_size_output, size_output);
  352. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  353. expected_result = 1;
  354. text[0] = '\0';
  355. result = SDL_sscanf("abc def", "%s", text);
  356. SDLTest_AssertPass("Call to SDL_sscanf(\"abc def\", \"%%s\", text)");
  357. SDLTest_AssertCheck(SDL_strcmp(text, "abc") == 0, "Check output, expected: \"abc\", got: \"%s\"", text);
  358. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  359. expected_result = 1;
  360. text[0] = '\0';
  361. result = SDL_sscanf("abc,def", "%s", text);
  362. SDLTest_AssertPass("Call to SDL_sscanf(\"abc,def\", \"%%s\", text)");
  363. SDLTest_AssertCheck(SDL_strcmp(text, "abc,def") == 0, "Check output, expected: \"abc\", got: \"%s\"", text);
  364. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  365. expected_result = 1;
  366. text[0] = '\0';
  367. result = SDL_sscanf("abc,def", "%[cba]", text);
  368. SDLTest_AssertPass("Call to SDL_sscanf(\"abc,def\", \"%%[cba]\", text)");
  369. SDLTest_AssertCheck(SDL_strcmp(text, "abc") == 0, "Check output, expected: \"abc\", got: \"%s\"", text);
  370. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  371. expected_result = 1;
  372. text[0] = '\0';
  373. result = SDL_sscanf("abc,def", "%[a-z]", text);
  374. SDLTest_AssertPass("Call to SDL_sscanf(\"abc,def\", \"%%[z-a]\", text)");
  375. SDLTest_AssertCheck(SDL_strcmp(text, "abc") == 0, "Check output, expected: \"abc\", got: \"%s\"", text);
  376. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  377. expected_result = 1;
  378. text[0] = '\0';
  379. result = SDL_sscanf("abc,def", "%[^,]", text);
  380. SDLTest_AssertPass("Call to SDL_sscanf(\"abc,def\", \"%%[^,]\", text)");
  381. SDLTest_AssertCheck(SDL_strcmp(text, "abc") == 0, "Check output, expected: \"abc\", got: \"%s\"", text);
  382. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  383. expected_result = 0;
  384. text[0] = '\0';
  385. result = SDL_sscanf("abc,def", "%[A-Z]", text);
  386. SDLTest_AssertPass("Call to SDL_sscanf(\"abc,def\", \"%%[A-Z]\", text)");
  387. SDLTest_AssertCheck(SDL_strcmp(text, "") == 0, "Check output, expected: \"\", got: \"%s\"", text);
  388. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  389. expected_result = 2;
  390. text[0] = '\0';
  391. text2[0] = '\0';
  392. result = SDL_sscanf("abc,def", "%[abc],%[def]", text, text2);
  393. SDLTest_AssertPass("Call to SDL_sscanf(\"abc,def\", \"%%[abc],%%[def]\", text)");
  394. SDLTest_AssertCheck(SDL_strcmp(text, "abc") == 0, "Check output, expected: \"abc\", got: \"%s\"", text);
  395. SDLTest_AssertCheck(SDL_strcmp(text2, "def") == 0, "Check output, expected: \"def\", got: \"%s\"", text2);
  396. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  397. expected_result = 2;
  398. text[0] = '\0';
  399. text2[0] = '\0';
  400. result = SDL_sscanf("abc,def", "%[abc]%*[,]%[def]", text, text2);
  401. SDLTest_AssertPass("Call to SDL_sscanf(\"abc,def\", \"%%[abc]%%*[,]%%[def]\", text)");
  402. SDLTest_AssertCheck(SDL_strcmp(text, "abc") == 0, "Check output, expected: \"abc\", got: \"%s\"", text);
  403. SDLTest_AssertCheck(SDL_strcmp(text2, "def") == 0, "Check output, expected: \"def\", got: \"%s\"", text2);
  404. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  405. expected_result = 2;
  406. text[0] = '\0';
  407. text2[0] = '\0';
  408. result = SDL_sscanf("abc def", "%[abc] %[def]", text, text2);
  409. SDLTest_AssertPass("Call to SDL_sscanf(\"abc def\", \"%%[abc] %%[def]\", text)");
  410. SDLTest_AssertCheck(SDL_strcmp(text, "abc") == 0, "Check output, expected: \"abc\", got: \"%s\"", text);
  411. SDLTest_AssertCheck(SDL_strcmp(text2, "def") == 0, "Check output, expected: \"def\", got: \"%s\"", text2);
  412. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  413. expected_result = 1;
  414. text[0] = '\0';
  415. result = SDL_sscanf("abc123XYZ", "%[a-zA-Z0-9]", text);
  416. SDLTest_AssertPass("Call to SDL_sscanf(\"abc123XYZ\", \"%%[a-zA-Z0-9]\", text)");
  417. SDLTest_AssertCheck(SDL_strcmp(text, "abc123XYZ") == 0, "Check output, expected: \"abc123XYZ\", got: \"%s\"", text);
  418. SDLTest_AssertCheck(expected_result == result, "Check return value, expected: %i, got: %i", expected_result, result);
  419. return TEST_COMPLETED;
  420. }
  421. #if defined(HAVE_WFORMAT) || defined(HAVE_WFORMAT_EXTRA_ARGS)
  422. #pragma GCC diagnostic pop
  423. #endif
  424. #if defined(_WIN64)
  425. #define SIZE_FORMAT "I64u"
  426. #elif defined(__WIN32__)
  427. #define SIZE_FORMAT "I32u"
  428. #else
  429. #define SIZE_FORMAT "zu"
  430. #endif
  431. typedef struct
  432. {
  433. size_t a;
  434. size_t b;
  435. size_t result;
  436. int status;
  437. } overflow_test;
  438. static const overflow_test multiplications[] = {
  439. { 1, 1, 1, 0 },
  440. { 0, 0, 0, 0 },
  441. { SDL_SIZE_MAX, 0, 0, 0 },
  442. { SDL_SIZE_MAX, 1, SDL_SIZE_MAX, 0 },
  443. { SDL_SIZE_MAX / 2, 2, SDL_SIZE_MAX - (SDL_SIZE_MAX % 2), 0 },
  444. { SDL_SIZE_MAX / 23, 23, SDL_SIZE_MAX - (SDL_SIZE_MAX % 23), 0 },
  445. { (SDL_SIZE_MAX / 2) + 1, 2, 0, -1 },
  446. { (SDL_SIZE_MAX / 23) + 42, 23, 0, -1 },
  447. { SDL_SIZE_MAX, SDL_SIZE_MAX, 0, -1 },
  448. };
  449. static const overflow_test additions[] = {
  450. { 1, 1, 2, 0 },
  451. { 0, 0, 0, 0 },
  452. { SDL_SIZE_MAX, 0, SDL_SIZE_MAX, 0 },
  453. { SDL_SIZE_MAX - 1, 1, SDL_SIZE_MAX, 0 },
  454. { SDL_SIZE_MAX - 42, 23, SDL_SIZE_MAX - (42 - 23), 0 },
  455. { SDL_SIZE_MAX, 1, 0, -1 },
  456. { SDL_SIZE_MAX, 23, 0, -1 },
  457. { SDL_SIZE_MAX, SDL_SIZE_MAX, 0, -1 },
  458. };
  459. static int
  460. stdlib_overflow(void *arg)
  461. {
  462. size_t i;
  463. size_t useBuiltin;
  464. for (useBuiltin = 0; useBuiltin < 2; useBuiltin++) {
  465. if (useBuiltin) {
  466. SDLTest_Log("Using gcc/clang builtins if possible");
  467. } else {
  468. SDLTest_Log("Not using gcc/clang builtins");
  469. }
  470. for (i = 0; i < SDL_arraysize(multiplications); i++) {
  471. const overflow_test *t = &multiplications[i];
  472. int status;
  473. size_t result = ~t->result;
  474. if (useBuiltin) {
  475. status = SDL_size_mul_overflow(t->a, t->b, &result);
  476. } else {
  477. /* This disables the macro that tries to use a gcc/clang
  478. * builtin, so we test the fallback implementation instead. */
  479. status = (SDL_size_mul_overflow)(t->a, t->b, &result);
  480. }
  481. if (t->status == 0) {
  482. SDLTest_AssertCheck(status == 0,
  483. "(%" SIZE_FORMAT " * %" SIZE_FORMAT ") should succeed",
  484. t->a, t->b);
  485. SDLTest_AssertCheck(result == t->result,
  486. "(%" SIZE_FORMAT " * %" SIZE_FORMAT "): expected %" SIZE_FORMAT ", got %" SIZE_FORMAT,
  487. t->a, t->b, t->result, result);
  488. } else {
  489. SDLTest_AssertCheck(status == -1,
  490. "(%" SIZE_FORMAT " * %" SIZE_FORMAT ") should fail",
  491. t->a, t->b);
  492. }
  493. if (t->a == t->b) {
  494. continue;
  495. }
  496. result = ~t->result;
  497. if (useBuiltin) {
  498. status = SDL_size_mul_overflow(t->b, t->a, &result);
  499. } else {
  500. status = (SDL_size_mul_overflow)(t->b, t->a, &result);
  501. }
  502. if (t->status == 0) {
  503. SDLTest_AssertCheck(status == 0,
  504. "(%" SIZE_FORMAT " * %" SIZE_FORMAT ") should succeed",
  505. t->b, t->a);
  506. SDLTest_AssertCheck(result == t->result,
  507. "(%" SIZE_FORMAT " * %" SIZE_FORMAT "): expected %" SIZE_FORMAT ", got %" SIZE_FORMAT,
  508. t->b, t->a, t->result, result);
  509. } else {
  510. SDLTest_AssertCheck(status == -1,
  511. "(%" SIZE_FORMAT " * %" SIZE_FORMAT ") should fail",
  512. t->b, t->a);
  513. }
  514. }
  515. for (i = 0; i < SDL_arraysize(additions); i++) {
  516. const overflow_test *t = &additions[i];
  517. int status;
  518. size_t result = ~t->result;
  519. if (useBuiltin) {
  520. status = SDL_size_add_overflow(t->a, t->b, &result);
  521. } else {
  522. status = (SDL_size_add_overflow)(t->a, t->b, &result);
  523. }
  524. if (t->status == 0) {
  525. SDLTest_AssertCheck(status == 0,
  526. "(%" SIZE_FORMAT " + %" SIZE_FORMAT ") should succeed",
  527. t->a, t->b);
  528. SDLTest_AssertCheck(result == t->result,
  529. "(%" SIZE_FORMAT " + %" SIZE_FORMAT "): expected %" SIZE_FORMAT ", got %" SIZE_FORMAT,
  530. t->a, t->b, t->result, result);
  531. } else {
  532. SDLTest_AssertCheck(status == -1,
  533. "(%" SIZE_FORMAT " + %" SIZE_FORMAT ") should fail",
  534. t->a, t->b);
  535. }
  536. if (t->a == t->b) {
  537. continue;
  538. }
  539. result = ~t->result;
  540. if (useBuiltin) {
  541. status = SDL_size_add_overflow(t->b, t->a, &result);
  542. } else {
  543. status = (SDL_size_add_overflow)(t->b, t->a, &result);
  544. }
  545. if (t->status == 0) {
  546. SDLTest_AssertCheck(status == 0,
  547. "(%" SIZE_FORMAT " + %" SIZE_FORMAT ") should succeed",
  548. t->b, t->a);
  549. SDLTest_AssertCheck(result == t->result,
  550. "(%" SIZE_FORMAT " + %" SIZE_FORMAT "): expected %" SIZE_FORMAT ", got %" SIZE_FORMAT,
  551. t->b, t->a, t->result, result);
  552. } else {
  553. SDLTest_AssertCheck(status == -1,
  554. "(%" SIZE_FORMAT " + %" SIZE_FORMAT ") should fail",
  555. t->b, t->a);
  556. }
  557. }
  558. }
  559. return TEST_COMPLETED;
  560. }
  561. /* ================= Test References ================== */
  562. /* Standard C routine test cases */
  563. static const SDLTest_TestCaseReference stdlibTest1 = {
  564. (SDLTest_TestCaseFp)stdlib_strlcpy, "stdlib_strlcpy", "Call to SDL_strlcpy", TEST_ENABLED
  565. };
  566. static const SDLTest_TestCaseReference stdlibTest2 = {
  567. (SDLTest_TestCaseFp)stdlib_snprintf, "stdlib_snprintf", "Call to SDL_snprintf", TEST_ENABLED
  568. };
  569. static const SDLTest_TestCaseReference stdlibTest3 = {
  570. (SDLTest_TestCaseFp)stdlib_getsetenv, "stdlib_getsetenv", "Call to SDL_getenv and SDL_setenv", TEST_ENABLED
  571. };
  572. static const SDLTest_TestCaseReference stdlibTest4 = {
  573. (SDLTest_TestCaseFp)stdlib_sscanf, "stdlib_sscanf", "Call to SDL_sscanf", TEST_ENABLED
  574. };
  575. static const SDLTest_TestCaseReference stdlibTestOverflow = {
  576. stdlib_overflow, "stdlib_overflow", "Overflow detection", TEST_ENABLED
  577. };
  578. /* Sequence of Standard C routine test cases */
  579. static const SDLTest_TestCaseReference *stdlibTests[] = {
  580. &stdlibTest1,
  581. &stdlibTest2,
  582. &stdlibTest3,
  583. &stdlibTest4,
  584. &stdlibTestOverflow,
  585. NULL
  586. };
  587. /* Standard C routine test suite (global) */
  588. SDLTest_TestSuiteReference stdlibTestSuite = {
  589. "Stdlib",
  590. NULL,
  591. stdlibTests,
  592. NULL
  593. };