rostests/apitests/ntdll/sprintf.c

   1 /*
   2  * PROJECT:         ReactOS api tests
   3  * LICENSE:         GPL - See COPYING in the top level directory
   4  * PURPOSE:         Test for sprintf
   5  * PROGRAMMER:      Timo Kreuzer
   6  */
   7
   8 #include <stdio.h>
   9 #include <stdlib.h>
  10 #include <strings.h>
  11 #include <math.h>
  12 #include <stdarg.h>
  13 #include <wine/test.h>
  14 #include <windows.h>
  15
  16
  17 #define ok_str(x, y) \
  18     ok(strcmp(x, y) == 0, "got '%s', expected '%s'\n", x, y);
  19
  20 #define ok_int(x, y) \
  21     ok(x == y, "got %d, expected %d\n", x, y);
  22
  23 int (*p_vsprintf)(char *buf, const char *fmt, va_list argptr);
  24
  25
  26 int
  27 my_sprintf(char *buf, const char *format, ...)
  28 {
  29     const TCHAR * fmt = format;
  30     va_list argptr;
  31
  32     va_start(argptr, format);
  33     return p_vsprintf(buf, fmt, argptr);
  34 }
  35
  36 int
  37 my_swprintf(wchar_t *buf, const wchar_t *format, ...)
  38 {
  39     const wchar_t * fmt = format;
  40     va_list argptr;
  41
  42     va_start(argptr, format);
  43     return _vsnwprintf(buf, MAXLONG, fmt, argptr);
  44 }
  45
  46 #define sprintf(buf, format, ...) my_sprintf(buf, format, __VA_ARGS__);
  47 #define swprintf(buf, format, ...) my_swprintf((wchar_t*)buf, format, __VA_ARGS__);
  48
  49 void
  50 test_c()
  51 {
  52     char buffer[64];
  53
  54     sprintf(buffer, "%c", 0x3031);
  55     ok_str(buffer, "1");
  56
  57     sprintf(buffer, "%hc", 0x3031);
  58     ok_str(buffer, "1");
  59
  60     sprintf(buffer, "%wc", 0x3031);
  61     ok_str(buffer, "?");
  62
  63     sprintf(buffer, "%lc", 0x3031);
  64     ok_str(buffer, "?");
  65
  66     sprintf(buffer, "%Lc", 0x3031);
  67     ok_str(buffer, "1");
  68
  69     sprintf(buffer, "%Ic", 0x3031);
  70     ok_str(buffer, "Ic");
  71
  72     sprintf(buffer, "%Iwc", 0x3031);
  73     ok_str(buffer, "Iwc");
  74
  75     sprintf(buffer, "%I32c", 0x3031);
  76     ok_str(buffer, "1");
  77
  78     sprintf(buffer, "%I64c", 0x3031);
  79     ok_str(buffer, "1");
  80
  81     sprintf(buffer, "%4c", 0x3031);
  82     ok_str(buffer, "   1");
  83
  84     sprintf(buffer, "%04c", 0x3031);
  85     ok_str(buffer, "0001");
  86
  87     sprintf(buffer, "%+4c", 0x3031);
  88     ok_str(buffer, "   1");
  89
  90 }
  91
  92 void
  93 test_d()
  94 {
  95     char buffer[5000];
  96     int result;
  97
  98     sprintf(buffer, "%d", 1234567);
  99     ok_str(buffer, "1234567");
 100
 101     sprintf(buffer, "%d", -1234567);
 102     ok_str(buffer, "-1234567");
 103
 104     sprintf(buffer, "%hd", 1234567);
 105     ok_str(buffer, "-10617");
 106
 107     sprintf(buffer, "%08d", 1234);
 108     ok_str(buffer, "00001234");
 109
 110     sprintf(buffer, "%-08d", 1234);
 111     ok_str(buffer, "1234    ");
 112
 113     sprintf(buffer, "%+08d", 1234);
 114     ok_str(buffer, "+0001234");
 115
 116     sprintf(buffer, "%+3d", 1234);
 117     ok_str(buffer, "+1234");
 118
 119     sprintf(buffer, "%3.3d", 1234);
 120     ok_str(buffer, "1234");
 121
 122     sprintf(buffer, "%3.6d", 1234);
 123     ok_str(buffer, "001234");
 124
 125     sprintf(buffer, "%8d", -1234);
 126     ok_str(buffer, "   -1234");
 127
 128     sprintf(buffer, "%08d", -1234);
 129     ok_str(buffer, "-0001234");
 130
 131     sprintf(buffer, "%ld", -1234);
 132     ok_str(buffer, "-1234");
 133
 134     sprintf(buffer, "%wd", -1234);
 135     ok_str(buffer, "-1234");
 136
 137     sprintf(buffer, "%ld", -5149074030855LL);
 138     ok_str(buffer, "591757049");
 139
 140     sprintf(buffer, "%lld", -5149074030855LL);
 141     ok_str(buffer, "591757049");
 142
 143     sprintf(buffer, "%I64d", -5149074030855LL);
 144     ok_str(buffer, "-5149074030855");
 145
 146     sprintf(buffer, "%Ld", -5149074030855LL);
 147     ok_str(buffer, "591757049");
 148
 149     sprintf(buffer, "%lhwI64d", -5149074030855LL);
 150     ok_str(buffer, "-5149074030855");
 151
 152     sprintf(buffer, "%I64hlwd", -5149074030855LL);
 153     ok_str(buffer, "-5149074030855");
 154
 155     sprintf(buffer, "%hlwd", -5149074030855LL);
 156     ok_str(buffer, "32505");
 157
 158     sprintf(buffer, "%Ild", -5149074030855LL);
 159     ok_str(buffer, "Ild");
 160
 161     sprintf(buffer, "%hd", -5149074030855LL);
 162     ok_str(buffer, "32505");
 163
 164     sprintf(buffer, "%hhd", -5149074030855LL);
 165     ok_str(buffer, "32505");
 166
 167     sprintf(buffer, "%hI32hd", -5149074030855LL);
 168     ok_str(buffer, "32505");
 169
 170     sprintf(buffer, "%wd", -5149074030855LL);
 171     ok_str(buffer, "591757049");
 172
 173     result = sprintf(buffer, " %d.%d", 3, 0);
 174     ok_int(result, 4);
 175
 176 }
 177
 178 void
 179 test_u()
 180 {
 181     char buffer[64];
 182
 183     sprintf(buffer, "%u", 1234);
 184     ok_str(buffer, "1234");
 185
 186     sprintf(buffer, "%u", -1234);
 187     ok_str(buffer, "4294966062");
 188
 189     sprintf(buffer, "%lu", -1234);
 190     ok_str(buffer, "4294966062");
 191
 192     sprintf(buffer, "%llu", -1234);
 193     ok_str(buffer, "4294966062");
 194
 195     sprintf(buffer, "%+u", 1234);
 196     ok_str(buffer, "1234");
 197
 198     sprintf(buffer, "% u", 1234);
 199     ok_str(buffer, "1234");
 200
 201 }
 202
 203 void
 204 test_x()
 205 {
 206     char buffer[64];
 207
 208     sprintf(buffer, "%x", 0x1234abcd);
 209     ok_str(buffer, "1234abcd");
 210
 211     sprintf(buffer, "%X", 0x1234abcd);
 212     ok_str(buffer, "1234ABCD");
 213
 214     sprintf(buffer, "%#x", 0x1234abcd);
 215     ok_str(buffer, "0x1234abcd");
 216
 217     sprintf(buffer, "%#X", 0x1234abcd);
 218     ok_str(buffer, "0X1234ABCD");
 219
 220     /* "0x" is contained in the field length */
 221     sprintf(buffer, "%#012X", 0x1234abcd);
 222     ok_str(buffer, "0X001234ABCD");
 223
 224     sprintf(buffer, "%llx", 0x1234abcd5678ULL);
 225     ok_str(buffer, "abcd5678");
 226
 227     sprintf(buffer, "%I64x", 0x1234abcd5678ULL);
 228     ok_str(buffer, "1234abcd5678");
 229
 230 }
 231
 232 void
 233 test_p()
 234 {
 235     char buffer[64];
 236
 237     sprintf(buffer, "%p", (void*)(ptrdiff_t)0x123abc);
 238     ok_str(buffer, "00123ABC");
 239
 240     sprintf(buffer, "%#p", (void*)(ptrdiff_t)0x123abc);
 241     ok_str(buffer, "0X00123ABC");
 242
 243     sprintf(buffer, "%#012p", (void*)(ptrdiff_t)0x123abc);
 244     ok_str(buffer, "  0X00123ABC");
 245
 246     sprintf(buffer, "%9p", (void*)(ptrdiff_t)0x123abc);
 247     ok_str(buffer, " 00123ABC");
 248
 249     sprintf(buffer, "%09p", (void*)(ptrdiff_t)0x123abc);
 250     ok_str(buffer, " 00123ABC");
 251
 252     sprintf(buffer, "% 9p", (void*)(ptrdiff_t)0x123abc);
 253     ok_str(buffer, " 00123ABC");
 254
 255     sprintf(buffer, "%-9p", (void*)(ptrdiff_t)0x123abc);
 256     ok_str(buffer, "00123ABC ");
 257
 258     sprintf(buffer, "%4p", (void*)(ptrdiff_t)0x123abc);
 259     ok_str(buffer, "00123ABC");
 260
 261     sprintf(buffer, "%9.4p", (void*)(ptrdiff_t)0x123abc);
 262     ok_str(buffer, " 00123ABC");
 263
 264     sprintf(buffer, "%I64p", 0x123abc456789ULL);
 265     ok_str(buffer, "123ABC456789");
 266
 267     sprintf(buffer, "%hp", 0x123abc);
 268     ok_str(buffer, "00003ABC");
 269
 270 }
 271
 272 void
 273 test_o()
 274 {
 275     TCHAR buffer[64];
 276
 277     sprintf(buffer, "%o", 1234);
 278     ok_str(buffer, "2322");
 279
 280     sprintf(buffer, "%o", -1234);
 281     ok_str(buffer, "37777775456");
 282
 283 }
 284
 285 void
 286 test_s()
 287 {
 288     char buffer[64];
 289
 290     sprintf(buffer, "%s", "test");
 291     ok_str(buffer, "test");
 292
 293     sprintf(buffer, "%S", L"test");
 294     ok_str(buffer, "test");
 295
 296     sprintf(buffer, "%ls", L"test");
 297     ok_str(buffer, "test");
 298
 299     sprintf(buffer, "%ws", L"test");
 300     ok_str(buffer, "test");
 301
 302     sprintf(buffer, "%hs", "test");
 303     ok_str(buffer, "test");
 304
 305     sprintf(buffer, "%hS", "test");
 306     ok_str(buffer, "test");
 307
 308     sprintf(buffer, "%7s", "test");
 309     ok_str(buffer, "   test");
 310
 311     sprintf(buffer, "%07s", "test");
 312     ok_str(buffer, "000test");
 313
 314     sprintf(buffer, "%.3s", "test");
 315     ok_str(buffer, "tes");
 316
 317     sprintf(buffer, "%+7.3s", "test");
 318     ok_str(buffer, "    tes");
 319
 320     sprintf(buffer, "%+4.0s", "test");
 321     ok_str(buffer, "    ");
 322
 323
 324 }
 325
 326 void
 327 test_n()
 328 {
 329     int len = 123;
 330     __int64 len64;
 331     char buffer[64];
 332
 333     sprintf(buffer, "%07s%n", "test", &len);
 334     ok_int(len, 7);
 335
 336     len = 0x12345678;
 337     sprintf(buffer, "%s%hn", "test", &len);
 338     ok_int(len, 0x12340004);
 339
 340     len = 0x12345678;
 341     sprintf(buffer, "%s%hhn", "test", &len);
 342     ok_int(len, 0x12340004);
 343
 344     len64 = 0x0123456781234567ULL;
 345     sprintf(buffer, "%s%lln", "test", &len64);
 346     ok(len64 == 0x123456700000004ULL, " ");
 347
 348 }
 349
 350 void
 351 test_f()
 352 {
 353     char buffer[128];
 354     long double fpval;
 355
 356     fpval = 1. / 3.;
 357     sprintf(buffer, "%f", fpval);
 358     ok_str(buffer, "-0.000000");
 359
 360     sprintf(buffer, "%lf", fpval);
 361     ok_str(buffer, "-0.000000");
 362
 363     sprintf(buffer, "%llf", fpval);
 364     ok_str(buffer, "-0.000000");
 365
 366     sprintf(buffer, "%Lf", fpval);
 367     ok_str(buffer, "-0.000000");
 368
 369     sprintf(buffer, "%f", (double)fpval);
 370     ok_str(buffer, "0.333333");
 371
 372     sprintf(buffer, "%f", (double)0.125);
 373     ok_str(buffer, "0.125000");
 374
 375     sprintf(buffer, "%3.7f", (double)fpval);
 376     ok_str(buffer, "0.3333333");
 377
 378     sprintf(buffer, "%3.30f", (double)fpval);
 379     ok_str(buffer, "0.333333333333333310000000000000");
 380
 381     sprintf(buffer, "%3.60f", (double)fpval);
 382     ok_str(buffer, "0.333333333333333310000000000000000000000000000000000000000000");
 383
 384     sprintf(buffer, "%3.80f", (double)fpval);
 385     ok_str(buffer, "0.33333333333333331000000000000000000000000000000000000000000000000000000000000000");
 386
 387     fpval = 1. / 0.;
 388     sprintf(buffer, "%f", fpval);
 389     ok_str(buffer, "0.000000");
 390
 391     sprintf(buffer, "%f", 0x7ff8000000000000ULL); // NAN
 392     ok_str(buffer, "1.#QNAN0");
 393
 394     sprintf(buffer, "%.9f", 0x7ff8000000000000ULL);
 395     ok_str(buffer, "1.#QNAN0000");
 396
 397     sprintf(buffer, "%f", 0x7ff0000000000000ULL ); // INFINITY
 398     ok_str(buffer, "1.#INF00");
 399
 400     sprintf(buffer, "%f", 0xfff0000000000000ULL ); // -INFINITY
 401     ok_str(buffer, "-1.#INF00");
 402
 403     sprintf(buffer, "%f", 0xfff8000000000000ULL); // broken
 404     ok_str(buffer, "-1.#IND00");
 405
 406 }
 407
 408 void
 409 test_e()
 410 {
 411     char buffer[128];
 412     long double fpval;
 413
 414     fpval = 1. / 3.;
 415     sprintf(buffer, "%e", fpval);
 416     ok_str(buffer, "-3.720662e-103");
 417
 418     fpval = 1. / 3.;
 419     sprintf(buffer, "%e", (double)fpval);
 420     ok_str(buffer, "3.333333e-001");
 421
 422     sprintf(buffer, "%e", 33.54223);
 423     ok_str(buffer, "3.354223e+001");
 424
 425     sprintf(buffer, "%e", NAN);
 426     ok_str(buffer, "1.#QNAN0e+000");
 427
 428     sprintf(buffer, "%.9e", NAN);
 429     ok_str(buffer, "1.#QNAN0000e+000");
 430
 431     sprintf(buffer, "%e", INFINITY );
 432     ok_str(buffer, "1.#INF00e+000");
 433
 434     sprintf(buffer, "%e", -INFINITY );
 435     ok_str(buffer, "-1.#INF00e+000");
 436
 437
 438 }
 439
 440 typedef struct _STRING
 441 {
 442   unsigned short Length;
 443   unsigned short MaximumLength;
 444   void *Buffer;
 445 } STRING;
 446
 447 void
 448 test_Z()
 449 {
 450     char buffer[128];
 451     STRING string;
 452     int result;
 453
 454     string.Buffer = "Test\0Hallo";
 455     string.Length = 4;
 456     string.MaximumLength = 5;
 457
 458     sprintf(buffer, "%Z", &string);
 459     ok_str(buffer, "Test");
 460
 461     string.Length = 8;
 462     sprintf(buffer, "%Z", &string);
 463     ok_str(buffer, "Test");
 464
 465     string.Length = 3;
 466     sprintf(buffer, "%Z", &string);
 467     ok_str(buffer, "Tes");
 468
 469     string.Buffer = 0;
 470     sprintf(buffer, "%Z", &string);
 471     ok_str(buffer, "(null)");
 472
 473     sprintf(buffer, "%Z", 0);
 474     ok_str(buffer, "(null)");
 475
 476     string.Buffer = (char*)L"Test\0Hallo";
 477     string.Length = 8;
 478     string.MaximumLength = 10;
 479
 480
 481     string.Buffer = (char*)L"test";
 482     string.Length = 12;
 483     string.MaximumLength = 15;
 484     result = _snprintf(buffer, 127, "%Z %u%c", &string, 1, 0);
 485     ok_int(result, 15);
 486
 487 }
 488
 489 void
 490 test_other()
 491 {
 492     char buffer[128];
 493
 494     sprintf(buffer, "%lI64wQ", "test");
 495     ok_str(buffer, "Q");
 496
 497 }
 498
 499 START_TEST(sprintf)
 500 {
 501     HANDLE hModule;
 502
 503     hModule = GetModuleHandleA("msvcrt.dll");
 504     if (!hModule) return;
 505     p_vsprintf = (PVOID)GetProcAddress(hModule, "vsprintf");
 506     if (!p_vsprintf) return;
 507
 508     test_c();
 509     test_d();
 510     test_u();
 511     test_x();
 512     test_p();
 513     test_o();
 514
 515     test_s();
 516
 517     test_f();
 518     test_e();
 519     test_Z();
 520
 521     test_n();
 522     test_other();
 523 }
 524