2 * test.c - test a portable implementation of snprintf
5 * Mark Martinec <mark.martinec@ijs.si>, April 1999.
7 * Copyright 1999, Mark Martinec. All rights reserved.
10 * This program is free software; you can redistribute it and/or modify
11 * it under the terms of the "Frontier Artistic License" which comes
14 * This program is distributed in the hope that it will be useful,
15 * but WITHOUT ANY WARRANTY; without even the implied warranty
16 * of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
17 * See the Frontier Artistic License for more details.
19 * You should have received a copy of the Frontier Artistic License
20 * with this Kit in the file named LICENSE.txt .
21 * If not, I'll be glad to provide one.
23 * NOTE: This test program is a QUICK and DIRTY tool
24 * ===== used while testing and benchmarking my portable snprintf.
25 * Certain data types are not fully supported, certain test
26 * cases were fabricated during testing by modifying the code
27 * or running it by specifying test parameters in the command line.
29 * You are on your own if you want to use this test program!
32 /* If no command arguments are specified do the exhaustive test.
33 * This takes a long time. You may want to reduce the fw and fp
34 * upper limits in the for loops.
35 * You may also reduce the number of test elements in the array iargs.
38 #include <sys/types.h>
47 #if defined(NEED_ASPRINTF) || defined(NEED_ASNPRINTF) || defined(NEED_VASPRINTF) || defined(NEED_VASNPRINTF)
48 # if defined(NEED_SNPRINTF_ONLY)
49 # undef NEED_SNPRINTF_ONLY
51 # if !defined(PREFER_PORTABLE_SNPRINTF)
52 # define PREFER_PORTABLE_SNPRINTF
57 extern int portable_snprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...);
59 extern int snprintf(char *, size_t, const char *, /*args*/ ...);
60 extern int vsnprintf(char *, size_t, const char *, va_list);
64 #define portable_snprintf snprintf
65 #define portable_vsnprintf vsnprintf
68 #ifndef CLOCKS_PER_SEC
69 #define CLOCKS_PER_SEC 100
72 #define min(a,b) ((a)<(b) ? (a) : (b))
73 #define max(a,b) ((a)>(b) ? (a) : (b))
75 extern int asprintf (char **ptr, const char *fmt, /*args*/ ...);
76 extern int vasprintf (char **ptr, const char *fmt, va_list ap);
77 extern int asnprintf (char **ptr, size_t str_m, const char *fmt, /*args*/ ...);
78 extern int vasnprintf(char **ptr, size_t str_m, const char *fmt, va_list ap);
80 #ifndef NEED_SNPRINTF_ONLY
81 int wrap_vsnprintf(char *str, size_t str_m, const char *fmt, /*args*/ ...);
82 int wrap_vsnprintf(char *str, size_t str_m, const char *fmt, ...) {
87 str_l = vsnprintf(str, str_m, fmt, ap);
94 int wrap_vasprintf(char **ptr, const char *fmt, /*args*/ ...);
95 int wrap_vasprintf(char **ptr, const char *fmt, ...) {
100 str_l = vasprintf(ptr, fmt, ap);
106 #ifdef NEED_VASNPRINTF
107 int wrap_vasnprintf(char **ptr, size_t str_m, const char *fmt, /*args*/ ...);
108 int wrap_vasnprintf(char **ptr, size_t str_m, const char *fmt, ...) {
113 str_l = vasnprintf(ptr, str_m, fmt, ap);
119 int main(int argc, char *argv[]) {
120 char str1[256], str2[256];
124 int len1, len2, len3;
126 size_t str_m = 20; /* declared str size */
130 const int cnt = 100000;
140 printf("\n\nsize = %d\n", (int)size);
141 p = malloc(size); assert(p);
142 memset(p,'h',size); p[size-1] = '\0';
145 printf("\ndetermine breakeven point to see when it is worth\n");
146 printf("calling memcpy and when to do inline string copy\n");
147 printf("str_l, memcpy, inline\n");
148 for (breakpoint=0; breakpoint<=35; breakpoint++) {
149 register size_t nnn = (size_t)breakpoint;
151 for (j=10*cnt; j>0; j--) memcpy(str, p, nnn);
152 t = clock(); printf(" %1.3f", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
153 for (j=10*cnt; j>0; j--) {
154 register size_t nn = (size_t)breakpoint;
156 register char *dd; register const char *ss;
157 for (ss=p, dd=str; nn>0; nn--) *dd++ = *ss++;
160 t = clock(); printf(" %1.3f\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
163 printf("\nmeasuring time to SKIP a long format with no conversions\n");
164 p[0] = '%'; p[1] = 's';
165 for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,p,"1234567890");
166 t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
167 for (j=cnt; j>0; j--) l2=portable_snprintf(str,(size_t)8,p,"1234567890");
168 t = clock(); printf("t_port = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
172 printf("\nmeasuring time to copy a long format with no conversions\n");
173 for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,p);
174 t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
175 for (j=cnt; j>0; j--) l2=portable_snprintf(str,sizeof(str),p);
176 t = clock(); printf("t_port = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
178 for (j=cnt; j>0; j--) sprintf(str,p);
179 t = clock(); printf("t_sys = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
181 printf("\nmeasuring time to copy a long format with one conversion\n");
183 for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,p);
184 t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
185 for (j=cnt; j>0; j--) l2=portable_snprintf(str,sizeof(str),p);
186 t = clock(); printf("t_port = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
188 for (j=cnt; j>0; j--) sprintf(str,p);
189 t = clock(); printf("t_sys = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
191 printf("\nmeasuring string argument copy speed\n");
192 for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,"%.18000s",p);
193 t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
194 for (j=cnt; j>0; j--) l2=portable_snprintf(str,sizeof(str),"%.18000s",p);
195 t = clock(); printf("t_port = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
197 for (j=cnt; j>0; j--) sprintf(str,"%.18000s",p);
198 t = clock(); printf("t_sys = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
200 printf("\nmeasuring left padding speed\n");
202 for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,"%-18000s",p);
203 t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
204 for (j=cnt; j>0; j--) l2=portable_snprintf(str,sizeof(str),"%-18000s",p);
205 t = clock(); printf("t_port = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
207 for (j=cnt; j>0; j--) sprintf(str,"%-18000s",p);
208 t = clock(); printf("t_sys = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
210 printf("\nmeasuring right padding speed\n");
212 for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,"%18000s",p);
213 t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
214 for (j=cnt; j>0; j--) l2=portable_snprintf(str,sizeof(str),"%18000s",p);
215 t = clock(); printf("t_port = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
217 for (j=cnt; j>0; j--) sprintf(str,"%18000s",p);
218 t = clock(); printf("t_sys = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
220 printf("\nmeasuring zero padding speed\n");
221 for (j=cnt; j>0; j--) l1=portable_snprintf(NULL,(size_t)0,"%018000d",1);
222 t = clock(); printf("t_port_nul = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
223 for (j=cnt; j>0; j--) l2=portable_snprintf(str,sizeof(str),"%018000d",1);
224 t = clock(); printf("t_port = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
226 for (j=cnt; j>0; j--) sprintf(str,"%018000d",1);
227 t = clock(); printf("t_sys = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
229 printf("\nmeasuring system's sprintf to efficiently handle truncated strings\n");
230 memset(p,'h',size); p[size-1] = '\0';
232 for (j=cnt; j>0; j--) len = strlen(p);
233 printf("len = %d\n", len);
234 t = clock(); printf("t_strlen = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
235 /* test if the system sprintf scans the whole string (e.g. by strlen)
236 * before recognizing this was a bad idea since the format specified
237 * a truncated string precision, e.g. "%.8s" .
239 for (j=cnt; j>0; j--) sprintf(str,"%.2s",p);
240 t = clock(); printf("t_sys = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
242 for (j=cnt; j>0; j--) snprintf(str,sizeof(str),"%.2s",p);
243 t = clock(); printf("t_sys = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
245 for (j=cnt; j>0; j--) portable_snprintf(str,sizeof(str),"%.2s",p);
246 t = clock(); printf("t_port = %1.3f s\n", (float)(t-t0)/CLOCKS_PER_SEC); t0 = t;
253 /* preliminary halfhearted test */
255 const char fmt[] = "Bla%.4s%05iHE%%%-50sTail";
256 char *ptr4=0, *ptr5=0, *ptr6=0, *ptr7=0;
260 printf("\npreliminary test: snprintf\n");
261 len1 = snprintf(str1, str_m, fmt, "abcdef",-12,"str");
262 len1f = snprintf(str_full, sizeof(str_full), fmt, "abcdef",-12,"str");
264 assert(memcmp(str1,str_full,min(len1,str_m-1)) == 0);
265 assert(str1[str_m-1] == '\0');
266 assert(str_full[sizeof(str_full)-1] == '\0');
268 #ifndef NEED_SNPRINTF_ONLY
269 printf("preliminary test: vsnprintf\n");
270 len2 = wrap_vsnprintf(str2, str_m, fmt, "abcdef",-12,"str");
272 assert(memcmp(str1,str2,min(len1+1,str_m)) == 0);
273 assert(str2[str_m-1] == '\0');
277 printf("preliminary test: asprintf\n");
278 len4 = asprintf(&ptr4, fmt, "abcdef",-12,"str");
281 assert(memcmp(str_full,ptr4,min(len4+1,sizeof(str_full))) == 0);
282 assert(ptr4[len4] == '\0');
285 #ifdef NEED_ASNPRINTF
286 printf("preliminary test: asnprintf\n");
287 len5 = asnprintf(&ptr5, str_m, fmt, "abcdef",-12,"str");
290 assert(memcmp(str1,ptr5,min(len5+1,str_m)) == 0);
291 assert(ptr5[len5] == '\0');
294 #ifdef NEED_VASPRINTF
295 printf("preliminary test: vasprintf\n");
296 len6 = wrap_vasprintf(&ptr6, fmt, "abcdef",-12,"str");
299 assert(memcmp(str_full,ptr6,min(len6+1,sizeof(str_full))) == 0);
300 assert(ptr6[len6] == '\0');
303 #ifdef NEED_VASNPRINTF
304 printf("preliminary test: vasnprintf\n");
305 len7 = wrap_vasnprintf(&ptr7, str_m, fmt, "abcdef",-12,"str");
308 assert(memcmp(str1,ptr7,min(len7+1,str_m)) == 0);
309 assert(ptr7[len7] == '\0');
312 if (ptr4) free(ptr4);
313 if (ptr5) free(ptr5);
314 if (ptr6) free(ptr6);
315 if (ptr7) free(ptr7);
318 /* second preliminary halfhearted test */
320 printf("\nsecond preliminary test:\n");
323 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
324 len1 = snprintf(str1, sizeof(str1), "");
325 len2 = sprintf (str2, "");
327 assert(memcmp(str1,str2,(size_t)len1) == 0);
330 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
331 len1 = snprintf(str1, sizeof(str1), "YK");
332 len2 = sprintf (str2, "YK");
334 assert(memcmp(str1,str2,(size_t)len1) == 0);
337 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
338 len1 = snprintf(str1, sizeof(str1), "%+d",0);
339 len2 = sprintf (str2, "%+d",0);
341 assert(memcmp(str1,str2,(size_t)len1) == 0);
344 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
345 len1 = snprintf(str1, sizeof(str1), "%.2147483647s", "13");
346 len2 = sprintf (str2, "%.2147483647s", "13");
347 printf("len1=%d, len2=%d\n", len1,len2);
349 assert(memcmp(str1,str2,(size_t)len1) == 0);
352 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
353 len1 = snprintf(str1, sizeof(str1), "%.2147483648s", "13");
354 len2 = sprintf (str2, "%.2147483648s", "13");
355 printf("len1=%d, len2=%d\n", len1,len2);
357 assert(memcmp(str1,str2,(size_t)len1) == 0);
360 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
361 len1 = snprintf(str1, sizeof(str1), "%.2147483649s", "13");
362 len2 = sprintf (str2, "%.2147483649s", "13");
363 printf("len1=%d, len2=%d\n", len1,len2);
365 assert(memcmp(str1,str2,(size_t)len1) == 0);
368 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
369 len1 = snprintf(str1, sizeof(str1), "%-.2147483647s", "13");
370 len2 = sprintf (str2, "%-.2147483647s", "13");
371 printf("len1=%d, len2=%d\n", len1,len2);
373 assert(memcmp(str1,str2,(size_t)len1) == 0);
376 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
377 len1 = snprintf(str1, sizeof(str1), "%-.2147483648s", "13");
378 len2 = sprintf (str2, "%-.2147483648s", "13");
379 printf("len1=%d, len2=%d\n", len1,len2);
381 assert(memcmp(str1,str2,(size_t)len1) == 0);
384 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
385 len1 = snprintf(str1, sizeof(str1), "%.4294967295s", "13");
386 len2 = sprintf (str2, "%.4294967295s", "13");
387 printf("len1=%d, len2=%d\n", len1,len2);
389 assert(memcmp(str1,str2,(size_t)len1) == 0);
392 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
393 len1 = snprintf(str1, sizeof(str1), "%.4294967296s", "13");
394 len2 = sprintf (str2, "%.4294967296s", "13");
395 printf("len1=%d, len2=%d\n", len1,len2);
397 assert(memcmp(str1,str2,(size_t)len1) == 0);
401 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
402 len1 = snprintf(str1, sizeof(str1), "%.*s", 2147483647,"13");
403 len2 = sprintf (str2, "%.*s", 2147483647,"13");
404 printf("len1=%d, len2=%d\n", len1,len2);
406 assert(memcmp(str1,str2,(size_t)len1) == 0);
409 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
410 len1 = snprintf(str1, sizeof(str1), "%.*s", 2147483648U,"13");
411 len2 = sprintf (str2, "%.*s", 2147483648U,"13");
412 printf("len1=%d, len2=%d\n", len1,len2);
414 assert(memcmp(str1,str2,(size_t)len1) == 0);
417 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
418 len1 = snprintf(str1, sizeof(str1), "%-.*s", 2147483647,"13");
419 len2 = sprintf (str2, "%-.*s", 2147483647,"13");
420 printf("len1=%d, len2=%d\n", len1,len2);
422 assert(memcmp(str1,str2,(size_t)len1) == 0);
425 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
426 len1 = snprintf(str1, sizeof(str1), "%-.*s", 2147483648U,"13");
427 len2 = sprintf (str2, "%-.*s", 2147483648U,"13");
428 printf("len1=%d, len2=%d\n", len1,len2);
430 assert(memcmp(str1,str2,(size_t)len1) == 0);
433 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
434 len1 = snprintf(str1, sizeof(str1), "%.*s", 4294967295U,"13");
435 len2 = sprintf (str2, "%.*s", 4294967295U,"13");
436 printf("len1=%d, len2=%d\n", len1,len2);
438 assert(memcmp(str1,str2,(size_t)len1) == 0);
441 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
442 len1 = snprintf(str1, sizeof(str1), "%.*s", 4294967296U,"13");
443 /* len2 = sprintf (str2, "%.*s", 4294967296U,"13"); */ /* core dumps on HPUX */
444 /* assert(len1==len2);
445 * assert(memcmp(str1,str2,(size_t)len1) == 0);
450 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
451 len1 = snprintf(str1, sizeof(str1), "%c",'A');
452 len2 = sprintf (str2, "%c",'A');
454 assert(memcmp(str1,str2,(size_t)len1) == 0);
457 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
458 len1 = snprintf(str1, sizeof(str1), "%10c",'A');
459 len2 = sprintf (str2, "%10c",'A');
461 assert(memcmp(str1,str2,(size_t)len1) == 0);
464 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
465 len1 = snprintf(str1, sizeof(str1), "%-10c",'A');
466 len2 = sprintf (str2, "%-10c",'A');
468 assert(memcmp(str1,str2,(size_t)len1) == 0);
471 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
472 len1 = snprintf(str1, sizeof(str1), "%.10c",'A');
473 len2 = sprintf (str2, "%.10c",'A');
475 assert(memcmp(str1,str2,(size_t)len1) == 0);
478 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
479 len1 = snprintf(str1, sizeof(str1), "%-.10c",'A');
480 len2 = sprintf (str2, "%-.10c",'A');
482 assert(memcmp(str1,str2,(size_t)len1) == 0);
485 printf("test 100\n");
486 memset(str1,'x',sizeof(str1)); memset(str2,'x',sizeof(str2));
487 len1 = snprintf(str1, (size_t)8, "blaBhb%shehe%cX","ABCD",'1');
488 len2 = sprintf (str2, "blaBhb%shehe%cX","ABCD",'1');
490 assert(memcmp(str1,str2,(size_t)7) == 0);
491 assert(str1[7] == '\0');
492 assert(memcmp(str1+14,str2+16,(size_t)(len1-16)) == 0);
496 /* testing for correctness and compatibility */
498 char *c; int alldigits = 1;
499 for (c=argv[2]; *c; c++)
500 if (! (*c == '-' || (*c >= '0' && *c <= '9'))) alldigits = 0;
502 int j = atoi(argv[2]);
503 len1 = portable_snprintf(str1, str_m, argv[1], j, 3);
504 len2 = sprintf(str2, argv[1], j, 3);
506 len3 = snprintf(str3, str_m, argv[1], j, 3);
509 len1 = portable_snprintf(str1, str_m, argv[1], argv[2], 3);
510 len2 = sprintf(str2, argv[1], argv[2], 3);
512 len3 = snprintf(str3, str_m, argv[1], argv[2], 3);
515 printf("portable: |%s| len = %d\n", str1, len1);
516 printf("sys sprintf: |%s| len = %d\n", str2, len2);
518 printf("sys snprintf: |%s| len = %d\n", str3, len3);
520 } else { /* exhaustive testing */
522 const char flags[] = "+- 0#"; /* set of test flags (including '\0')*/
523 int flags_l = strlen(flags);
525 const char fspec[] = "scdpoxXuiy"; /* set of test formats (including '\0') */
526 int fspec_l = strlen(fspec);
528 #ifdef SNPRINTF_LONGLONG_SUPPORT
529 const char datatype[] = " hl2"; /* set of datatypes */
531 const char datatype[] = " hl"; /* set of datatypes */
533 int datatype_l = strlen(datatype);
535 const long int iargs[] = /* set of numeric test arguments */
536 { 0,1,9,10,28,99,100,127,128,129,998,1000,32767,32768,32769,
537 -1,-9,-10,-28,-99,-100,-127,-128,-129,
538 -998,-1000,-32767,-32768,-32769 };
539 int iargs_l = sizeof(iargs)/sizeof(iargs[0]);
540 const char *sargs[] = /* set of string test arguments */
541 { "", "a", "0", "-ab", "abcde", "abcdefghijk mnopqrstuv" };
542 int sargs_l = sizeof(sargs)/sizeof(sargs[0]);
546 int a, fs, fl1, fl2, fl3, fl4, fl5, fw, fp, dt;
548 for (fs=0; fs<=fspec_l; fs++) { /* format specifier */
549 int strtype = (fspec[fs] == 's' || fspec[fs] == '%');
550 int args_l = (strtype ? sargs_l : iargs_l);
552 for (fw= -1; fw<=3; fw++) { /* minimal field width */
554 printf("Trying format %%");
555 if (fw >= 0) printf("%d", fw);
556 if (fspec[fs]) putchar(fspec[fs]);
559 for (fp= -2; fp<=3; fp++) { /* format field precision */
561 /* data type modifiers */
562 for (dt=0; dt < ((strtype||fspec[fs]=='c') ? 1 : datatype_l); dt++) {
564 int dataty = datatype[dt];
566 if (fspec[fs] == 'D' || fspec[fs] == 'U' || fspec[fs] == 'O')
569 if (fspec[fs] == 'p' && dataty == '2') continue;
571 for (fl1=0; fl1<=flags_l; fl1++) { /* flags */
572 for (fl2=0; fl2<=flags_l; fl2++) {
573 for (fl3=0; fl3<=flags_l; fl3++) {
574 for (fl4=0; fl4<=flags_l; fl4++) {
575 for (fl5=0; fl5<=flags_l; fl5++) {
577 for (a=0; a<args_l; a++) { /* test arguments */
579 fmt_l = 0; fmt[fmt_l++] = '%';
580 if (flags[fl1]) fmt[fmt_l++] = flags[fl1];
581 if (flags[fl2]) fmt[fmt_l++] = flags[fl2];
582 if (flags[fl3]) fmt[fmt_l++] = flags[fl3];
583 if (flags[fl4]) fmt[fmt_l++] = flags[fl4];
584 if (flags[fl5]) fmt[fmt_l++] = flags[fl5];
585 if (fw >= 0) fmt_l += sprintf(fmt+fmt_l, "%d", fw);
588 if (fp >= 0) fmt_l += sprintf(fmt+fmt_l, "%d", fp);
591 { fmt[fmt_l++] = 'l'; fmt[fmt_l++] = 'l'; }
592 else if (dataty != ' ')
593 { fmt[fmt_l++] = dataty; }
595 if (fspec[fs]) fmt[fmt_l++] = fspec[fs];
598 if (a==0 && fl1==flags_l && fl2==flags_l && fl3==flags_l
599 && fl4==flags_l && fl5==flags_l) printf("%s\n", fmt);
602 memset(str1,'G',sizeof(str1));
603 memset(str2,'G',sizeof(str2));
604 memset(str3,'G',sizeof(str3));
606 len1 = len2 = len3 = 0;
608 len1 = portable_snprintf(str1, str_m, fmt, sargs[a]);
609 len2 = sprintf(str2, fmt, sargs[a]);
611 len3 = snprintf(str3, str_m, fmt, sargs[a]);
613 } else if (fspec[fs] == 'p') {
614 len1 = portable_snprintf(str1, str_m, fmt, (void *)iargs[a]);
615 len2 = sprintf(str2, fmt, (void *)iargs[a]);
617 len3 = snprintf(str3, str_m, fmt, (void *)iargs[a]);
622 len1 = portable_snprintf(str1, str_m, fmt, (int) iargs[a]);
623 len2 = sprintf(str2, fmt, (int) iargs[a]);
625 len3 = snprintf(str3, str_m, fmt, (int) iargs[a]);
629 len1 = portable_snprintf(str1, str_m, fmt, (short int)iargs[a]);
630 len2 = sprintf(str2, fmt, (short int)iargs[a]);
632 len3 = snprintf(str3, str_m, fmt, (short int)iargs[a]);
636 len1 = portable_snprintf(str1, str_m, fmt, (long int)iargs[a]);
637 len2 = sprintf(str2, fmt, (long int)iargs[a]);
639 len3 = snprintf(str3, str_m, fmt, (long int)iargs[a]);
642 #ifdef SNPRINTF_LONGLONG_SUPPORT
644 len1 = portable_snprintf(str1, str_m, fmt, (long long int)iargs[a]);
645 len2 = sprintf(str2, fmt, (long long int)iargs[a]);
647 len3 = snprintf(str3, str_m, fmt, (long long int)iargs[a]);
656 } else if (len1 != len3 ||
657 memcmp(str1,str3,min(len1+20,sizeof(str1))) != 0) {
659 if (strtype) printf("\n2: %s, <%s>\n", fmt, sargs[a]);
660 else printf("\n2: %s, %ld\n", fmt, iargs[a]);
661 printf("portable: |%s| len = %d\n", str1, len1);
662 printf("sys sprintf: |%s| len = %d\n", str2, len2);
663 printf("sys snprintf: |%s| len = %d\n", str3, len3);
665 } else if (len1 != len2 ||
666 (len1>0 && memcmp(str1,str2,min(len1,str_m)-1) != 0)) {
668 if (strtype) printf("\n1: %s, <%s>\n", fmt, sargs[a]);
669 else printf("\n1: %s, %ld\n", fmt, iargs[a]);
670 printf("portable: |%s| len = %d\n", str1, len1);
671 printf("sys sprintf: |%s| len = %d\n", str2, len2);