ReactOS 0.4.16-dev-942-g91fadeb
Macros | Functions
printf.c File Reference
#include <stdio.h>
#include <errno.h>
#include <math.h>
#include <inttypes.h>
#include "windef.h"
#include "winbase.h"
#include "winnls.h"
#include "wine/test.h"
Include dependency graph for printf.c:

Go to the source code of this file.

Macros

#define DEFINE_EXPECT(func)    static BOOL expect_ ## func = FALSE, called_ ## func = FALSE
 
#define SET_EXPECT(func)    expect_ ## func = TRUE
 
#define CHECK_EXPECT2(func)
 
#define CHECK_EXPECT(func)
 
#define CHECK_CALLED(func)
 
#define IND   __port_ind()
 

Functions

 DEFINE_EXPECT (invalid_parameter_handler)
 
static float __port_ind (void)
 
static void __cdecl test_invalid_parameter_handler (const wchar_t *expression, const wchar_t *function, const wchar_t *file, unsigned line, uintptr_t arg)
 
static int WINAPIV vsprintf_wrapper (unsigned __int64 options, char *str, size_t len, const char *format,...)
 
static void test_snprintf (void)
 
static int WINAPIV vswprintf_wrapper (unsigned __int64 options, wchar_t *str, size_t len, const wchar_t *format,...)
 
static void test_swprintf (void)
 
static int WINAPIV vfprintf_wrapper (FILE *file, const char *format,...)
 
static void test_fprintf (void)
 
static int WINAPIV vfwprintf_wrapper (FILE *file, const wchar_t *format,...)
 
static void test_fwprintf (void)
 
static int WINAPIV _vsnprintf_s_wrapper (char *str, size_t sizeOfBuffer, size_t count, const char *format,...)
 
static void test_vsnprintf_s (void)
 
static int WINAPIV _vsnwprintf_s_wrapper (WCHAR *str, size_t sizeOfBuffer, size_t count, const WCHAR *format,...)
 
static void test_vsnwprintf_s (void)
 
static void test_printf_legacy_wide (void)
 
static void test_printf_legacy_msvcrt (void)
 
static void test_printf_legacy_three_digit_exp (void)
 
static void test_printf_c99 (void)
 
static void test_printf_natural_string (void)
 
static void test_printf_fp (void)
 
static void test_printf_width_specification (void)
 
 START_TEST (printf)
 

Macro Definition Documentation

◆ CHECK_CALLED

#define CHECK_CALLED (   func)
Value:
do { \
ok(called_ ## func, "expected " #func "\n"); \
expect_ ## func = called_ ## func = FALSE; \
}while(0)
FALSE
#define FALSE
Definition: types.h:117
func
GLenum func
Definition: glext.h:6028
expect_
#define expect_(expected, got, precision)
Definition: font.c:29

Definition at line 53 of file printf.c.

◆ CHECK_EXPECT

#define CHECK_EXPECT (   func)
Value:
do { \
CHECK_EXPECT2(func); \
expect_ ## func = FALSE; \
}while(0)

Definition at line 47 of file printf.c.

◆ CHECK_EXPECT2

#define CHECK_EXPECT2 (   func)
Value:
do { \
ok(expect_ ##func, "unexpected call " #func "\n"); \
called_ ## func = TRUE; \
}while(0)
TRUE
#define TRUE
Definition: types.h:120

Definition at line 41 of file printf.c.

◆ DEFINE_EXPECT

#define DEFINE_EXPECT (   func)     static BOOL expect_ ## func = FALSE, called_ ## func = FALSE

Definition at line 35 of file printf.c.

◆ IND

#define IND   __port_ind()

Definition at line 66 of file printf.c.

◆ SET_EXPECT

#define SET_EXPECT (   func)     expect_ ## func = TRUE

Definition at line 38 of file printf.c.

Function Documentation

◆ __port_ind()

static float __port_ind ( void  )
inlinestatic

Definition at line 61 of file printf.c.

62{
63 static const unsigned __ind_bytes = 0xffc00000;
64 return *(const float *)&__ind_bytes;
65}

◆ _vsnprintf_s_wrapper()

static int WINAPIV _vsnprintf_s_wrapper ( char *  str,
size_t  sizeOfBuffer,
size_t  count,
const char *  format,
  ... 
)
static

Definition at line 428 of file printf.c.

430{
431 int ret;
432 va_list valist;
433 va_start(valist, format);
434 ret = __stdio_common_vsnprintf_s(0, str, sizeOfBuffer, count, format, NULL, valist);
435 va_end(valist);
436 return ret;
437}
va_list
char * va_list
Definition: acmsvcex.h:78
va_end
#define va_end(ap)
Definition: acmsvcex.h:90
va_start
#define va_start(ap, A)
Definition: acmsvcex.h:91
NULL
#define NULL
Definition: types.h:112
count
GLuint GLuint GLsizei count
Definition: gl.h:1545
valist
static va_list valist
Definition: printf.c:46
sizeOfBuffer
static size_t sizeOfBuffer
Definition: printf.c:48
__stdio_common_vsnprintf_s
int __cdecl __stdio_common_vsnprintf_s(unsigned __int64 const options, char *const buffer, size_t const buffer_count, size_t const max_count, char const *const format, _locale_t const locale, va_list const arglist)
Definition: output.cpp:393
str
const WCHAR * str
Definition: rpc_transport.c:2724
format
Definition: format.c:58
ret
int ret
Definition: wcstombs-tests.c:31

Referenced by test_vsnprintf_s().

◆ _vsnwprintf_s_wrapper()

static int WINAPIV _vsnwprintf_s_wrapper ( WCHAR *  str,
size_t  sizeOfBuffer,
size_t  count,
const WCHAR *  format,
  ... 
)
static

Definition at line 480 of file printf.c.

482{
483 int ret;
484 va_list valist;
485 va_start(valist, format);
486 ret = __stdio_common_vsnwprintf_s(0, str, sizeOfBuffer, count, format, NULL, valist);
487 va_end(valist);
488 return ret;
489}
__stdio_common_vsnwprintf_s
int __cdecl __stdio_common_vsnwprintf_s(unsigned __int64 const options, wchar_t *const buffer, size_t const buffer_count, size_t const max_count, wchar_t const *const format, _locale_t const locale, va_list const arglist)
Definition: output.cpp:407

◆ DEFINE_EXPECT()

DEFINE_EXPECT ( invalid_parameter_handler  )

◆ START_TEST()

START_TEST ( printf  )

Definition at line 885 of file printf.c.

886{
887 ok(_set_invalid_parameter_handler(test_invalid_parameter_handler) == NULL,
888 "Invalid parameter handler was already set\n");
889
890 test_snprintf();
891 test_swprintf();
892 test_fprintf();
893 test_fwprintf();
894 test_vsnprintf_s();
895 test_vsnwprintf_s();
896 test_printf_legacy_wide();
897 test_printf_legacy_msvcrt();
898 test_printf_legacy_three_digit_exp();
899 test_printf_c99();
900 test_printf_natural_string();
901 test_printf_fp();
902 test_printf_width_specification();
903}
ok
#define ok(value,...)
Definition: atltest.h:57
_set_invalid_parameter_handler
_invalid_parameter_handler __cdecl _set_invalid_parameter_handler(_In_opt_ _invalid_parameter_handler _Handler)
test_vsnwprintf_s
static void test_vsnwprintf_s(void)
Definition: printf.c:1019
test_swprintf
static void test_swprintf(void)
Definition: printf.c:431
test_fprintf
static void test_fprintf(void)
Definition: printf.c:477
test_snprintf
static void test_snprintf(void)
Definition: printf.c:447
test_invalid_parameter_handler
static void test_invalid_parameter_handler(void)
Definition: misc.c:384
test_printf_fp
static void test_printf_fp(void)
Definition: printf.c:651
test_vsnprintf_s
static void test_vsnprintf_s(void)
Definition: printf.c:439
test_printf_c99
static void test_printf_c99(void)
Definition: printf.c:598
test_printf_natural_string
static void test_printf_natural_string(void)
Definition: printf.c:633
test_printf_legacy_wide
static void test_printf_legacy_wide(void)
Definition: printf.c:532
test_printf_legacy_three_digit_exp
static void test_printf_legacy_three_digit_exp(void)
Definition: printf.c:586
test_printf_legacy_msvcrt
static void test_printf_legacy_msvcrt(void)
Definition: printf.c:560
test_printf_width_specification
static void test_printf_width_specification(void)
Definition: printf.c:867
test_fwprintf
static void test_fwprintf(void)
Definition: printf.c:342

◆ test_fprintf()

static void test_fprintf ( void  )
static

Definition at line 269 of file printf.c.

270{
271 static const char file_name[] = "fprintf.tst";
272
273 FILE *fp = fopen(file_name, "wb");
274 char buf[1024];
275 int ret;
276
277 ret = vfprintf_wrapper(fp, "simple test\n");
278 ok(ret == 12, "ret = %d\n", ret);
279 ret = ftell(fp);
280 ok(ret == 12, "ftell returned %d\n", ret);
281
282 ret = vfprintf_wrapper(fp, "contains%cnull\n", '\0');
283 ok(ret == 14, "ret = %d\n", ret);
284 ret = ftell(fp);
285 ok(ret == 26, "ftell returned %d\n", ret);
286
287 fclose(fp);
288
289 fp = fopen(file_name, "rb");
290 fgets(buf, sizeof(buf), fp);
291 ret = ftell(fp);
292 ok(ret == 12, "ftell returned %d\n", ret);
293 ok(!strcmp(buf, "simple test\n"), "buf = %s\n", buf);
294
295 fgets(buf, sizeof(buf), fp);
296 ret = ftell(fp);
297 ok(ret == 26, "ret = %d\n", ret);
298 ok(!memcmp(buf, "contains\0null\n", 14), "buf = %s\n", buf);
299
300 fclose(fp);
301
302 fp = fopen(file_name, "wt");
303
304 ret = vfprintf_wrapper(fp, "simple test\n");
305 ok(ret == 12, "ret = %d\n", ret);
306 ret = ftell(fp);
307 ok(ret == 13, "ftell returned %d\n", ret);
308
309 ret = vfprintf_wrapper(fp, "contains%cnull\n", '\0');
310 ok(ret == 14, "ret = %d\n", ret);
311 ret = ftell(fp);
312 ok(ret == 28, "ftell returned %d\n", ret);
313
314 fclose(fp);
315
316 fp = fopen(file_name, "rb");
317 fgets(buf, sizeof(buf), fp);
318 ret = ftell(fp);
319 ok(ret == 13, "ftell returned %d\n", ret);
320 ok(!strcmp(buf, "simple test\r\n"), "buf = %s\n", buf);
321
322 fgets(buf, sizeof(buf), fp);
323 ret = ftell(fp);
324 ok(ret == 28, "ret = %d\n", ret);
325 ok(!memcmp(buf, "contains\0null\r\n", 15), "buf = %s\n", buf);
326
327 fclose(fp);
328 unlink(file_name);
329}
strcmp
int strcmp(const char *String1, const char *String2)
Definition: utclib.c:469
memcmp
int memcmp(void *Buffer1, void *Buffer2, ACPI_SIZE Count)
Definition: utclib.c:112
buf
GLenum GLuint GLenum GLsizei const GLchar * buf
Definition: glext.h:7751
fopen
_Check_return_ _CRTIMP FILE *__cdecl fopen(_In_z_ const char *_Filename, _In_z_ const char *_Mode)
fgets
_Check_return_opt_ _CRTIMP char *__cdecl fgets(_Out_writes_z_(_MaxCount) char *_Buf, _In_ int _MaxCount, _Inout_ FILE *_File)
fclose
_Check_return_opt_ _CRTIMP int __cdecl fclose(_Inout_ FILE *_File)
ftell
_Check_return_ _CRTIMP long __cdecl ftell(_Inout_ FILE *_File)
unlink
#define unlink
Definition: syshdrs.h:54
vfprintf_wrapper
static int WINAPIV vfprintf_wrapper(FILE *file, const char *format,...)
Definition: printf.c:258
file_name
static LPCWSTR file_name
Definition: protocol.c:147
_iobuf
Definition: mbstring.h:19

◆ test_fwprintf()

static void test_fwprintf ( void  )
static

Definition at line 342 of file printf.c.

343{
344 static const char file_name[] = "fprintf.tst";
345 static const WCHAR simple[] = {'s','i','m','p','l','e',' ','t','e','s','t','\n',0};
346 static const WCHAR cont_fmt[] = {'c','o','n','t','a','i','n','s','%','c','n','u','l','l','\n',0};
347 static const WCHAR cont[] = {'c','o','n','t','a','i','n','s','\0','n','u','l','l','\n',0};
348
349 FILE *fp = fopen(file_name, "wb");
350 wchar_t bufw[1024];
351 char bufa[1024];
352 int ret;
353
354 ret = vfwprintf_wrapper(fp, simple);
355 ok(ret == 12, "ret = %d\n", ret);
356 ret = ftell(fp);
357 ok(ret == 24, "ftell returned %d\n", ret);
358
359 ret = vfwprintf_wrapper(fp, cont_fmt, '\0');
360 ok(ret == 14, "ret = %d\n", ret);
361 ret = ftell(fp);
362 ok(ret == 52, "ftell returned %d\n", ret);
363
364 fclose(fp);
365
366 fp = fopen(file_name, "rb");
367 fgetws(bufw, ARRAY_SIZE(bufw), fp);
368 ret = ftell(fp);
369 ok(ret == 24, "ftell returned %d\n", ret);
370 ok(!wcscmp(bufw, simple), "buf = %s\n", wine_dbgstr_w(bufw));
371
372 fgetws(bufw, ARRAY_SIZE(bufw), fp);
373 ret = ftell(fp);
374 ok(ret == 52, "ret = %d\n", ret);
375 ok(!memcmp(bufw, cont, 28), "buf = %s\n", wine_dbgstr_w(bufw));
376
377 fclose(fp);
378
379 fp = fopen(file_name, "wt");
380
381 ret = vfwprintf_wrapper(fp, simple);
382 ok(ret == 12, "ret = %d\n", ret);
383 ret = ftell(fp);
384 ok(ret == 13, "ftell returned %d\n", ret);
385
386 ret = vfwprintf_wrapper(fp, cont_fmt, '\0');
387 ok(ret == 14, "ret = %d\n", ret);
388 ret = ftell(fp);
389 ok(ret == 28, "ftell returned %d\n", ret);
390
391 fclose(fp);
392
393 fp = fopen(file_name, "rb");
394 fgets(bufa, sizeof(bufa), fp);
395 ret = ftell(fp);
396 ok(ret == 13, "ftell returned %d\n", ret);
397 ok(!strcmp(bufa, "simple test\r\n"), "buf = %s\n", bufa);
398
399 fgets(bufa, sizeof(bufa), fp);
400 ret = ftell(fp);
401 ok(ret == 28, "ret = %d\n", ret);
402 ok(!memcmp(bufa, "contains\0null\r\n", 15), "buf = %s\n", bufa);
403
404 fclose(fp);
405 unlink(file_name);
406
407 /* NULL format */
408 errno = 0xdeadbeef;
409 SET_EXPECT(invalid_parameter_handler);
410 ret = vfwprintf_wrapper(fp, NULL);
411 ok(errno == EINVAL, "expected errno EINVAL, got %d\n", errno);
412 ok(ret == -1, "expected ret -1, got %d\n", ret);
413 CHECK_CALLED(invalid_parameter_handler);
414
415 /* NULL file */
416 errno = 0xdeadbeef;
417 SET_EXPECT(invalid_parameter_handler);
418 ret = vfwprintf_wrapper(NULL, simple);
419 ok(errno == EINVAL, "expected errno EINVAL, got %d\n", errno);
420 ok(ret == -1, "expected ret -1, got %d\n", ret);
421 CHECK_CALLED(invalid_parameter_handler);
422
423 /* format using % with NULL arglist*/
424 /* crashes on Windows */
425 /* ret = __stdio_common_vfwprintf(0, fp, cont_fmt, NULL, NULL); */
426}
invalid_parameter_handler
static _invalid_parameter_handler invalid_parameter_handler
Definition: _invalid_parameter.c:17
EINVAL
#define EINVAL
Definition: acclib.h:90
ARRAY_SIZE
#define ARRAY_SIZE(A)
Definition: main.h:20
wine_dbgstr_w
#define wine_dbgstr_w
Definition: kernel32.h:34
SET_EXPECT
#define SET_EXPECT(func)
Definition: printf.c:38
vfwprintf_wrapper
static int WINAPIV vfwprintf_wrapper(FILE *file, const wchar_t *format,...)
Definition: printf.c:331
CHECK_CALLED
#define CHECK_CALLED(func)
Definition: printf.c:53
errno
#define errno
Definition: errno.h:18
wcscmp
_Check_return_ _CRTIMP int __cdecl wcscmp(_In_z_ const wchar_t *_Str1, _In_z_ const wchar_t *_Str2)
fgetws
wchar_t * fgetws(wchar_t *buf, int bufsize, FILE *file)
Definition: wmain.c:22
WCHAR
__wchar_t WCHAR
Definition: xmlstorage.h:180

Referenced by START_TEST().

◆ test_invalid_parameter_handler()

static void __cdecl test_invalid_parameter_handler ( const wchar_t *  expression,
const wchar_t *  function,
const wchar_t *  file,
unsigned  line,
uintptr_t  arg 
)
static

Definition at line 68 of file printf.c.

71{
72 CHECK_EXPECT(invalid_parameter_handler);
73 ok(expression == NULL, "expression is not NULL\n");
74 ok(function == NULL, "function is not NULL\n");
75 ok(file == NULL, "file is not NULL\n");
76 ok(line == 0, "line = %u\n", line);
77 ok(arg == 0, "arg = %Ix\n", arg);
78}
CHECK_EXPECT
#define CHECK_EXPECT(func)
Definition: printf.c:47
file
Definition: fci.c:127
line
Definition: parser.c:49

◆ test_printf_c99()

static void test_printf_c99 ( void  )
static

Definition at line 598 of file printf.c.

599{
600 char buf[30];
601 int i;
602
603 /* The msvcrt compatibility flag doesn't affect whether 'z' is interpreted
604 * as size_t size for integers. */
605 for (i = 0; i < 2; i++) {
606 unsigned __int64 options = (i == 0) ? 0 :
607 _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY;
608
609 /* z modifier accepts size_t argument */
610 vsprintf_wrapper(options, buf, sizeof(buf), "%zx %d", SIZE_MAX, 1);
611 if (sizeof(size_t) == 8)
612 ok(!strcmp(buf, "ffffffffffffffff 1"), "buf = %s\n", buf);
613 else
614 ok(!strcmp(buf, "ffffffff 1"), "buf = %s\n", buf);
615
616 /* j modifier with signed format accepts intmax_t argument */
617 vsprintf_wrapper(options, buf, sizeof(buf), "%jd %d", INTMAX_MIN, 1);
618 ok(!strcmp(buf, "-9223372036854775808 1"), "buf = %s\n", buf);
619
620 /* j modifier with unsigned format accepts uintmax_t argument */
621 vsprintf_wrapper(options, buf, sizeof(buf), "%ju %d", UINTMAX_MAX, 1);
622 ok(!strcmp(buf, "18446744073709551615 1"), "buf = %s\n", buf);
623
624 /* t modifier accepts ptrdiff_t argument */
625 vsprintf_wrapper(options, buf, sizeof(buf), "%td %d", PTRDIFF_MIN, 1);
626 if (sizeof(ptrdiff_t) == 8)
627 ok(!strcmp(buf, "-9223372036854775808 1"), "buf = %s\n", buf);
628 else
629 ok(!strcmp(buf, "-2147483648 1"), "buf = %s\n", buf);
630 }
631}
__int64
#define __int64
Definition: basetyps.h:16
_CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY
#define _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY
Definition: corecrt_stdio_config.h:118
ptrdiff_t
__kernel_ptrdiff_t ptrdiff_t
Definition: linux.h:247
i
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint i
Definition: glfuncs.h:248
INTMAX_MIN
#define INTMAX_MIN
Definition: stdint.h:136
UINTMAX_MAX
#define UINTMAX_MAX
Definition: stdint.h:138
PTRDIFF_MIN
#define PTRDIFF_MIN
Definition: stdint.h:145
vsprintf_wrapper
static int WINAPIV vsprintf_wrapper(unsigned __int64 options, char *str, size_t len, const char *format,...)
Definition: printf.c:80
SIZE_MAX
#define SIZE_MAX
Definition: compat.h:66

Referenced by START_TEST().

◆ test_printf_fp()

static void test_printf_fp ( void  )
static

Definition at line 651 of file printf.c.

652{
653 static const int flags[] = {
654 0,
655 _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY,
656 _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS,
657 _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY
658 | _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS,
659 _CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY
660 | _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS
661 | _CRT_INTERNAL_PRINTF_STANDARD_ROUNDING
662 };
663 const struct {
664 const char *fmt;
665 double d;
666 const char *res[ARRAY_SIZE(flags)];
667 const char *broken[ARRAY_SIZE(flags)];
668 } tests[] = {
669 { "%a", NAN, { "nan", "0x1.#QNAN00000000p+0", "nan", "0x1.#QNAN00000000p+0" }},
670 { "%A", NAN, { "NAN", "0X1.#QNAN00000000P+0", "NAN", "0X1.#QNAN00000000P+0" }},
671 { "%e", NAN, { "nan", "1.#QNAN0e+00", "nan", "1.#QNAN0e+000" }},
672 { "%E", NAN, { "NAN", "1.#QNAN0E+00", "NAN", "1.#QNAN0E+000" }},
673 { "%g", NAN, { "nan", "1.#QNAN", "nan", "1.#QNAN" }},
674 { "%G", NAN, { "NAN", "1.#QNAN", "NAN", "1.#QNAN" }},
675 { "%21a", NAN, { " nan", " 0x1.#QNAN00000000p+0", " nan", " 0x1.#QNAN00000000p+0" }},
676 { "%20e", NAN, { " nan", " 1.#QNAN0e+00", " nan", " 1.#QNAN0e+000" }},
677 { "%20g", NAN, { " nan", " 1.#QNAN", " nan", " 1.#QNAN" }},
678 { "%.21a", NAN, { "nan", "0x1.#QNAN0000000000000000p+0", "nan", "0x1.#QNAN0000000000000000p+0" }},
679 { "%.20e", NAN, { "nan", "1.#QNAN000000000000000e+00", "nan", "1.#QNAN000000000000000e+000" }},
680 { "%.20g", NAN, { "nan", "1.#QNAN", "nan", "1.#QNAN" }},
681 { "%.021a", NAN, { "nan", "0x1.#QNAN0000000000000000p+0", "nan", "0x1.#QNAN0000000000000000p+0" }},
682 { "%.020e", NAN, { "nan", "1.#QNAN000000000000000e+00", "nan", "1.#QNAN000000000000000e+000" }},
683 { "%.020g", NAN, { "nan", "1.#QNAN", "nan", "1.#QNAN" }},
684 { "%#.21a", NAN, { "nan", "0x1.#QNAN0000000000000000p+0", "nan", "0x1.#QNAN0000000000000000p+0" }},
685 { "%#.20e", NAN, { "nan", "1.#QNAN000000000000000e+00", "nan", "1.#QNAN000000000000000e+000" }},
686 { "%#.20g", NAN, { "nan", "1.#QNAN00000000000000", "nan", "1.#QNAN00000000000000" }},
687 { "%.1g", NAN, { "nan", "1", "nan", "1" }},
688 { "%.2g", NAN, { "nan", "1.$", "nan", "1.$" }},
689 { "%.3g", NAN, { "nan", "1.#R", "nan", "1.#R" }},
690
691 { "%a", IND, { "-nan(ind)", "-0x1.#IND000000000p+0", "-nan(ind)", "-0x1.#IND000000000p+0" }},
692 { "%e", IND, { "-nan(ind)", "-1.#IND00e+00", "-nan(ind)", "-1.#IND00e+000" }},
693 { "%g", IND, { "-nan(ind)", "-1.#IND", "-nan(ind)", "-1.#IND" }},
694 { "%21a", IND, { " -nan(ind)", "-0x1.#IND000000000p+0", " -nan(ind)", "-0x1.#IND000000000p+0" }},
695 { "%20e", IND, { " -nan(ind)", " -1.#IND00e+00", " -nan(ind)", " -1.#IND00e+000" }},
696 { "%20g", IND, { " -nan(ind)", " -1.#IND", " -nan(ind)", " -1.#IND" }},
697 { "%.21a", IND, { "-nan(ind)", "-0x1.#IND00000000000000000p+0", "-nan(ind)", "-0x1.#IND00000000000000000p+0" }},
698 { "%.20e", IND, { "-nan(ind)", "-1.#IND0000000000000000e+00", "-nan(ind)", "-1.#IND0000000000000000e+000" }},
699 { "%.20g", IND, { "-nan(ind)", "-1.#IND", "-nan(ind)", "-1.#IND" }},
700 { "%.021a", IND, { "-nan(ind)", "-0x1.#IND00000000000000000p+0", "-nan(ind)", "-0x1.#IND00000000000000000p+0" }},
701 { "%.020e", IND, { "-nan(ind)", "-1.#IND0000000000000000e+00", "-nan(ind)", "-1.#IND0000000000000000e+000" }},
702 { "%.020g", IND, { "-nan(ind)", "-1.#IND", "-nan(ind)", "-1.#IND" }},
703 { "%#.21a", IND, { "-nan(ind)", "-0x1.#IND00000000000000000p+0", "-nan(ind)", "-0x1.#IND00000000000000000p+0" }},
704 { "%#.20e", IND, { "-nan(ind)", "-1.#IND0000000000000000e+00", "-nan(ind)", "-1.#IND0000000000000000e+000" }},
705 { "%#.20g", IND, { "-nan(ind)", "-1.#IND000000000000000", "-nan(ind)", "-1.#IND000000000000000" }},
706
707 { "%a", INFINITY, { "inf", "0x1.#INF000000000p+0", "inf", "0x1.#INF000000000p+0" }},
708 { "%e", INFINITY, { "inf", "1.#INF00e+00", "inf", "1.#INF00e+000" }},
709 { "%g", INFINITY, { "inf", "1.#INF", "inf", "1.#INF" }},
710 { "%21a", INFINITY, { " inf", " 0x1.#INF000000000p+0", " inf", " 0x1.#INF000000000p+0" }},
711 { "%20e", INFINITY, { " inf", " 1.#INF00e+00", " inf", " 1.#INF00e+000" }},
712 { "%20g", INFINITY, { " inf", " 1.#INF", " inf", " 1.#INF" }},
713 { "%.21a", INFINITY, { "inf", "0x1.#INF00000000000000000p+0", "inf", "0x1.#INF00000000000000000p+0" }},
714 { "%.20e", INFINITY, { "inf", "1.#INF0000000000000000e+00", "inf", "1.#INF0000000000000000e+000" }},
715 { "%.20g", INFINITY, { "inf", "1.#INF", "inf", "1.#INF" }},
716 { "%.021a", INFINITY, { "inf", "0x1.#INF00000000000000000p+0", "inf", "0x1.#INF00000000000000000p+0" }},
717 { "%.020e", INFINITY, { "inf", "1.#INF0000000000000000e+00", "inf", "1.#INF0000000000000000e+000" }},
718 { "%.020g", INFINITY, { "inf", "1.#INF", "inf", "1.#INF" }},
719 { "%#.21a", INFINITY, { "inf", "0x1.#INF00000000000000000p+0", "inf", "0x1.#INF00000000000000000p+0" }},
720 { "%#.20e", INFINITY, { "inf", "1.#INF0000000000000000e+00", "inf", "1.#INF0000000000000000e+000" }},
721 { "%#.20g", INFINITY, { "inf", "1.#INF000000000000000", "inf", "1.#INF000000000000000" }},
722
723 { "%a", -INFINITY, { "-inf", "-0x1.#INF000000000p+0", "-inf", "-0x1.#INF000000000p+0" }},
724 { "%e", -INFINITY, { "-inf", "-1.#INF00e+00", "-inf", "-1.#INF00e+000" }},
725 { "%g", -INFINITY, { "-inf", "-1.#INF", "-inf", "-1.#INF" }},
726 { "%21a", -INFINITY, { " -inf", "-0x1.#INF000000000p+0", " -inf", "-0x1.#INF000000000p+0" }},
727 { "%20e", -INFINITY, { " -inf", " -1.#INF00e+00", " -inf", " -1.#INF00e+000" }},
728 { "%20g", -INFINITY, { " -inf", " -1.#INF", " -inf", " -1.#INF" }},
729 { "%.21a", -INFINITY, { "-inf", "-0x1.#INF00000000000000000p+0", "-inf", "-0x1.#INF00000000000000000p+0" }},
730 { "%.20e", -INFINITY, { "-inf", "-1.#INF0000000000000000e+00", "-inf", "-1.#INF0000000000000000e+000" }},
731 { "%.20g", -INFINITY, { "-inf", "-1.#INF", "-inf", "-1.#INF" }},
732 { "%.021a", -INFINITY, { "-inf", "-0x1.#INF00000000000000000p+0", "-inf", "-0x1.#INF00000000000000000p+0" }},
733 { "%.020e", -INFINITY, { "-inf", "-1.#INF0000000000000000e+00", "-inf", "-1.#INF0000000000000000e+000" }},
734 { "%.020g", -INFINITY, { "-inf", "-1.#INF", "-inf", "-1.#INF" }},
735 { "%#.21a", -INFINITY, { "-inf", "-0x1.#INF00000000000000000p+0", "-inf", "-0x1.#INF00000000000000000p+0" }},
736 { "%#.20e", -INFINITY, { "-inf", "-1.#INF0000000000000000e+00", "-inf", "-1.#INF0000000000000000e+000" }},
737 { "%#.20g", -INFINITY, { "-inf", "-1.#INF000000000000000", "-inf", "-1.#INF000000000000000" }},
738
739 { "%a", 0, { "0x0.0000000000000p+0" }},
740 { "%A", 0, { "0X0.0000000000000P+0" }},
741 { "%a", 0.5, { "0x1.0000000000000p-1" }},
742 { "%a", 1, { "0x1.0000000000000p+0" }},
743 { "%a", 20, { "0x1.4000000000000p+4" }},
744 { "%a", -1, { "-0x1.0000000000000p+0" }},
745 { "%a", 0.1, { "0x1.999999999999ap-4" }},
746 { "%24a", 0.1, { " 0x1.999999999999ap-4" }},
747 { "%024a", 0.1, { "0x00001.999999999999ap-4" }},
748 { "%.2a", 0.1, { "0x1.9ap-4" }},
749 { "%.20a", 0.1, { "0x1.999999999999a0000000p-4" }},
750 { "%.a", 0.1e-20, { "0x1p-70" }},
751 { "%a", 0.1e-20, { "0x1.2e3b40a0e9b4fp-70" }},
752 { "%a", 4.9406564584124654e-324, { "0x0.0000000000001p-1022" }},
753 { "%.0a", -1.5, { "-0x2p+0" }, { "-0x1p+0" }},
754 { "%.0a", -0.5, { "-0x1p-1" }},
755 { "%.0a", 0.5, { "0x1p-1" }},
756 { "%.0a", 1.5, { "0x2p+0" }, { "0x1p+0" }},
757 { "%.0a", 1.99, { "0x2p+0" }},
758 { "%.0a", 2, { "0x1p+1" }},
759 { "%.0a", 9.5, { "0x1p+3" }},
760 { "%.0a", 10.5, { "0x1p+3" }},
761 { "%#.0a", -1.5, { "-0x2.p+0" }, { "-0x1.p+0" }},
762 { "%#.0a", -0.5, { "-0x1.p-1" }},
763 { "%#.0a", 0.5, { "0x1.p-1" }},
764 { "%#.0a", 1.5, { "0x2.p+0" }, { "0x1.p+0" }},
765 { "%#.1a", 1.03125, { "0x1.1p+0", NULL, NULL, NULL, "0x1.0p+0" }, { "0x1.0p+0" }},
766 { "%#.1a", 1.09375, { "0x1.2p+0" }, { "0x1.1p+0" }},
767 { "%#.1a", 1.15625, { "0x1.3p+0", NULL, NULL, NULL, "0x1.2p+0" }, { "0x1.2p+0" }},
768
769 { "%f", 0, { "0.000000" }},
770 { "%e", 0, { "0.000000e+00", NULL, "0.000000e+000" }},
771 { "%g", 0, { "0" }},
772 { "%21f", 0, { " 0.000000" }},
773 { "%20e", 0, { " 0.000000e+00", NULL, " 0.000000e+000" }},
774 { "%20g", 0, { " 0" }},
775 { "%.21f", 0, { "0.000000000000000000000" }},
776 { "%.20e", 0, { "0.00000000000000000000e+00", NULL, "0.00000000000000000000e+000" }},
777 { "%.20g", 0, { "0" }},
778 { "%.021f", 0, { "0.000000000000000000000" }},
779 { "%.020e", 0, { "0.00000000000000000000e+00", NULL, "0.00000000000000000000e+000" }},
780 { "%.020g", 0, { "0" }},
781 { "%#.21f", 0, { "0.000000000000000000000" }},
782 { "%#.20e", 0, { "0.00000000000000000000e+00", NULL, "0.00000000000000000000e+000" }},
783 { "%#.20g", 0, { "0.0000000000000000000" }, { "0.00000000000000000000" }},
784
785 { "%f", 123, { "123.000000" }},
786 { "%e", 123, { "1.230000e+02", NULL, "1.230000e+002" }},
787 { "%g", 123, { "123" }},
788 { "%21f", 123, { " 123.000000" }},
789 { "%20e", 123, { " 1.230000e+02", NULL, " 1.230000e+002" }},
790 { "%20g", 123, { " 123" }},
791 { "%.21f", 123, { "123.000000000000000000000" }},
792 { "%.20e", 123, { "1.23000000000000000000e+02", NULL, "1.23000000000000000000e+002" }},
793 { "%.20g", 123, { "123" }},
794 { "%.021f", 123, { "123.000000000000000000000" }},
795 { "%.020e", 123, { "1.23000000000000000000e+02", NULL, "1.23000000000000000000e+002" }},
796 { "%.020g", 123, { "123" }},
797 { "%#.21f", 123, { "123.000000000000000000000" }},
798 { "%#.20e", 123, { "1.23000000000000000000e+02", NULL, "1.23000000000000000000e+002" }},
799 { "%#.20g", 123, { "123.00000000000000000" }},
800
801 { "%f", -765, { "-765.000000" }},
802 { "%e", -765, { "-7.650000e+02", NULL, "-7.650000e+002" }},
803 { "%g", -765, { "-765" }},
804 { "%21f", -765, { " -765.000000" }},
805 { "%20e", -765, { " -7.650000e+02", NULL, " -7.650000e+002" }},
806 { "%20g", -765, { " -765" }},
807 { "%.21f", -765, { "-765.000000000000000000000" }},
808 { "%.20e", -765, { "-7.65000000000000000000e+02", NULL, "-7.65000000000000000000e+002" }},
809 { "%.20g", -765, { "-765" }},
810 { "%.021f", -765, { "-765.000000000000000000000" }},
811 { "%.020e", -765, { "-7.65000000000000000000e+02", NULL, "-7.65000000000000000000e+002" }},
812 { "%.020g", -765, { "-765" }},
813 { "%#.21f", -765, { "-765.000000000000000000000" }},
814 { "%#.20e", -765, { "-7.65000000000000000000e+02", NULL, "-7.65000000000000000000e+002" }},
815 { "%#.20g", -765, { "-765.00000000000000000" }},
816 { "%.30f", 1.0/3.0, { "0.333333333333333314829616256247" }},
817 { "%.30lf", sqrt(2), { "1.414213562373095145474621858739" }},
818 { "%f", 3.141592653590000, { "3.141593" }},
819 { "%.10f", 3.141592653590000, { "3.1415926536" }},
820 { "%.11f", 3.141592653590000, { "3.14159265359" }},
821 { "%.15f", 3.141592653590000, { "3.141592653590000" }},
822 { "%.15f", M_PI, { "3.141592653589793" }},
823 { "%.13f", 37.866261574537077, { "37.8662615745371" }},
824 { "%.14f", 37.866261574537077, { "37.86626157453708" }},
825 { "%.15f", 37.866261574537077, { "37.866261574537077" }},
826 { "%.0g", 9.8949714229143402e-05, { "0.0001" }},
827 { "%.0f", 0.5, { "1", NULL, NULL, NULL, "0" }, {NULL, NULL, NULL, NULL, "1" }},
828 { "%.0f", 1.5, { "2" }},
829 { "%.0f", 2.5, { "3", NULL, NULL, NULL, "2" }, {NULL, NULL, NULL, NULL, "3" }},
830 { "%g", 9.999999999999999e-5, { "0.0001" }},
831
832 { "%g", 0.0005, { "0.0005" }},
833 { "%g", 0.00005, { "5e-05", NULL, "5e-005" }},
834 { "%g", 0.000005, { "5e-06", NULL, "5e-006" }},
835 { "%g", 999999999999999.0, { "1e+15", NULL, "1e+015" }},
836 { "%g", 1000000000000000.0, { "1e+15", NULL, "1e+015" }},
837 { "%.15g", 0.0005, { "0.0005" }},
838 { "%.15g", 0.00005, { "5e-05", NULL, "5e-005" }},
839 { "%.15g", 0.000005, { "5e-06", NULL, "5e-006" }},
840 { "%.15g", 999999999999999.0, { "999999999999999" }},
841 { "%.15g", 1000000000000000.0, { "1e+15", NULL, "1e+015" }},
842 };
843
844 const char *res = NULL;
845 const char *broken_res;
846 char buf[100];
847 int i, j, r;
848
849 for (i = 0; i < ARRAY_SIZE(tests); i++)
850 {
851 broken_res = NULL;
852
853 for (j = 0; j < ARRAY_SIZE(flags); j++)
854 {
855 if (tests[i].res[j]) res = tests[i].res[j];
856 if (tests[i].broken[j]) broken_res = tests[i].broken[j];
857
858 r = vsprintf_wrapper(flags[j], buf, sizeof(buf), tests[i].fmt, tests[i].d);
859 ok(r == strlen(res) || broken(broken_res && r == strlen(broken_res)),
860 "%d,%d) r = %d, expected %Id\n", i, j, r, strlen(res));
861 ok(!strcmp(buf, res) || broken(broken_res && !strcmp(buf, broken_res)),
862 "%d,%d) buf = %s, expected %s\n", i, j, buf, res);
863 }
864 }
865}
sqrt
_STLP_DECLSPEC complex< float > _STLP_CALL sqrt(const complex< float > &)
Definition: complex.cpp:188
strlen
ACPI_SIZE strlen(const char *String)
Definition: utclib.c:269
broken
#define broken(x)
Definition: atltest.h:178
_CRT_INTERNAL_PRINTF_STANDARD_ROUNDING
#define _CRT_INTERNAL_PRINTF_STANDARD_ROUNDING
Definition: corecrt_stdio_config.h:120
_CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS
#define _CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS
Definition: corecrt_stdio_config.h:119
r
GLdouble GLdouble GLdouble r
Definition: gl.h:2055
res
GLuint res
Definition: glext.h:9613
flags
GLbitfield flags
Definition: glext.h:7161
j
GLsizei GLenum const GLvoid GLsizei GLenum GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLint GLint GLint GLshort GLshort GLshort GLubyte GLubyte GLubyte GLuint GLuint GLuint GLushort GLushort GLushort GLbyte GLbyte GLbyte GLbyte GLdouble GLdouble GLdouble GLdouble GLfloat GLfloat GLfloat GLfloat GLint GLint GLint GLint GLshort GLshort GLshort GLshort GLubyte GLubyte GLubyte GLubyte GLuint GLuint GLuint GLuint GLushort GLushort GLushort GLushort GLboolean const GLdouble const GLfloat const GLint const GLshort const GLbyte const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLdouble const GLfloat const GLfloat const GLint const GLint const GLshort const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort const GLdouble const GLfloat const GLint const GLshort GLenum GLenum GLenum GLfloat GLenum GLint GLenum GLenum GLenum GLfloat GLenum GLenum GLint GLenum GLfloat GLenum GLint GLint GLushort GLenum GLenum GLfloat GLenum GLenum GLint GLfloat const GLubyte GLenum GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLint GLint GLsizei GLsizei GLint GLenum GLenum const GLvoid GLenum GLenum const GLfloat GLenum GLenum const GLint GLenum GLenum const GLdouble GLenum GLenum const GLfloat GLenum GLenum const GLint GLsizei GLuint GLfloat GLuint GLbitfield GLfloat GLint GLuint GLboolean GLenum GLfloat GLenum GLbitfield GLenum GLfloat GLfloat GLint GLint const GLfloat GLenum GLfloat GLfloat GLint GLint GLfloat GLfloat GLint GLint const GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat GLint GLfloat GLfloat const GLdouble const GLfloat const GLdouble const GLfloat GLint GLint GLint j
Definition: glfuncs.h:250
INFINITY
#define INFINITY
Definition: math.h:56
d
#define d
Definition: ke_i.h:81
M_PI
#define M_PI
Definition: macros.h:263
tests
static struct test_info tests[]
NAN
#define NAN
Definition: mesh.c:39
IND
#define IND
Definition: printf.c:44
fmt
Definition: dsound.c:943

Referenced by START_TEST().

◆ test_printf_legacy_msvcrt()

static void test_printf_legacy_msvcrt ( void  )
static

Definition at line 560 of file printf.c.

561{
562 char buf[50];
563
564 /* In standard mode, %F is a float format conversion, while it is a
565 * length modifier in legacy msvcrt mode. In legacy mode, N is also
566 * a length modifier. */
567 vsprintf_wrapper(0, buf, sizeof(buf), "%F", 1.23);
568 ok(!strcmp(buf, "1.230000"), "buf = %s\n", buf);
569 vsprintf_wrapper(_CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY, buf, sizeof(buf), "%Fd %Nd", 123, 456);
570 ok(!strcmp(buf, "123 456"), "buf = %s\n", buf);
571
572 vsprintf_wrapper(0, buf, sizeof(buf), "%f %F %f %e %E %g %G", INFINITY, INFINITY, -INFINITY, INFINITY, INFINITY, INFINITY, INFINITY);
573 ok(!strcmp(buf, "inf INF -inf inf INF inf INF"), "buf = %s\n", buf);
574 vsprintf_wrapper(_CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY, buf, sizeof(buf), "%f", INFINITY);
575 ok(!strcmp(buf, "1.#INF00"), "buf = %s\n", buf);
576 vsprintf_wrapper(0, buf, sizeof(buf), "%f %F", NAN, NAN);
577 ok(!strcmp(buf, "nan NAN"), "buf = %s\n", buf);
578 vsprintf_wrapper(_CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY, buf, sizeof(buf), "%f", NAN);
579 ok(!strcmp(buf, "1.#QNAN0"), "buf = %s\n", buf);
580 vsprintf_wrapper(0, buf, sizeof(buf), "%f %F", IND, IND);
581 ok(!strcmp(buf, "-nan(ind) -NAN(IND)"), "buf = %s\n", buf);
582 vsprintf_wrapper(_CRT_INTERNAL_PRINTF_LEGACY_MSVCRT_COMPATIBILITY, buf, sizeof(buf), "%f", IND);
583 ok(!strcmp(buf, "-1.#IND00"), "buf = %s\n", buf);
584}

Referenced by START_TEST().

◆ test_printf_legacy_three_digit_exp()

static void test_printf_legacy_three_digit_exp ( void  )
static

Definition at line 586 of file printf.c.

587{
588 char buf[20];
589
590 vsprintf_wrapper(0, buf, sizeof(buf), "%E", 1.23);
591 ok(!strcmp(buf, "1.230000E+00"), "buf = %s\n", buf);
592 vsprintf_wrapper(_CRT_INTERNAL_PRINTF_LEGACY_THREE_DIGIT_EXPONENTS, buf, sizeof(buf), "%E", 1.23);
593 ok(!strcmp(buf, "1.230000E+000"), "buf = %s\n", buf);
594 vsprintf_wrapper(0, buf, sizeof(buf), "%E", 1.23e+123);
595 ok(!strcmp(buf, "1.230000E+123"), "buf = %s\n", buf);
596}

Referenced by START_TEST().

◆ test_printf_legacy_wide()

static void test_printf_legacy_wide ( void  )
static

Definition at line 532 of file printf.c.

533{
534 const wchar_t wide[] = {'A','B','C','D',0};
535 const char narrow[] = "abcd";
536 const char out[] = "abcd ABCD";
537 /* The legacy wide flag doesn't affect narrow printfs, so the same
538 * format should behave the same both with and without the flag. */
539 const char narrow_fmt[] = "%s %ls";
540 /* The standard behaviour is to use the same format as for the narrow
541 * case, while the legacy case has got a different meaning for %s. */
542 const wchar_t std_wide_fmt[] = {'%','s',' ','%','l','s',0};
543 const wchar_t legacy_wide_fmt[] = {'%','h','s',' ','%','s',0};
544 char buffer[20];
545 wchar_t wbuffer[20];
546
547 vsprintf_wrapper(0, buffer, sizeof(buffer), narrow_fmt, narrow, wide);
548 ok(!strcmp(buffer, out), "buffer wrong, got=%s\n", buffer);
549 vsprintf_wrapper(_CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS, buffer, sizeof(buffer), narrow_fmt, narrow, wide);
550 ok(!strcmp(buffer, out), "buffer wrong, got=%s\n", buffer);
551
552 vswprintf_wrapper(0, wbuffer, sizeof(wbuffer), std_wide_fmt, narrow, wide);
553 WideCharToMultiByte(CP_ACP, 0, wbuffer, -1, buffer, sizeof(buffer), NULL, NULL);
554 ok(!strcmp(buffer, out), "buffer wrong, got=%s\n", buffer);
555 vswprintf_wrapper(_CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS, wbuffer, sizeof(wbuffer), legacy_wide_fmt, narrow, wide);
556 WideCharToMultiByte(CP_ACP, 0, wbuffer, -1, buffer, sizeof(buffer), NULL, NULL);
557 ok(!strcmp(buffer, out), "buffer wrong, got=%s\n", buffer);
558}
_CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS
#define _CRT_INTERNAL_PRINTF_LEGACY_WIDE_SPECIFIERS
Definition: corecrt_stdio_config.h:117
CP_ACP
#define CP_ACP
Definition: compat.h:109
WideCharToMultiByte
#define WideCharToMultiByte
Definition: compat.h:111
buffer
GLuint buffer
Definition: glext.h:5915
vswprintf_wrapper
static int WINAPIV vswprintf_wrapper(wchar_t *str, const wchar_t *format,...)
Definition: printf.c:853
out
wchar_t tm const _CrtWcstime_Writes_and_advances_ptr_ count wchar_t ** out
Definition: wcsftime.cpp:383

Referenced by START_TEST().

◆ test_printf_natural_string()

static void test_printf_natural_string ( void  )
static

Definition at line 633 of file printf.c.

634{
635 const wchar_t wide[] = {'A','B','C','D',0};
636 const char narrow[] = "abcd";
637 const char narrow_fmt[] = "%s %Ts";
638 const char narrow_out[] = "abcd abcd";
639 const wchar_t wide_fmt[] = {'%','s',' ','%','T','s',0};
640 const wchar_t wide_out[] = {'a','b','c','d',' ','A','B','C','D',0};
641 char buffer[20];
642 wchar_t wbuffer[20];
643
644 vsprintf_wrapper(0, buffer, sizeof(buffer), narrow_fmt, narrow, narrow);
645 ok(!strcmp(buffer, narrow_out), "buffer wrong, got=%s\n", buffer);
646
647 vswprintf_wrapper(0, wbuffer, sizeof(wbuffer), wide_fmt, narrow, wide);
648 ok(!lstrcmpW(wbuffer, wide_out), "buffer wrong, got=%s\n", wine_dbgstr_w(wbuffer));
649}
lstrcmpW
int WINAPI lstrcmpW(LPCWSTR str1, LPCWSTR str2)
Definition: locale.c:4243

Referenced by START_TEST().

◆ test_printf_width_specification()

static void test_printf_width_specification ( void  )
static

Definition at line 867 of file printf.c.

868{
869 int r;
870 char buffer[20];
871
872 r = vsprintf_wrapper(0, buffer, sizeof(buffer), "%0*2d", 1, 3);
873 ok(r == 2, "r = %d\n", r);
874 ok(!strcmp(buffer, "03"), "buffer wrong, got=%s\n", buffer);
875
876 r = vsprintf_wrapper(0, buffer, sizeof(buffer), "%*0d", 1, 2);
877 ok(r == 1, "r = %d\n", r);
878 ok(!strcmp(buffer, "2"), "buffer wrong, got=%s\n", buffer);
879
880 r = vsprintf_wrapper(0, buffer, sizeof(buffer), "% *2d", 0, 7);
881 ok(r == 2, "r = %d\n", r);
882 ok(!strcmp(buffer, " 7"), "buffer wrong, got=%s\n", buffer);
883}

Referenced by START_TEST().

◆ test_snprintf()

static void test_snprintf ( void  )
static

Definition at line 91 of file printf.c.

92{
93 const char *tests[] = {"short", "justfit", "justfits", "muchlonger", "", "1"};
94 char buffer[8];
95 int bufsizes[] = { 0, 1, sizeof(buffer) };
96 unsigned int i, j;
97
98 for (j = 0; j < ARRAY_SIZE(bufsizes); j++) {
99 const int bufsiz = bufsizes[j];
100 /* Legacy _snprintf style termination */
101 for (i = 0; i < ARRAY_SIZE(tests); i++) {
102 const char *fmt = tests[i];
103 const int expect = strlen(fmt) > bufsiz ? -1 : strlen(fmt);
104 const int n = vsprintf_wrapper (_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION, buffer, bufsiz, fmt);
105 const int valid = n < 0 ? bufsiz : (n == bufsiz ? n : n+1);
106
107 ok (n == expect, "\"%s\": expected %d, returned %d\n",
108 fmt, expect, n);
109 ok (!memcmp (fmt, buffer, valid),
110 "\"%s\": rendered \"%.*s\"\n", fmt, valid, buffer);
111 }
112
113 /* C99 snprintf style termination */
114 for (i = 0; i < ARRAY_SIZE(tests); i++) {
115 const char *fmt = tests[i];
116 const int expect = strlen(fmt);
117 const int n = vsprintf_wrapper (_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, buffer, bufsiz, fmt);
118 const int valid = n >= bufsiz ? (bufsiz > 0 ? bufsiz - 1 : 0) : n < 0 ? 0 : n;
119
120 ok (n == expect, "\"%s\": expected %d, returned %d\n",
121 fmt, expect, n);
122 ok (!memcmp (fmt, buffer, valid),
123 "\"%s\": rendered \"%.*s\" bufsiz %d\n", fmt, valid, buffer, bufsiz);
124 ok (bufsiz == 0 || buffer[valid] == '\0',
125 "\"%s\": Missing null termination (ret %d) - is %d (bufsiz %d)\n", fmt, n, buffer[valid], bufsiz);
126 }
127
128 /* swprintf style termination */
129 for (i = 0; i < ARRAY_SIZE(tests); i++) {
130 const char *fmt = tests[i];
131 const int expect = strlen(fmt) >= bufsiz ? bufsiz > 0 ? -2 : -1 : strlen(fmt);
132 const int n = vsprintf_wrapper (0, buffer, bufsiz, fmt);
133 const int valid = n < 0 ? bufsiz > 0 ? bufsiz - 1 : 0 : n;
134
135 ok (n == expect, "\"%s\": expected %d, returned %d\n",
136 fmt, expect, n);
137 ok (!memcmp (fmt, buffer, valid),
138 "\"%s\": rendered \"%.*s\" bufsiz %d\n", fmt, valid, buffer, bufsiz);
139 ok (bufsiz == 0 || buffer[valid] == '\0',
140 "\"%s\": Missing null termination (ret %d) - is %d\n", fmt, n, buffer[valid]);
141 }
142 }
143
144 ok (vsprintf_wrapper (_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, NULL, 0, "abcd") == 4,
145 "Failure to snprintf to NULL\n");
146 ok (vsprintf_wrapper (_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION, NULL, 0, "abcd") == 4,
147 "Failure to snprintf to NULL\n");
148 ok (vsprintf_wrapper (0, NULL, 0, "abcd") == 4,
149 "Failure to snprintf to NULL\n");
150 ok (vsprintf_wrapper (_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, buffer, 0, "abcd") == 4,
151 "Failure to snprintf to zero length buffer\n");
152 ok (vsprintf_wrapper (_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION, buffer, 0, "abcd") == -1,
153 "Failure to snprintf to zero length buffer\n");
154 ok (vsprintf_wrapper (0, buffer, 0, "abcd") == -1,
155 "Failure to snprintf to zero length buffer\n");
156 ok (vsprintf_wrapper (_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, buffer, 0, "") == 0,
157 "Failure to snprintf a zero length string to a zero length buffer\n");
158 ok (vsprintf_wrapper (_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION, buffer, 0, "") == 0,
159 "Failure to snprintf a zero length string to a zero length buffer\n");
160 ok (vsprintf_wrapper (0, buffer, 0, "") == -1,
161 "Failure to snprintf a zero length string to a zero length buffer\n");
162}
expect
#define expect(EXPECTED, GOT)
Definition: SystemMenu.c:483
_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION
#define _CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION
Definition: corecrt_stdio_config.h:115
_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR
#define _CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR
Definition: corecrt_stdio_config.h:116
valid
BOOLEAN valid
Definition: fxregistryapi.cpp:1474
n
GLdouble n
Definition: glext.h:7729

◆ test_swprintf()

static void test_swprintf ( void  )
static

Definition at line 175 of file printf.c.

176{
177 const wchar_t str_short[] = {'s','h','o','r','t',0};
178 const wchar_t str_justfit[] = {'j','u','s','t','f','i','t',0};
179 const wchar_t str_justfits[] = {'j','u','s','t','f','i','t','s',0};
180 const wchar_t str_muchlonger[] = {'m','u','c','h','l','o','n','g','e','r',0};
181 const wchar_t str_empty[] = {0};
182 const wchar_t *tests[] = {str_short, str_justfit, str_justfits, str_muchlonger};
183
184 wchar_t buffer[8];
185 char narrow[8], narrow_fmt[16];
186 const int bufsiz = ARRAY_SIZE(buffer);
187 unsigned int i;
188
189 /* Legacy _snprintf style termination */
190 for (i = 0; i < ARRAY_SIZE(tests); i++) {
191 const wchar_t *fmt = tests[i];
192 const int expect = wcslen(fmt) > bufsiz ? -1 : wcslen(fmt);
193 const int n = vswprintf_wrapper (_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION, buffer, bufsiz, fmt);
194 const int valid = n < 0 ? bufsiz : (n == bufsiz ? n : n+1);
195
196 WideCharToMultiByte (CP_ACP, 0, buffer, -1, narrow, sizeof(narrow), NULL, NULL);
197 WideCharToMultiByte (CP_ACP, 0, fmt, -1, narrow_fmt, sizeof(narrow_fmt), NULL, NULL);
198 ok (n == expect, "\"%s\": expected %d, returned %d\n",
199 narrow_fmt, expect, n);
200 ok (!memcmp (fmt, buffer, valid * sizeof(wchar_t)),
201 "\"%s\": rendered \"%.*s\"\n", narrow_fmt, valid, narrow);
202 }
203
204 /* C99 snprintf style termination */
205 for (i = 0; i < ARRAY_SIZE(tests); i++) {
206 const wchar_t *fmt = tests[i];
207 const int expect = wcslen(fmt);
208 const int n = vswprintf_wrapper (_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, buffer, bufsiz, fmt);
209 const int valid = n >= bufsiz ? bufsiz - 1 : n < 0 ? 0 : n;
210
211 WideCharToMultiByte (CP_ACP, 0, buffer, -1, narrow, sizeof(narrow), NULL, NULL);
212 WideCharToMultiByte (CP_ACP, 0, fmt, -1, narrow_fmt, sizeof(narrow_fmt), NULL, NULL);
213 ok (n == expect, "\"%s\": expected %d, returned %d\n",
214 narrow_fmt, expect, n);
215 ok (!memcmp (fmt, buffer, valid * sizeof(wchar_t)),
216 "\"%s\": rendered \"%.*s\"\n", narrow_fmt, valid, narrow);
217 ok (buffer[valid] == '\0',
218 "\"%s\": Missing null termination (ret %d) - is %d\n", narrow_fmt, n, buffer[valid]);
219 }
220
221 /* swprintf style termination */
222 for (i = 0; i < ARRAY_SIZE(tests); i++) {
223 const wchar_t *fmt = tests[i];
224 const int expect = wcslen(fmt) >= bufsiz ? -2 : wcslen(fmt);
225 const int n = vswprintf_wrapper (0, buffer, bufsiz, fmt);
226 const int valid = n < 0 ? bufsiz - 1 : n;
227
228 WideCharToMultiByte (CP_ACP, 0, buffer, -1, narrow, sizeof(narrow), NULL, NULL);
229 WideCharToMultiByte (CP_ACP, 0, fmt, -1, narrow_fmt, sizeof(narrow_fmt), NULL, NULL);
230 ok (n == expect, "\"%s\": expected %d, returned %d\n",
231 narrow_fmt, expect, n);
232 ok (!memcmp (fmt, buffer, valid * sizeof(wchar_t)),
233 "\"%s\": rendered \"%.*s\"\n", narrow_fmt, valid, narrow);
234 ok (buffer[valid] == '\0',
235 "\"%s\": Missing null termination (ret %d) - is %d\n", narrow_fmt, n, buffer[valid]);
236 }
237
238 ok (vswprintf_wrapper (_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, NULL, 0, str_short) == 5,
239 "Failure to swprintf to NULL\n");
240 ok (vswprintf_wrapper (_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION, NULL, 0, str_short) == 5,
241 "Failure to swprintf to NULL\n");
242 ok (vswprintf_wrapper (0, NULL, 0, str_short) == 5,
243 "Failure to swprintf to NULL\n");
244 ok (vswprintf_wrapper (_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, buffer, 0, str_short) == 5,
245 "Failure to swprintf to a zero length buffer\n");
246 ok (vswprintf_wrapper (_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION, buffer, 0, str_short) == -1,
247 "Failure to swprintf to a zero length buffer\n");
248 ok (vswprintf_wrapper (0, buffer, 0, str_short) == -1,
249 "Failure to swprintf to a zero length buffer\n");
250 ok (vswprintf_wrapper (_CRT_INTERNAL_PRINTF_STANDARD_SNPRINTF_BEHAVIOR, buffer, 0, str_empty) == 0,
251 "Failure to swprintf a zero length string to a zero length buffer\n");
252 ok (vswprintf_wrapper (_CRT_INTERNAL_PRINTF_LEGACY_VSPRINTF_NULL_TERMINATION, buffer, 0, str_empty) == 0,
253 "Failure to swprintf a zero length string to a zero length buffer\n");
254 ok (vswprintf_wrapper (0, buffer, 0, str_empty) == -1,
255 "Failure to swprintf a zero length string to a zero length buffer\n");
256}
wcslen
_CRTIMP size_t __cdecl wcslen(_In_z_ const wchar_t *_Str)

◆ test_vsnprintf_s()

static void test_vsnprintf_s ( void  )
static

Definition at line 439 of file printf.c.

440{
441 const char format[] = "AB%uC";
442 const char out7[] = "AB123C";
443 const char out6[] = "AB123";
444 const char out2[] = "A";
445 const char out1[] = "";
446 char buffer[14] = { 0 };
447 int exp, got;
448
449 /* Enough room. */
450 exp = strlen(out7);
451
452 got = _vsnprintf_s_wrapper(buffer, 14, _TRUNCATE, format, 123);
453 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
454 ok( !strcmp(out7, buffer), "buffer wrong, got=%s\n", buffer);
455
456 got = _vsnprintf_s_wrapper(buffer, 12, _TRUNCATE, format, 123);
457 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
458 ok( !strcmp(out7, buffer), "buffer wrong, got=%s\n", buffer);
459
460 got = _vsnprintf_s_wrapper(buffer, 7, _TRUNCATE, format, 123);
461 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
462 ok( !strcmp(out7, buffer), "buffer wrong, got=%s\n", buffer);
463
464 /* Not enough room. */
465 exp = -1;
466
467 got = _vsnprintf_s_wrapper(buffer, 6, _TRUNCATE, format, 123);
468 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
469 ok( !strcmp(out6, buffer), "buffer wrong, got=%s\n", buffer);
470
471 got = _vsnprintf_s_wrapper(buffer, 2, _TRUNCATE, format, 123);
472 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
473 ok( !strcmp(out2, buffer), "buffer wrong, got=%s\n", buffer);
474
475 got = _vsnprintf_s_wrapper(buffer, 1, _TRUNCATE, format, 123);
476 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
477 ok( !strcmp(out1, buffer), "buffer wrong, got=%s\n", buffer);
478}
_vsnprintf_s_wrapper
static int WINAPIV _vsnprintf_s_wrapper(char *str, size_t sizeOfBuffer, size_t count, const char *format,...)
Definition: printf.c:428
exp
DWORD exp
Definition: msg.c:16058
_TRUNCATE
#define _TRUNCATE
Definition: corecrt.h:278

Referenced by START_TEST().

◆ test_vsnwprintf_s()

static void test_vsnwprintf_s ( void  )
static

Definition at line 491 of file printf.c.

492{
493 const WCHAR format[] = {'A','B','%','u','C',0};
494 const WCHAR out7[] = {'A','B','1','2','3','C',0};
495 const WCHAR out6[] = {'A','B','1','2','3',0};
496 const WCHAR out2[] = {'A',0};
497 const WCHAR out1[] = {0};
498 WCHAR buffer[14] = { 0 };
499 int exp, got;
500
501 /* Enough room. */
502 exp = lstrlenW(out7);
503
504 got = _vsnwprintf_s_wrapper(buffer, 14, _TRUNCATE, format, 123);
505 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
506 ok( !lstrcmpW(out7, buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
507
508 got = _vsnwprintf_s_wrapper(buffer, 12, _TRUNCATE, format, 123);
509 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
510 ok( !lstrcmpW(out7, buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
511
512 got = _vsnwprintf_s_wrapper(buffer, 7, _TRUNCATE, format, 123);
513 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
514 ok( !lstrcmpW(out7, buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
515
516 /* Not enough room. */
517 exp = -1;
518
519 got = _vsnwprintf_s_wrapper(buffer, 6, _TRUNCATE, format, 123);
520 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
521 ok( !lstrcmpW(out6, buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
522
523 got = _vsnwprintf_s_wrapper(buffer, 2, _TRUNCATE, format, 123);
524 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
525 ok( !lstrcmpW(out2, buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
526
527 got = _vsnwprintf_s_wrapper(buffer, 1, _TRUNCATE, format, 123);
528 ok( exp == got, "length wrong, expect=%d, got=%d\n", exp, got);
529 ok( !lstrcmpW(out1, buffer), "buffer wrong, got=%s\n", wine_dbgstr_w(buffer));
530}
lstrlenW
#define lstrlenW
Definition: compat.h:750
_vsnwprintf_s_wrapper
static int WINAPIV _vsnwprintf_s_wrapper(wchar_t *str, size_t sizeOfBuffer, size_t count, const wchar_t *format,...)
Definition: printf.c:1008

◆ vfprintf_wrapper()

static int WINAPIV vfprintf_wrapper ( FILE *  file,
const char *  format,
  ... 
)
static

Definition at line 258 of file printf.c.

260{
261 int ret;
262 va_list valist;
263 va_start(valist, format);
264 ret = __stdio_common_vfprintf(0, file, format, NULL, valist);
265 va_end(valist);
266 return ret;
267}
__stdio_common_vfprintf
int __cdecl __stdio_common_vfprintf(unsigned __int64 const options, FILE *const stream, char const *const format, _locale_t const locale, va_list const arglist)
Definition: output.cpp:52

Referenced by test_fprintf().

◆ vfwprintf_wrapper()

static int WINAPIV vfwprintf_wrapper ( FILE *  file,
const wchar_t *  format,
  ... 
)
static

Definition at line 331 of file printf.c.

333{
334 int ret;
335 va_list valist;
336 va_start(valist, format);
337 ret = __stdio_common_vfwprintf(0, file, format, NULL, valist);
338 va_end(valist);
339 return ret;
340}
__stdio_common_vfwprintf
int __cdecl __stdio_common_vfwprintf(unsigned __int64 const options, FILE *const stream, wchar_t const *const format, _locale_t const locale, va_list const arglist)
Definition: output.cpp:64

Referenced by test_fwprintf().

◆ vsprintf_wrapper()

static int WINAPIV vsprintf_wrapper ( unsigned __int64  options,
char *  str,
size_t  len,
const char *  format,
  ... 
)
static

Definition at line 80 of file printf.c.

82{
83 int ret;
84 va_list valist;
85 va_start(valist, format);
86 ret = __stdio_common_vsprintf(options, str, len, format, NULL, valist);
87 va_end(valist);
88 return ret;
89}
len
GLenum GLsizei len
Definition: glext.h:6722
__stdio_common_vsprintf
int __cdecl __stdio_common_vsprintf(unsigned __int64 const options, char *const buffer, size_t const buffer_count, char const *const format, _locale_t const locale, va_list const arglist)
Definition: output.cpp:233

Referenced by test_printf_c99(), test_printf_fp(), test_printf_legacy_msvcrt(), test_printf_legacy_three_digit_exp(), test_printf_legacy_wide(), test_printf_natural_string(), test_printf_width_specification(), and test_snprintf().

◆ vswprintf_wrapper()

static int WINAPIV vswprintf_wrapper ( unsigned __int64  options,
wchar_t *  str,
size_t  len,
const wchar_t *  format,
  ... 
)
static

Definition at line 164 of file printf.c.

166{
167 int ret;
168 va_list valist;
169 va_start(valist, format);
170 ret = __stdio_common_vswprintf(options, str, len, format, NULL, valist);
171 va_end(valist);
172 return ret;
173}
__stdio_common_vswprintf
int __cdecl __stdio_common_vswprintf(unsigned __int64 const options, wchar_t *const buffer, size_t const buffer_count, wchar_t const *const format, _locale_t const locale, va_list const arglist)
Definition: output.cpp:246