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