mirrors/cosmopolitan
1
0
Fork 0
mirror of https://github.com/jart/cosmopolitan.git synced 2025-05-28 00:02:28 +00:00
Code Issues Projects Releases Packages Wiki Activity Actions 1

Remove printf() linking hack

Browse source
This commit is contained in:
Justine Tunney 2023-06-17 10:13:50 -07:00
parent ba03cd95c5
commit b881c0ec9e
No known key found for this signature in database
GPG key ID: BE714B4575D6E328
107 changed files with 1520 additions and 2577 deletions
Download patch file Download diff file Expand all files Collapse all files

411
test/libc/stdio/fmt_test.c Normal file
View file

@ -0,0 +1,411 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2021 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/fmt/fmt.h"
#include "libc/limits.h"
#include "libc/log/log.h"
#include "libc/math.h"
#include "libc/mem/gc.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
#include "libc/x/xasprintf.h"
TEST(fmt, d) {
EXPECT_STREQ("-123", _gc(xasprintf("%d", -123)));
EXPECT_STREQ("-1", _gc(xasprintf("%d", -1)));
EXPECT_STREQ("1", _gc(xasprintf("%d", 1)));
EXPECT_STREQ("16", _gc(xasprintf("%d", 16)));
EXPECT_STREQ("2147483647", _gc(xasprintf("%d", INT_MAX)));
EXPECT_STREQ("-2147483648", _gc(xasprintf("%d", INT_MIN)));
EXPECT_STREQ(" -123", _gc(xasprintf("%10d", -123)));
EXPECT_STREQ(" -1", _gc(xasprintf("%10d", -1)));
EXPECT_STREQ(" 1", _gc(xasprintf("%10d", 1)));
EXPECT_STREQ(" 16", _gc(xasprintf("%10d", 16)));
EXPECT_STREQ("2147483647", _gc(xasprintf("%10d", INT_MAX)));
EXPECT_STREQ("-2147483648", _gc(xasprintf("%10d", INT_MIN)));
EXPECT_STREQ("-000000123", _gc(xasprintf("%010d", -123)));
EXPECT_STREQ("-000000001", _gc(xasprintf("%010d", -1)));
EXPECT_STREQ("0000000001", _gc(xasprintf("%010d", 1)));
EXPECT_STREQ("0000000016", _gc(xasprintf("%010d", 16)));
EXPECT_STREQ("2147483647", _gc(xasprintf("%010d", INT_MAX)));
EXPECT_STREQ("-2147483648", _gc(xasprintf("%010d", INT_MIN)));
EXPECT_STREQ("-123 ", _gc(xasprintf("%-10d", -123)));
EXPECT_STREQ("-1 ", _gc(xasprintf("%-10d", -1)));
EXPECT_STREQ("1 ", _gc(xasprintf("%-10d", 1)));
EXPECT_STREQ("16 ", _gc(xasprintf("%-10d", 16)));
EXPECT_STREQ("2147483647", _gc(xasprintf("%-10d", INT_MAX)));
EXPECT_STREQ("-2147483648", _gc(xasprintf("%-10d", INT_MIN)));
EXPECT_STREQ(" -123", _gc(xasprintf("%+10d", -123)));
EXPECT_STREQ(" -1", _gc(xasprintf("%+10d", -1)));
EXPECT_STREQ(" +1", _gc(xasprintf("%+10d", 1)));
EXPECT_STREQ(" +16", _gc(xasprintf("%+10d", 16)));
EXPECT_STREQ("+2147483647", _gc(xasprintf("%+10d", INT_MAX)));
EXPECT_STREQ("-2147483648", _gc(xasprintf("%+10d", INT_MIN)));
EXPECT_STREQ("-123", _gc(xasprintf("% d", -123)));
EXPECT_STREQ("-1", _gc(xasprintf("% d", -1)));
EXPECT_STREQ(" 1", _gc(xasprintf("% d", 1)));
EXPECT_STREQ(" 16", _gc(xasprintf("% d", 16)));
EXPECT_STREQ(" 2147483647", _gc(xasprintf("% d", INT_MAX)));
EXPECT_STREQ("-2147483648", _gc(xasprintf("% d", INT_MIN)));
EXPECT_STREQ("042 ", _gc(xasprintf("%-4.3d", 42)));
EXPECT_STREQ("-00054", _gc(xasprintf("%-1.5lld", -54ll)));
EXPECT_STREQ("00109", _gc(xasprintf("%-.5lld", 109ll)));
EXPECT_STREQ("-00116", _gc(xasprintf("%-.5lld", -116ll)));
EXPECT_STREQ("00108 ", _gc(xasprintf("%-8.5lld", 108ll)));
EXPECT_STREQ("-00054 ", _gc(xasprintf("%-8.5lld", -54ll)));
}
TEST(fmt, u) {
EXPECT_STREQ("042 ", _gc(xasprintf("%-4.3u", 42)));
}
TEST(fmt, x) {
EXPECT_STREQ("0x01 ", _gc(xasprintf("%#-07.2x", 1)));
EXPECT_STREQ("0x00136d ", _gc(xasprintf("%#-010.6x", 4973)));
EXPECT_STREQ("0X1", _gc(xasprintf("%#X", 1)));
EXPECT_STREQ("0XA", _gc(xasprintf("%#X", 10)));
EXPECT_STREQ("0XFFFF", _gc(xasprintf("%#X", 65535)));
EXPECT_STREQ("0XABCDEF", _gc(xasprintf("%#X", 0xABCDEF)));
EXPECT_STREQ("0X1", _gc(xasprintf("%#hX", (short)1)));
EXPECT_STREQ("0XA", _gc(xasprintf("%#hX", (short)10)));
EXPECT_STREQ("0XFFFF", _gc(xasprintf("%#hX", (short)65535)));
EXPECT_STREQ("0XABCD", _gc(xasprintf("%#hX", (short)0xABCD)));
EXPECT_STREQ(" 0X308C6705", _gc(xasprintf("%#20X", 814507781)));
EXPECT_STREQ("0X0000000000308C6705", _gc(xasprintf("%#020X", 814507781)));
EXPECT_STREQ(" 0X6705",
_gc(xasprintf("%#20hX", (short)814507781)));
EXPECT_STREQ("0X000000000000006705",
_gc(xasprintf("%#020hX", (short)814507781)));
EXPECT_STREQ(" 0XABCDEF", _gc(xasprintf("%#20X", 0xABCDEF)));
EXPECT_STREQ("0X000000000000ABCDEF", _gc(xasprintf("%#020X", 0xABCDEF)));
EXPECT_STREQ(" 0XCDEF",
_gc(xasprintf("%#20hX", (short)0xABCDEF)));
EXPECT_STREQ("0X00000000000000CDEF",
_gc(xasprintf("%#020hX", (short)0xABCDEF)));
}
TEST(fmt, o) {
EXPECT_STREQ("0000000000000037777777634", _gc(xasprintf("%#.25o", -100)));
EXPECT_STREQ("0001777777777777777777634", _gc(xasprintf("%#.25lo", -100L)));
EXPECT_STREQ("0001777777777777777777634", _gc(xasprintf("%#.25llo", -100LL)));
EXPECT_STREQ("0", _gc(xasprintf("%#.o", 0)));
EXPECT_STREQ(" 056520", _gc(xasprintf("%#8.6o", 23888)));
EXPECT_STREQ("00144 ", _gc(xasprintf("%#-8.5llo", 100ll)));
EXPECT_STREQ("0 ", _gc(xasprintf("%-#02lo", 0l)));
EXPECT_STREQ("0", _gc(xasprintf("%#01lo", 0l)));
EXPECT_STREQ("00", _gc(xasprintf("%#02lo", 0l)));
}
TEST(fmt, b) {
EXPECT_STREQ("000010100 ", _gc(xasprintf("%-14.9b", 20)));
EXPECT_STREQ("0b110", _gc(xasprintf("%#b", 6)));
}
TEST(fmt, s) {
EXPECT_STREQ("123456", _gc(xasprintf("%4.*s", -5, "123456")));
EXPECT_STREQ("123456789", _gc(xasprintf("%4.*s", -5, "123456789")));
EXPECT_STREQ("12345678901234567890",
_gc(xasprintf("%4.*s", -5, "12345678901234567890")));
EXPECT_STREQ("123456789012345678901234567890",
_gc(xasprintf("%4.*s", -5, "123456789012345678901234567890")));
EXPECT_STREQ(
"1234567890123456789012345678901234567890",
_gc(xasprintf("%4.*s", -5, "1234567890123456789012345678901234567890")));
EXPECT_STREQ(
"12345678901234567890123456789012345678901234567890",
_gc(xasprintf("%4.*s", -5,
"12345678901234567890123456789012345678901234567890")));
EXPECT_STREQ(
"123456789012345678901234567890123456789012345678901234567890",
_gc(xasprintf(
"%4.*s", -5,
"123456789012345678901234567890123456789012345678901234567890")));
EXPECT_STREQ("Wide character output test",
_gc(xasprintf("%S", L"Wide character output test")));
}
TEST(fmt, g) {
EXPECT_STREQ("1", _gc(xasprintf("%g", 1.)));
EXPECT_STREQ(" 1", _gc(xasprintf("% g", 1.)));
EXPECT_STREQ("+1", _gc(xasprintf("%+g", 1.)));
EXPECT_STREQ("-1", _gc(xasprintf("%g", -1.)));
EXPECT_STREQ("10", _gc(xasprintf("%g", 10.)));
EXPECT_STREQ("-10", _gc(xasprintf("%g", -10.)));
EXPECT_STREQ("1e+01", _gc(xasprintf("%.0g", 10.)));
EXPECT_STREQ("-1e+01", _gc(xasprintf("%.0g", -10.)));
EXPECT_STREQ("1", _gc(xasprintf("%.0g", 1.0)));
EXPECT_STREQ("1e-05", _gc(xasprintf("%.0g", 0.00001)));
EXPECT_STREQ("0.0001", _gc(xasprintf("%.0g", 0.0001)));
EXPECT_STREQ("1e+01", _gc(xasprintf("%.1g", 10.)));
EXPECT_STREQ("-1e+01", _gc(xasprintf("%.1g", -10.)));
EXPECT_STREQ("1", _gc(xasprintf("%.1g", 1.0)));
EXPECT_STREQ("1e-05", _gc(xasprintf("%.1g", 0.00001)));
EXPECT_STREQ("0.0001", _gc(xasprintf("%.1g", 0.0001)));
EXPECT_STREQ("0.007812", _gc(xasprintf("%.4g", 0.0078125)));
EXPECT_STREQ("0.023438", _gc(xasprintf("%.5g", 0.0234375)));
EXPECT_STREQ("1e+100", _gc(xasprintf("%g", 1e100)));
EXPECT_STREQ("1e-100", _gc(xasprintf("%g", 1e-100)));
EXPECT_STREQ("-1e-100", _gc(xasprintf("%g", -1e-100)));
EXPECT_STREQ("0.123456", _gc(xasprintf("%g", 0.1234564)));
EXPECT_STREQ("0.123457", _gc(xasprintf("%g", 0.1234566)));
EXPECT_STREQ("3.14159", _gc(xasprintf("%g", 0x1.921fb54442d1846ap+1)));
EXPECT_STREQ("0", _gc(xasprintf("%g", 0.)));
EXPECT_STREQ("-0", _gc(xasprintf("%g", -0.)));
EXPECT_STREQ("nan", _gc(xasprintf("%g", NAN)));
EXPECT_STREQ("-nan", _gc(xasprintf("%g", -NAN)));
EXPECT_STREQ("inf", _gc(xasprintf("%g", INFINITY)));
EXPECT_STREQ("-inf", _gc(xasprintf("%g", -INFINITY)));
EXPECT_STREQ("2.22507e-308", _gc(xasprintf("%g", __DBL_MIN__)));
EXPECT_STREQ("1.79769e+308", _gc(xasprintf("%g", __DBL_MAX__)));
EXPECT_STREQ("0", _gc(xasprintf("%G", 0.)));
EXPECT_STREQ("-0", _gc(xasprintf("%G", -0.)));
EXPECT_STREQ("NAN", _gc(xasprintf("%G", NAN)));
EXPECT_STREQ("-NAN", _gc(xasprintf("%G", -NAN)));
EXPECT_STREQ("INF", _gc(xasprintf("%G", INFINITY)));
EXPECT_STREQ("-INF", _gc(xasprintf("%G", -INFINITY)));
EXPECT_STREQ("2.22507E-308", _gc(xasprintf("%G", __DBL_MIN__)));
EXPECT_STREQ("1.79769E+308", _gc(xasprintf("%G", __DBL_MAX__)));
EXPECT_STREQ(" 0", _gc(xasprintf("%13g", 0.)));
EXPECT_STREQ(" -0", _gc(xasprintf("%13g", -0.)));
EXPECT_STREQ(" nan", _gc(xasprintf("%13g", NAN)));
EXPECT_STREQ(" -nan", _gc(xasprintf("%13g", -NAN)));
EXPECT_STREQ(" inf", _gc(xasprintf("%13g", INFINITY)));
EXPECT_STREQ(" -inf", _gc(xasprintf("%13g", -INFINITY)));
EXPECT_STREQ(" 2.22507e-308", _gc(xasprintf("%13g", __DBL_MIN__)));
EXPECT_STREQ(" 1.79769e+308", _gc(xasprintf("%13g", __DBL_MAX__)));
EXPECT_STREQ(" 0", _gc(xasprintf("%13G", 0.)));
EXPECT_STREQ(" -0", _gc(xasprintf("%13G", -0.)));
EXPECT_STREQ(" NAN", _gc(xasprintf("%13G", NAN)));
EXPECT_STREQ(" -NAN", _gc(xasprintf("%13G", -NAN)));
EXPECT_STREQ(" INF", _gc(xasprintf("%13G", INFINITY)));
EXPECT_STREQ(" -INF", _gc(xasprintf("%13G", -INFINITY)));
EXPECT_STREQ(" 2.22507E-308", _gc(xasprintf("%13G", __DBL_MIN__)));
EXPECT_STREQ(" 1.79769E+308", _gc(xasprintf("%13G", __DBL_MAX__)));
}
TEST(fmt, f) {
EXPECT_STREQ("3.141593", _gc(xasprintf("%f", 0x1.921fb54442d1846ap+1)));
EXPECT_STREQ("3.1415926535897931",
_gc(xasprintf("%.16f", 0x1.921fb54442d1846ap+1)));
EXPECT_STREQ("100000000000000001590289110975991804683608085639452813"
"89781327557747838772170381060813469985856815104.000000",
_gc(xasprintf("%f", 1e100)));
EXPECT_STREQ("0.000000", _gc(xasprintf("%f", 0.)));
EXPECT_STREQ("-0.000000", _gc(xasprintf("%f", -0.)));
EXPECT_STREQ("nan", _gc(xasprintf("%f", NAN)));
EXPECT_STREQ("-nan", _gc(xasprintf("%f", -NAN)));
EXPECT_STREQ("inf", _gc(xasprintf("%f", INFINITY)));
EXPECT_STREQ("-inf", _gc(xasprintf("%f", -INFINITY)));
EXPECT_STREQ("0.000000", _gc(xasprintf("%f", __DBL_MIN__)));
EXPECT_STREQ(
"179769313486231570814527423731704356798070567525844996598917476803157260"
"780028538760589558632766878171540458953514382464234321326889464182768467"
"546703537516986049910576551282076245490090389328944075868508455133942304"
"583236903222948165808559332123348274797826204144723168738177180919299881"
"250404026184124858368.000000",
_gc(xasprintf("%f", __DBL_MAX__)));
EXPECT_STREQ("0.000000", _gc(xasprintf("%F", 0.)));
EXPECT_STREQ("-0.000000", _gc(xasprintf("%F", -0.)));
EXPECT_STREQ("NAN", _gc(xasprintf("%F", NAN)));
EXPECT_STREQ("-NAN", _gc(xasprintf("%F", -NAN)));
EXPECT_STREQ("INF", _gc(xasprintf("%F", INFINITY)));
EXPECT_STREQ("-INF", _gc(xasprintf("%F", -INFINITY)));
EXPECT_STREQ("0.000000", _gc(xasprintf("%F", __DBL_MIN__)));
EXPECT_STREQ(
"179769313486231570814527423731704356798070567525844996598917476803157260"
"780028538760589558632766878171540458953514382464234321326889464182768467"
"546703537516986049910576551282076245490090389328944075868508455133942304"
"583236903222948165808559332123348274797826204144723168738177180919299881"
"250404026184124858368.000000",
_gc(xasprintf("%F", __DBL_MAX__)));
EXPECT_STREQ(" 0.000000", _gc(xasprintf("%10f", 0.)));
EXPECT_STREQ(" -0.000000", _gc(xasprintf("%10f", -0.)));
EXPECT_STREQ(" nan", _gc(xasprintf("%10f", NAN)));
EXPECT_STREQ(" -nan", _gc(xasprintf("%10f", -NAN)));
EXPECT_STREQ(" inf", _gc(xasprintf("%10f", INFINITY)));
EXPECT_STREQ(" -inf", _gc(xasprintf("%10f", -INFINITY)));
EXPECT_STREQ(" 0.000000", _gc(xasprintf("%10f", __DBL_MIN__)));
EXPECT_STREQ(
"179769313486231570814527423731704356798070567525844996598917476803157260"
"780028538760589558632766878171540458953514382464234321326889464182768467"
"546703537516986049910576551282076245490090389328944075868508455133942304"
"583236903222948165808559332123348274797826204144723168738177180919299881"
"250404026184124858368.000000",
_gc(xasprintf("%10f", __DBL_MAX__)));
EXPECT_STREQ(" 0.000000", _gc(xasprintf("%10F", 0.)));
EXPECT_STREQ(" -0.000000", _gc(xasprintf("%10F", -0.)));
EXPECT_STREQ(" NAN", _gc(xasprintf("%10F", NAN)));
EXPECT_STREQ(" -NAN", _gc(xasprintf("%10F", -NAN)));
EXPECT_STREQ(" INF", _gc(xasprintf("%10F", INFINITY)));
EXPECT_STREQ(" -INF", _gc(xasprintf("%10F", -INFINITY)));
EXPECT_STREQ(" 0.000000", _gc(xasprintf("%10F", __DBL_MIN__)));
EXPECT_STREQ(
"179769313486231570814527423731704356798070567525844996598917476803157260"
"780028538760589558632766878171540458953514382464234321326889464182768467"
"546703537516986049910576551282076245490090389328944075868508455133942304"
"583236903222948165808559332123348274797826204144723168738177180919299881"
"250404026184124858368.000000",
_gc(xasprintf("%10F", __DBL_MAX__)));
}
TEST(fmt, e) {
EXPECT_STREQ("3.14159", _gc(xasprintf("%g", 0x1.921fb54442d1846ap+1)));
EXPECT_STREQ("3.141592653589793",
_gc(xasprintf("%.16g", 0x1.921fb54442d1846ap+1)));
EXPECT_STREQ("1.000000e+100", _gc(xasprintf("%e", 1e100)));
EXPECT_STREQ("1.000000E+100", _gc(xasprintf("%E", 1e100)));
EXPECT_STREQ(" 0.000000e+00", _gc(xasprintf("%24e", 0.)));
EXPECT_STREQ(" -0.000000e+00", _gc(xasprintf("%24e", -0.)));
EXPECT_STREQ(" nan", _gc(xasprintf("%24e", NAN)));
EXPECT_STREQ(" -nan", _gc(xasprintf("%24e", -NAN)));
EXPECT_STREQ(" inf", _gc(xasprintf("%24e", INFINITY)));
EXPECT_STREQ(" -inf", _gc(xasprintf("%24e", -INFINITY)));
EXPECT_STREQ(" 2.225074e-308", _gc(xasprintf("%24e", __DBL_MIN__)));
EXPECT_STREQ(" 1.797693e+308", _gc(xasprintf("%24e", __DBL_MAX__)));
EXPECT_STREQ(" 0.000000E+00", _gc(xasprintf("%24E", 0.)));
EXPECT_STREQ(" -0.000000E+00", _gc(xasprintf("%24E", -0.)));
EXPECT_STREQ(" NAN", _gc(xasprintf("%24E", NAN)));
EXPECT_STREQ(" -NAN", _gc(xasprintf("%24E", -NAN)));
EXPECT_STREQ(" INF", _gc(xasprintf("%24E", INFINITY)));
EXPECT_STREQ(" -INF", _gc(xasprintf("%24E", -INFINITY)));
EXPECT_STREQ(" 2.225074E-308", _gc(xasprintf("%24E", __DBL_MIN__)));
EXPECT_STREQ(" 1.797693E+308", _gc(xasprintf("%24E", __DBL_MAX__)));
EXPECT_STREQ(" +0.000000e+00", _gc(xasprintf("%+24e", 0.)));
EXPECT_STREQ(" -0.000000e+00", _gc(xasprintf("%+24e", -0.)));
EXPECT_STREQ(" +nan", _gc(xasprintf("%+24e", NAN)));
EXPECT_STREQ(" -nan", _gc(xasprintf("%+24e", -NAN)));
EXPECT_STREQ(" +inf", _gc(xasprintf("%+24e", INFINITY)));
EXPECT_STREQ(" -inf", _gc(xasprintf("%+24e", -INFINITY)));
EXPECT_STREQ(" +2.225074e-308",
_gc(xasprintf("%+24e", __DBL_MIN__)));
EXPECT_STREQ(" +1.797693e+308",
_gc(xasprintf("%+24e", __DBL_MAX__)));
EXPECT_STREQ(" +0.000000E+00", _gc(xasprintf("%+24E", 0.)));
EXPECT_STREQ(" -0.000000E+00", _gc(xasprintf("%+24E", -0.)));
EXPECT_STREQ(" +NAN", _gc(xasprintf("%+24E", NAN)));
EXPECT_STREQ(" -NAN", _gc(xasprintf("%+24E", -NAN)));
EXPECT_STREQ(" +INF", _gc(xasprintf("%+24E", INFINITY)));
EXPECT_STREQ(" -INF", _gc(xasprintf("%+24E", -INFINITY)));
EXPECT_STREQ(" +2.225074E-308",
_gc(xasprintf("%+24E", __DBL_MIN__)));
EXPECT_STREQ(" +1.797693E+308",
_gc(xasprintf("%+24E", __DBL_MAX__)));
}
TEST(fmt, a) {
EXPECT_STREQ("0x1.921fb54442d18p+1",
_gc(xasprintf("%a", 0x1.921fb54442d1846ap+1)));
EXPECT_STREQ("0X1.921FB54442D18P+1",
_gc(xasprintf("%A", 0x1.921fb54442d1846ap+1)));
EXPECT_STREQ(" 0x0p+0", _gc(xasprintf("%24a", 0.)));
EXPECT_STREQ(" -0x0p+0", _gc(xasprintf("%24a", -0.)));
EXPECT_STREQ(" nan", _gc(xasprintf("%24a", NAN)));
EXPECT_STREQ(" -nan", _gc(xasprintf("%24a", -NAN)));
EXPECT_STREQ(" inf", _gc(xasprintf("%24a", INFINITY)));
EXPECT_STREQ(" -inf", _gc(xasprintf("%24a", -INFINITY)));
EXPECT_STREQ(" 0x1p-1022", _gc(xasprintf("%24a", __DBL_MIN__)));
EXPECT_STREQ(" 0x1.fffffffffffffp+1023", _gc(xasprintf("%24a", __DBL_MAX__)));
EXPECT_STREQ(" 0X0P+0", _gc(xasprintf("%24A", 0.)));
EXPECT_STREQ(" -0X0P+0", _gc(xasprintf("%24A", -0.)));
EXPECT_STREQ(" NAN", _gc(xasprintf("%24A", NAN)));
EXPECT_STREQ(" -NAN", _gc(xasprintf("%24A", -NAN)));
EXPECT_STREQ(" INF", _gc(xasprintf("%24A", INFINITY)));
EXPECT_STREQ(" -INF", _gc(xasprintf("%24A", -INFINITY)));
EXPECT_STREQ(" 0X1P-1022", _gc(xasprintf("%24A", __DBL_MIN__)));
EXPECT_STREQ(" 0X1.FFFFFFFFFFFFFP+1023", _gc(xasprintf("%24A", __DBL_MAX__)));
EXPECT_STREQ(" 0X1.E9A488E8A71DEP+14", _gc(xasprintf("%24A", 31337.1337)));
EXPECT_STREQ(" -0X1.E9A488E8A71DEP+14", _gc(xasprintf("%24A", -31337.1337)));
}
TEST(fmt, p) {
EXPECT_STREQ("0x1", _gc(xasprintf("%p", 1)));
EXPECT_STREQ("0x10", _gc(xasprintf("%p", 16)));
EXPECT_STREQ("0x31337", _gc(xasprintf("%p", 0x31337)));
EXPECT_STREQ("0xffffffff", _gc(xasprintf("%p", 0xffffffff)));
EXPECT_STREQ("0xffff800000031337", _gc(xasprintf("%p", 0xffff800000031337)));
EXPECT_STREQ(" 0x1", _gc(xasprintf("%10p", 1)));
EXPECT_STREQ(" 0x10", _gc(xasprintf("%10p", 16)));
EXPECT_STREQ(" 0x31337", _gc(xasprintf("%10p", 0x31337)));
EXPECT_STREQ("0xffffffff", _gc(xasprintf("%10p", 0xffffffff)));
EXPECT_STREQ("0xffff800000031337",
_gc(xasprintf("%10p", 0xffff800000031337)));
EXPECT_STREQ("0x00000001", _gc(xasprintf("%010p", 1)));
EXPECT_STREQ("0x00000010", _gc(xasprintf("%010p", 16)));
EXPECT_STREQ("0x00031337", _gc(xasprintf("%010p", 0x31337)));
EXPECT_STREQ("0xffffffff", _gc(xasprintf("%010p", 0xffffffff)));
EXPECT_STREQ("0xffff800000031337",
_gc(xasprintf("%010p", 0xffff800000031337)));
EXPECT_STREQ("0x1 ", _gc(xasprintf("%-10p", 1)));
EXPECT_STREQ("0x10 ", _gc(xasprintf("%-10p", 16)));
EXPECT_STREQ("0x31337 ", _gc(xasprintf("%-10p", 0x31337)));
EXPECT_STREQ("0xffffffff", _gc(xasprintf("%-10p", 0xffffffff)));
EXPECT_STREQ("0xffff800000031337",
_gc(xasprintf("%-10p", 0xffff800000031337)));
EXPECT_STREQ(" 0x1", _gc(xasprintf("%+10p", 1)));
EXPECT_STREQ(" 0x10", _gc(xasprintf("%+10p", 16)));
EXPECT_STREQ(" 0x31337", _gc(xasprintf("%+10p", 0x31337)));
EXPECT_STREQ("0xffffffff", _gc(xasprintf("%+10p", 0xffffffff)));
EXPECT_STREQ("0xffff800000031337",
_gc(xasprintf("%+10p", 0xffff800000031337)));
EXPECT_STREQ(" 0x1", _gc(xasprintf("% 10p", 1)));
EXPECT_STREQ(" 0x10", _gc(xasprintf("% 10p", 16)));
EXPECT_STREQ(" 0x31337", _gc(xasprintf("% 10p", 0x31337)));
EXPECT_STREQ("0xffffffff", _gc(xasprintf("% 10p", 0xffffffff)));
EXPECT_STREQ("0xffff800000031337",
_gc(xasprintf("% 10p", 0xffff800000031337)));
}
TEST(fmt, quoted) {
ASSERT_STREQ(" \"hello\"", _gc(xasprintf("%`*.*s", 10, 5, "hello")));
ASSERT_STREQ("\"hello\" ", _gc(xasprintf("%-`*.*s", 10, 5, "hello")));
}
TEST(fmt, nulCharacter) {
char b[3] = {1, 1, 1};
ASSERT_EQ(1, snprintf(0, 0, "%c", 0));
ASSERT_EQ(1, snprintf(b, 3, "%c", 0));
ASSERT_EQ(0, b[0]);
ASSERT_EQ(0, b[1]);
ASSERT_EQ(1, b[2]);
}
TEST(fmt, regress) {
char buf[512];
const char *meth = "GET";
const char *path = "/";
const char *host = "10.10.10.124";
const char *port = "8080";
const char *agent = "hurl/1.o (https://github.com/jart/cosmopolitan)";
ASSERT_EQ(
strlen("GET / HTTP/1.1\r\n"
"Host: 10.10.10.124:8080\r\n"
"Connection: close\r\n"
"User-Agent: hurl/1.o (https://github.com/jart/cosmopolitan)\r\n"),
sprintf(buf,
"%s %s HTTP/1.1\r\n"
"Host: %s:%s\r\n"
"Connection: close\r\n"
"User-Agent: %s\r\n",
meth, path, host, port, agent));
ASSERT_STREQ(
"GET / HTTP/1.1\r\n"
"Host: 10.10.10.124:8080\r\n"
"Connection: close\r\n"
"User-Agent: hurl/1.o (https://github.com/jart/cosmopolitan)\r\n",
buf);
}

34
test/libc/stdio/fprintf_test.c Normal file
View file

@ -0,0 +1,34 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2023 Gabriel Ravier │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/dce.h"
#include "libc/stdio/stdio.h"
#include "libc/testlib/testlib.h"
TEST(fprintf, testWriteError) {
// Only Linux, NetBSD and FreeBSD are known to have /dev/full
if (!IsLinux() && !IsNetbsd() && !IsFreebsd()) return;
FILE *fp = fopen("/dev/full", "w");
ASSERT_NE(fp, NULL);
setbuf(fp, NULL);
ASSERT_LT(fprintf(fp, "test"), 0);
ASSERT_EQ(fclose(fp), 0);
}

665
test/libc/stdio/palandprintf_test.c Normal file
View file

@ -0,0 +1,665 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=8 sts=2 sw=2 fenc=utf-8 :vi│
╚══════════════════════════════════════════════════════════════════════════════╝
│ @author (c) Marco Paland (info@paland.com) │
│ 2014-2019, PALANDesign Hannover, Germany │
│ │
│ @license The MIT License (MIT) │
│ │
│ Permission is hereby granted, free of charge, to any person obtaining a copy │
│ of this software and associated documentation files (the "Software"), to deal│
│ in the Software without restriction, including without limitation the rights │
│ to use, copy, modify, merge, publish, distribute, sublicense, and/or sell │
│ copies of the Software, and to permit persons to whom the Software is │
│ furnished to do so, subject to the following conditions: │
│ │
│ The above copyright notice and this permission notice shall be included in │
│ all copies or substantial portions of the Software. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR │
│ IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, │
│ FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE │
│ AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER │
│ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,│
│ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN │
│ THE SOFTWARE. │
└─────────────────────────────────────────────────────────────────────────────*/
#include "libc/errno.h"
#include "libc/fmt/fmt.h"
#include "libc/fmt/itoa.h"
#include "libc/intrin/pushpop.internal.h"
#include "libc/intrin/safemacros.internal.h"
#include "libc/limits.h"
#include "libc/math.h"
#include "libc/mem/gc.h"
#include "libc/mem/mem.h"
#include "libc/str/str.h"
#include "libc/testlib/ezbench.h"
#include "libc/testlib/testlib.h"
#include "libc/x/xasprintf.h"
char buffer[1000];
/* #define Format(...) _gc(xasprintf(__VA_ARGS__)) */
#define Format(...) (snprintf(buffer, sizeof(buffer), __VA_ARGS__), buffer)
TEST(sprintf, test_space_flag) {
EXPECT_STREQ(" 42", Format("% d", 42));
EXPECT_STREQ("-42", Format("% d", -42));
EXPECT_STREQ(" 42", Format("% 5d", 42));
EXPECT_STREQ(" -42", Format("% 5d", -42));
EXPECT_STREQ(" 42", Format("% 15d", 42));
EXPECT_STREQ(" -42", Format("% 15d", -42));
EXPECT_STREQ(" -42", Format("% 15d", -42));
EXPECT_STREQ(" -42.987", Format("% 15.3f", -42.987));
EXPECT_STREQ(" 42.987", Format("% 15.3f", 42.987));
EXPECT_STREQ("Hello testing", Format("% s", "Hello testing"));
EXPECT_STREQ(" 1024", Format("% d", 1024));
EXPECT_STREQ("-1024", Format("% d", -1024));
EXPECT_STREQ(" 1024", Format("% i", 1024));
EXPECT_STREQ("-1024", Format("% i", -1024));
EXPECT_STREQ("1024", Format("% u", 1024));
EXPECT_STREQ("4294966272", Format("% u", 4294966272U));
EXPECT_STREQ("777", Format("% o", 511));
EXPECT_STREQ("37777777001", Format("% o", 4294966785U));
EXPECT_STREQ("1234abcd", Format("% x", 305441741));
EXPECT_STREQ("edcb5433", Format("% x", 3989525555U));
EXPECT_STREQ("1234ABCD", Format("% X", 305441741));
EXPECT_STREQ("EDCB5433", Format("% X", 3989525555U));
EXPECT_STREQ("x", Format("% c", 'x'));
}
TEST(sprintf, test_plus_flag) {
EXPECT_STREQ("+42", Format("%+d", 42));
EXPECT_STREQ("-42", Format("%+d", -42));
EXPECT_STREQ(" +42", Format("%+5d", 42));
EXPECT_STREQ(" -42", Format("%+5d", -42));
EXPECT_STREQ(" +42", Format("%+15d", 42));
EXPECT_STREQ(" -42", Format("%+15d", -42));
EXPECT_STREQ("+1024", Format("%+d", 1024));
EXPECT_STREQ("-1024", Format("%+d", -1024));
EXPECT_STREQ("+1024", Format("%+i", 1024));
EXPECT_STREQ("-1024", Format("%+i", -1024));
EXPECT_STREQ("1024", Format("%+u", 1024));
EXPECT_STREQ("4294966272", Format("%+u", 4294966272U));
EXPECT_STREQ("777", Format("%+o", 511));
EXPECT_STREQ("37777777001", Format("%+o", 4294966785U));
EXPECT_STREQ("1234abcd", Format("%+x", 305441741));
EXPECT_STREQ("edcb5433", Format("%+x", 3989525555U));
EXPECT_STREQ("1234ABCD", Format("%+X", 305441741));
EXPECT_STREQ("EDCB5433", Format("%+X", 3989525555U));
EXPECT_STREQ("+", Format("%+.0d", 0));
}
TEST(sprintf, test_flag0) {
EXPECT_STREQ("42", Format("%0d", 42));
EXPECT_STREQ("42", Format("%0ld", 42L));
EXPECT_STREQ("-42", Format("%0d", -42));
EXPECT_STREQ("00042", Format("%05d", 42));
EXPECT_STREQ("-0042", Format("%05d", -42));
EXPECT_STREQ("000000000000042", Format("%015d", 42));
EXPECT_STREQ("-00000000000042", Format("%015d", -42));
EXPECT_STREQ("000000000042.12", Format("%015.2f", 42.1234));
EXPECT_STREQ("00000000042.988", Format("%015.3f", 42.9876));
EXPECT_STREQ("-00000042.98760", Format("%015.5f", -42.9876));
}
TEST(sprintf, test_flag_minus) {
EXPECT_STREQ("42", Format("%-d", 42));
EXPECT_STREQ("-42", Format("%-d", -42));
EXPECT_STREQ("42 ", Format("%-5d", 42));
EXPECT_STREQ("-42 ", Format("%-5d", -42));
EXPECT_STREQ("42 ", Format("%-15d", 42));
EXPECT_STREQ("-42 ", Format("%-15d", -42));
EXPECT_STREQ("42", Format("%-0d", 42));
EXPECT_STREQ("-42", Format("%-0d", -42));
EXPECT_STREQ("42 ", Format("%-05d", 42));
EXPECT_STREQ("-42 ", Format("%-05d", -42));
EXPECT_STREQ("42 ", Format("%-015d", 42));
EXPECT_STREQ("-42 ", Format("%-015d", -42));
EXPECT_STREQ("42", Format("%0-d", 42));
EXPECT_STREQ("-42", Format("%0-d", -42));
EXPECT_STREQ("42 ", Format("%0-5d", 42));
EXPECT_STREQ("-42 ", Format("%0-5d", -42));
EXPECT_STREQ("42 ", Format("%0-15d", 42));
EXPECT_STREQ("-42 ", Format("%0-15d", -42));
}
TEST(sprintf, testAlternativeFormatting) {
EXPECT_STREQ("0", Format("%#x", 0));
EXPECT_STREQ("", Format("%#.0x", 0));
EXPECT_STREQ("0", Format("%#.1x", 0));
EXPECT_STREQ("", Format("%#.0llx", (long long)0));
EXPECT_STREQ("0x0000614e", Format("%#.8x", 0x614e));
EXPECT_STREQ("0b110", Format("%#b", 6));
}
TEST(sprintf, testHexBasePrefix_onlyConsumesLeadingZeroes) {
/* TODO(jart): Upstream bug fix for this behavior. */
EXPECT_STREQ("0x01", Format("%#04x", 0x1));
EXPECT_STREQ("0x12", Format("%#04x", 0x12));
EXPECT_STREQ("0x123", Format("%#04x", 0x123));
EXPECT_STREQ("0x1234", Format("%#04x", 0x1234));
}
TEST(sprintf, testBinaryBasePrefix_onlyConsumesLeadingZeroes) {
EXPECT_STREQ("0b01", Format("%#04b", 0b1));
EXPECT_STREQ("0b10", Format("%#04b", 0b10));
EXPECT_STREQ("0b101", Format("%#04b", 0b101));
EXPECT_STREQ("0b1010", Format("%#04b", 0b1010));
}
TEST(sprintf, testOctalBasePrefix_onlyConsumesLeadingZeroes) {
EXPECT_STREQ("0001", Format("%#04o", 01));
EXPECT_STREQ("0010", Format("%#04o", 010));
EXPECT_STREQ("0101", Format("%#04o", 0101));
EXPECT_STREQ("01010", Format("%#04o", 01010));
}
TEST(sprintf, test_specifier) {
EXPECT_STREQ("Hello testing", Format("Hello testing"));
EXPECT_STREQ("Hello testing", Format("%s", "Hello testing"));
EXPECT_STREQ("1024", Format("%d", 1024));
EXPECT_STREQ("-1024", Format("%d", -1024));
EXPECT_STREQ("1024", Format("%i", 1024));
EXPECT_STREQ("-1024", Format("%i", -1024));
EXPECT_STREQ("1024", Format("%u", 1024));
EXPECT_STREQ("4294966272", Format("%u", 4294966272U));
EXPECT_STREQ("777", Format("%o", 511));
EXPECT_STREQ("37777777001", Format("%o", 4294966785U));
EXPECT_STREQ("1234abcd", Format("%x", 305441741));
EXPECT_STREQ("edcb5433", Format("%x", 3989525555U));
EXPECT_STREQ("1234ABCD", Format("%X", 305441741));
EXPECT_STREQ("EDCB5433", Format("%X", 3989525555U));
EXPECT_STREQ("%", Format("%%"));
}
TEST(sprintf, test_width) {
EXPECT_STREQ("Hello testing", Format("%1s", "Hello testing"));
EXPECT_STREQ("1024", Format("%1d", 1024));
EXPECT_STREQ("-1024", Format("%1d", -1024));
EXPECT_STREQ("1024", Format("%1i", 1024));
EXPECT_STREQ("-1024", Format("%1i", -1024));
EXPECT_STREQ("1024", Format("%1u", 1024));
EXPECT_STREQ("4294966272", Format("%1u", 4294966272U));
EXPECT_STREQ("777", Format("%1o", 511));
EXPECT_STREQ("37777777001", Format("%1o", 4294966785U));
EXPECT_STREQ("1234abcd", Format("%1x", 305441741));
EXPECT_STREQ("edcb5433", Format("%1x", 3989525555U));
EXPECT_STREQ("1234ABCD", Format("%1X", 305441741));
EXPECT_STREQ("EDCB5433", Format("%1X", 3989525555U));
EXPECT_STREQ("x", Format("%1c", 'x'));
}
TEST(sprintf, test_width_20) {
/* TODO(jart): wut */
/* sprintf(buffer, "%20s", "Hello"); */
/* printf("'%s' %d\n", buffer, strlen(buffer)); */
/* EXPECT_STREQ(" Hello", buffer); */
EXPECT_STREQ(" 1024", Format("%20d", 1024));
EXPECT_STREQ(" -1024", Format("%20d", -1024));
EXPECT_STREQ(" 1024", Format("%20i", 1024));
EXPECT_STREQ(" -1024", Format("%20i", -1024));
EXPECT_STREQ(" 1024", Format("%20u", 1024));
EXPECT_STREQ(" 4294966272", Format("%20u", 4294966272U));
EXPECT_STREQ(" 777", Format("%20o", 511));
EXPECT_STREQ(" 37777777001", Format("%20o", 4294966785U));
EXPECT_STREQ(" 1234abcd", Format("%20x", 305441741));
EXPECT_STREQ(" edcb5433", Format("%20x", 3989525555U));
EXPECT_STREQ(" 1234ABCD", Format("%20X", 305441741));
EXPECT_STREQ(" EDCB5433", Format("%20X", 3989525555U));
EXPECT_STREQ(" x", Format("%20c", 'x'));
}
TEST(sprintf, test_width_star_20) {
EXPECT_STREQ(" Hello", Format("%*s", 20, "Hello"));
EXPECT_STREQ(" 1024", Format("%*d", 20, 1024));
EXPECT_STREQ(" -1024", Format("%*d", 20, -1024));
EXPECT_STREQ(" 1024", Format("%*i", 20, 1024));
EXPECT_STREQ(" -1024", Format("%*i", 20, -1024));
EXPECT_STREQ(" 1024", Format("%*u", 20, 1024));
EXPECT_STREQ(" 4294966272", Format("%*u", 20, 4294966272U));
EXPECT_STREQ(" 777", Format("%*o", 20, 511));
EXPECT_STREQ(" 37777777001", Format("%*o", 20, 4294966785U));
EXPECT_STREQ(" 1234abcd", Format("%*x", 20, 305441741));
EXPECT_STREQ(" edcb5433", Format("%*x", 20, 3989525555U));
EXPECT_STREQ(" 1234ABCD", Format("%*X", 20, 305441741));
EXPECT_STREQ(" EDCB5433", Format("%*X", 20, 3989525555U));
EXPECT_STREQ(" x", Format("%*c", 20, 'x'));
}
TEST(sprintf, test_width_minus_20) {
EXPECT_STREQ("Hello ", Format("%-20s", "Hello"));
EXPECT_STREQ("1024 ", Format("%-20d", 1024));
EXPECT_STREQ("-1024 ", Format("%-20d", -1024));
EXPECT_STREQ("1024 ", Format("%-20i", 1024));
EXPECT_STREQ("-1024 ", Format("%-20i", -1024));
EXPECT_STREQ("1024 ", Format("%-20u", 1024));
EXPECT_STREQ("1024.1234 ", Format("%-20.4f", 1024.1234));
EXPECT_STREQ("4294966272 ", Format("%-20u", 4294966272U));
EXPECT_STREQ("777 ", Format("%-20o", 511));
EXPECT_STREQ("37777777001 ", Format("%-20o", 4294966785U));
EXPECT_STREQ("1234abcd ", Format("%-20x", 305441741));
EXPECT_STREQ("edcb5433 ", Format("%-20x", 3989525555U));
EXPECT_STREQ("1234ABCD ", Format("%-20X", 305441741));
EXPECT_STREQ("EDCB5433 ", Format("%-20X", 3989525555U));
EXPECT_STREQ("x ", Format("%-20c", 'x'));
EXPECT_STREQ("| 9| |9 | | 9|", Format("|%5d| |%-2d| |%5d|", 9, 9, 9));
EXPECT_STREQ("| 10| |10| | 10|",
Format("|%5d| |%-2d| |%5d|", 10, 10, 10));
EXPECT_STREQ("| 9| |9 | | 9|",
Format("|%5d| |%-12d| |%5d|", 9, 9, 9));
EXPECT_STREQ("| 10| |10 | | 10|",
Format("|%5d| |%-12d| |%5d|", 10, 10, 10));
}
TEST(sprintf, test_width_0_minus_20) {
EXPECT_STREQ("Hello ", Format("%0-20s", "Hello"));
EXPECT_STREQ("1024 ", Format("%0-20d", 1024));
EXPECT_STREQ("-1024 ", Format("%0-20d", -1024));
EXPECT_STREQ("1024 ", Format("%0-20i", 1024));
EXPECT_STREQ("-1024 ", Format("%0-20i", -1024));
EXPECT_STREQ("1024 ", Format("%0-20u", 1024));
EXPECT_STREQ("4294966272 ", Format("%0-20u", 4294966272U));
EXPECT_STREQ("777 ", Format("%0-20o", 511));
EXPECT_STREQ("37777777001 ", Format("%0-20o", 4294966785U));
EXPECT_STREQ("1234abcd ", Format("%0-20x", 305441741));
EXPECT_STREQ("edcb5433 ", Format("%0-20x", 3989525555U));
EXPECT_STREQ("1234ABCD ", Format("%0-20X", 305441741));
EXPECT_STREQ("EDCB5433 ", Format("%0-20X", 3989525555U));
EXPECT_STREQ("x ", Format("%0-20c", 'x'));
}
TEST(sprintf, test_padding_20) {
EXPECT_STREQ("00000000000000001024", Format("%020d", 1024));
EXPECT_STREQ("-0000000000000001024", Format("%020d", -1024));
EXPECT_STREQ("00000000000000001024", Format("%020i", 1024));
EXPECT_STREQ("-0000000000000001024", Format("%020i", -1024));
EXPECT_STREQ("00000000000000001024", Format("%020u", 1024));
EXPECT_STREQ("00000000004294966272", Format("%020u", 4294966272U));
EXPECT_STREQ("00000000000000000777", Format("%020o", 511));
EXPECT_STREQ("00000000037777777001", Format("%020o", 4294966785U));
EXPECT_STREQ("0000000000001234abcd", Format("%020x", 305441741));
EXPECT_STREQ("000000000000edcb5433", Format("%020x", 3989525555U));
EXPECT_STREQ("0000000000001234ABCD", Format("%020X", 305441741));
EXPECT_STREQ("000000000000EDCB5433", Format("%020X", 3989525555U));
}
TEST(sprintf, test_padding_dot_20) {
EXPECT_STREQ("00000000000000001024", Format("%.20d", 1024));
EXPECT_STREQ("-00000000000000001024", Format("%.20d", -1024));
EXPECT_STREQ("00000000000000001024", Format("%.20i", 1024));
EXPECT_STREQ("-00000000000000001024", Format("%.20i", -1024));
EXPECT_STREQ("00000000000000001024", Format("%.20u", 1024));
EXPECT_STREQ("00000000004294966272", Format("%.20u", 4294966272U));
EXPECT_STREQ("00000000000000000777", Format("%.20o", 511));
EXPECT_STREQ("00000000037777777001", Format("%.20o", 4294966785U));
EXPECT_STREQ("0000000000001234abcd", Format("%.20x", 305441741));
EXPECT_STREQ("000000000000edcb5433", Format("%.20x", 3989525555U));
EXPECT_STREQ("0000000000001234ABCD", Format("%.20X", 305441741));
EXPECT_STREQ("000000000000EDCB5433", Format("%.20X", 3989525555U));
}
TEST(sprintf, test_padding_pound_020) {
EXPECT_STREQ("00000000000000001024", Format("%#020d", 1024));
EXPECT_STREQ("-0000000000000001024", Format("%#020d", -1024));
EXPECT_STREQ("00000000000000001024", Format("%#020i", 1024));
EXPECT_STREQ("-0000000000000001024", Format("%#020i", -1024));
EXPECT_STREQ("00000000000000001024", Format("%#020u", 1024));
EXPECT_STREQ("00000000004294966272", Format("%#020u", 4294966272U));
EXPECT_STREQ("00000000000000000777", Format("%#020o", 511));
EXPECT_STREQ("00000000037777777001", Format("%#020o", 4294966785U));
EXPECT_STREQ("0x00000000001234abcd", Format("%#020x", 305441741));
EXPECT_STREQ("0x0000000000edcb5433", Format("%#020x", 3989525555U));
EXPECT_STREQ("0X00000000001234ABCD", Format("%#020X", 305441741));
EXPECT_STREQ("0X0000000000EDCB5433", Format("%#020X", 3989525555U));
}
TEST(sprintf, test_padding_pound_20) {
EXPECT_STREQ(" 1024", Format("%#20d", 1024));
EXPECT_STREQ(" -1024", Format("%#20d", -1024));
EXPECT_STREQ(" 1024", Format("%#20i", 1024));
EXPECT_STREQ(" -1024", Format("%#20i", -1024));
EXPECT_STREQ(" 1024", Format("%#20u", 1024));
EXPECT_STREQ(" 4294966272", Format("%#20u", 4294966272U));
EXPECT_STREQ(" 0777", Format("%#20o", 511));
EXPECT_STREQ(" 037777777001", Format("%#20o", 4294966785U));
EXPECT_STREQ(" 0x1234abcd", Format("%#20x", 305441741));
EXPECT_STREQ(" 0xedcb5433", Format("%#20x", 3989525555U));
EXPECT_STREQ(" 0X1234ABCD", Format("%#20X", 305441741));
EXPECT_STREQ(" 0XEDCB5433", Format("%#20X", 3989525555U));
}
TEST(sprintf, test_padding_20_point_5) {
EXPECT_STREQ(" 01024", Format("%20.5d", 1024));
EXPECT_STREQ(" -01024", Format("%20.5d", -1024));
EXPECT_STREQ(" 01024", Format("%20.5i", 1024));
EXPECT_STREQ(" -01024", Format("%20.5i", -1024));
EXPECT_STREQ(" 01024", Format("%20.5u", 1024));
EXPECT_STREQ(" 4294966272", Format("%20.5u", 4294966272U));
EXPECT_STREQ(" 00777", Format("%20.5o", 511));
EXPECT_STREQ(" 37777777001", Format("%20.5o", 4294966785U));
EXPECT_STREQ(" 1234abcd", Format("%20.5x", 305441741));
EXPECT_STREQ(" 00edcb5433", Format("%20.10x", 3989525555U));
EXPECT_STREQ(" 1234ABCD", Format("%20.5X", 305441741));
EXPECT_STREQ(" 00EDCB5433", Format("%20.10X", 3989525555U));
}
TEST(sprintf, test_padding_neg_numbers) {
/* space padding */
EXPECT_STREQ("-5", Format("% 1d", -5));
EXPECT_STREQ("-5", Format("% 2d", -5));
EXPECT_STREQ(" -5", Format("% 3d", -5));
EXPECT_STREQ(" -5", Format("% 4d", -5));
/* zero padding */
EXPECT_STREQ("-5", Format("%01d", -5));
EXPECT_STREQ("-5", Format("%02d", -5));
EXPECT_STREQ("-05", Format("%03d", -5));
EXPECT_STREQ("-005", Format("%04d", -5));
}
TEST(sprintf, test_float_padding_neg_numbers) {
/* space padding */
EXPECT_STREQ("-5.0", Format("% 3.1f", -5.));
EXPECT_STREQ("-5.0", Format("% 4.1f", -5.));
EXPECT_STREQ(" -5.0", Format("% 5.1f", -5.));
/* zero padding */
EXPECT_STREQ("-5.0", Format("%03.1f", -5.));
EXPECT_STREQ("-5.0", Format("%04.1f", -5.));
EXPECT_STREQ("-05.0", Format("%05.1f", -5.));
/* zero padding no decimal point */
EXPECT_STREQ("-5", Format("%01.0f", -5.));
EXPECT_STREQ("-5", Format("%02.0f", -5.));
EXPECT_STREQ("-05", Format("%03.0f", -5.));
}
TEST(sprintf, test_length) {
EXPECT_STREQ("", Format("%.0s", "Hello testing"));
EXPECT_STREQ(" ", Format("%20.0s", "Hello testing"));
EXPECT_STREQ("", Format("%.s", "Hello testing"));
EXPECT_STREQ(" ", Format("%20.s", "Hello testing"));
EXPECT_STREQ(" 1024", Format("%20.0d", 1024));
EXPECT_STREQ(" -1024", Format("%20.0d", -1024));
EXPECT_STREQ(" ", Format("%20.d", 0));
EXPECT_STREQ(" 1024", Format("%20.0i", 1024));
EXPECT_STREQ(" -1024", Format("%20.i", -1024));
EXPECT_STREQ(" ", Format("%20.i", 0));
EXPECT_STREQ(" 1024", Format("%20.u", 1024));
EXPECT_STREQ(" 4294966272", Format("%20.0u", 4294966272U));
EXPECT_STREQ(" ", Format("%20.u", 0U));
EXPECT_STREQ(" 777", Format("%20.o", 511));
EXPECT_STREQ(" 37777777001", Format("%20.0o", 4294966785U));
EXPECT_STREQ(" ", Format("%20.o", 0U));
EXPECT_STREQ(" 1234abcd", Format("%20.x", 305441741));
EXPECT_STREQ(" 1234abcd",
Format("%50.x", 305441741));
EXPECT_STREQ(" 1234abcd 12345",
Format("%50.x%10.u", 305441741, 12345));
EXPECT_STREQ(" edcb5433", Format("%20.0x", 3989525555U));
EXPECT_STREQ(" ", Format("%20.x", 0U));
EXPECT_STREQ(" 1234ABCD", Format("%20.X", 305441741));
EXPECT_STREQ(" EDCB5433", Format("%20.0X", 3989525555U));
EXPECT_STREQ(" ", Format("%20.X", 0U));
EXPECT_STREQ(" ", Format("%02.0u", 0U));
EXPECT_STREQ(" ", Format("%02.0d", 0));
}
TEST(sprintf, test_float) {
#ifndef __FINITE_MATH_ONLY__
EXPECT_STREQ("nan", Format("%.4f", NAN));
#endif
EXPECT_STREQ("-0.0000", Format("%.4f", -0.));
EXPECT_STREQ("3.1415", Format("%.4f", 3.1415354));
EXPECT_STREQ("30343.142", Format("%.3f", 30343.1415354));
EXPECT_STREQ("34", Format("%.0f", 34.1415354));
EXPECT_STREQ("1", Format("%.0f", 1.3));
EXPECT_STREQ("2", Format("%.0f", 1.55));
EXPECT_STREQ("1.6", Format("%.1f", 1.64));
EXPECT_STREQ("42.90", Format("%.2f", 42.8952));
EXPECT_STREQ("42.895200000", Format("%.9f", 42.8952));
EXPECT_STREQ("42.8952230000", Format("%.10f", 42.895223));
EXPECT_STREQ("42.89522312345678", Format("%.14f", 42.89522312345678));
EXPECT_STREQ("42.89522387654321", Format("%.14f", 42.89522387654321));
EXPECT_STREQ(" 42.90", Format("%6.2f", 42.8952));
EXPECT_STREQ("+42.90", Format("%+6.2f", 42.8952));
EXPECT_STREQ("+42.9", Format("%+5.1f", 42.9252));
EXPECT_STREQ("42.500000", Format("%f", 42.5));
EXPECT_STREQ("42.500000", Format("%lf", 42.5));
EXPECT_STREQ("42.5", Format("%.1f", 42.5));
EXPECT_STREQ("42167.000000", Format("%f", 42167.0));
EXPECT_STREQ("-12345.987654321", Format("%.9f", -12345.987654321));
EXPECT_STREQ("4.0", Format("%.1f", 3.999));
EXPECT_STREQ("4", Format("%.0f", 3.5));
EXPECT_STREQ("4", Format("%.0f", 4.5));
EXPECT_STREQ("3", Format("%.0f", 3.49));
EXPECT_STREQ("3.5", Format("%.1f", 3.49));
EXPECT_STREQ("a0.5 ", Format("a%-5.1f", 0.5));
EXPECT_STREQ("a0.5 end", Format("a%-5.1fend", 0.5));
EXPECT_STREQ("100000000000000000000.0", Format("%.1f", 1E20));
}
TEST(sprintf, test_types) {
EXPECT_STREQ("0", Format("%i", 0));
EXPECT_STREQ("1234", Format("%i", 1234));
EXPECT_STREQ("32767", Format("%i", 32767));
EXPECT_STREQ("-32767", Format("%i", -32767));
EXPECT_STREQ("30", Format("%li", 30L));
EXPECT_STREQ("-2147483647", Format("%li", -2147483647L));
EXPECT_STREQ("2147483647", Format("%li", 2147483647L));
EXPECT_STREQ("30", Format("%lli", 30LL));
EXPECT_STREQ("-9223372036854775807", Format("%lli", -9223372036854775807LL));
EXPECT_STREQ("9223372036854775807", Format("%lli", 9223372036854775807LL));
EXPECT_STREQ("100000", Format("%lu", 100000L));
EXPECT_STREQ("4294967295", Format("%lu", 0xFFFFFFFFL));
EXPECT_STREQ("281474976710656", Format("%llu", 281474976710656LLU));
EXPECT_STREQ("18446744073709551615", Format("%llu", 18446744073709551615LLU));
EXPECT_STREQ("2147483647", Format("%zu", 2147483647UL));
EXPECT_STREQ("2147483647", Format("%zd", 2147483647UL));
if (sizeof(size_t) == sizeof(long)) {
EXPECT_STREQ("-2147483647", Format("%zi", -2147483647L));
} else {
EXPECT_STREQ("-2147483647", Format("%zi", -2147483647LL));
}
EXPECT_STREQ("1110101001100000", Format("%b", 60000));
EXPECT_STREQ("101111000110000101001110", Format("%lb", 12345678L));
EXPECT_STREQ("165140", Format("%o", 60000));
EXPECT_STREQ("57060516", Format("%lo", 12345678L));
EXPECT_STREQ("12345678", Format("%lx", 0x12345678L));
EXPECT_STREQ("1234567891234567", Format("%llx", 0x1234567891234567LLU));
EXPECT_STREQ("abcdefab", Format("%lx", 0xabcdefabL));
EXPECT_STREQ("ABCDEFAB", Format("%lX", 0xabcdefabL));
EXPECT_STREQ("v", Format("%c", 'v'));
EXPECT_STREQ("wv", Format("%cv", 'w'));
EXPECT_STREQ("A Test", Format("%s", "A Test"));
EXPECT_STREQ("255", Format("%hhu", 0xFFFFUL));
EXPECT_STREQ("a", Format("%tx", &buffer[10] - &buffer[0]));
/* TBD */
EXPECT_STREQ("-2147483647", Format("%ji", (intmax_t)-2147483647L));
}
TEST(sprintf, testOverflow_truncationNotSaturation) {
errno = 0;
EXPECT_STREQ("13398", Format("%hu", 0x123456UL));
errno = 0;
EXPECT_STREQ("Test16 65535", Format("%s%hhi %hu", "Test", 10000, 0xFFFFFFFF));
}
TEST(sprintf, test_unknown_flag) {
EXPECT_STREQ("kmarco", Format("%kmarco", 42, 37));
}
TEST(sprintf, test_buffer_length) {
int ret;
/* EXPECT_EQ(4, snprintf(pushpop(NULL), 10, "%s", "Test")); */
EXPECT_EQ(4, snprintf(pushpop(NULL), 0, "%s", "Test"));
buffer[0] = (char)0xA5;
ret = snprintf(buffer, 0, "%s", "Test");
EXPECT_TRUE(buffer[0] == (char)0xA5);
EXPECT_TRUE(ret == 4);
buffer[0] = (char)0xCC;
snprintf(buffer, 1, "%s", pushpop(&"Test"[0]));
EXPECT_TRUE(buffer[0] == '\0');
snprintf(buffer, 2, "%s", pushpop(&"Hello"[0]));
EXPECT_STREQ("H", buffer);
}
TEST(sprintf, test_ret_value) {
int ret;
ret = snprintf(buffer, 6, "0%s", "1234");
EXPECT_STREQ("01234", buffer);
EXPECT_TRUE(ret == 5);
ret = snprintf(buffer, 6, "0%s", pushpop(&"12345"[0]));
EXPECT_STREQ("01234", buffer);
EXPECT_TRUE(ret == 6); /* '5' is truncated */
ret = snprintf(buffer, 6, "0%s", pushpop(&"1234567"[0]));
EXPECT_STREQ("01234", buffer);
EXPECT_TRUE(ret == 8); /* '567' are truncated */
ret = snprintf(buffer, 10, pushpop(&"hello, world"[0]));
EXPECT_TRUE(ret == 12);
ret = snprintf(buffer, 3, "%d", pushpop(10000));
EXPECT_TRUE(ret == 5);
EXPECT_TRUE(strlen(buffer) == 2U);
EXPECT_TRUE(buffer[0] == '1');
EXPECT_TRUE(buffer[1] == '0');
EXPECT_TRUE(buffer[2] == '\0');
}
TEST(sprintf, test_misc) {
EXPECT_STREQ("53000atest-20 bit",
Format("%u%u%ctest%d %s", 5, 3000, 'a', -20, "bit"));
EXPECT_STREQ("0.33", Format("%.*f", 2, 0.33333333));
EXPECT_STREQ("1", Format("%.*d", -1, 1));
EXPECT_STREQ("foo", Format("%.3s", "foobar"));
EXPECT_STREQ(" ", Format("% .0d", 0));
EXPECT_STREQ(" 00004", Format("%10.5d", 4));
EXPECT_STREQ("hi x", Format("%*sx", -3, "hi"));
}
TEST(sprintf, test_snprintf) {
snprintf(buffer, 100U, "%d", -1000);
EXPECT_STREQ("-1000", buffer);
snprintf(buffer, 3U, "%d", pushpop(-1000));
EXPECT_STREQ("-1", buffer);
}
void vsnprintf_builder_1(char *buf, ...) {
va_list args;
va_start(args, buf);
vsnprintf(buf, 100U, "%d", args);
va_end(args);
}
void vsnprintf_builder_3(char *buf, ...) {
va_list args;
va_start(args, buf);
vsnprintf(buf, 100U, "%d %d %s", args);
va_end(args);
}
TEST(sprintf, test_vsnprintf) {
vsnprintf_builder_1(buffer, -1);
EXPECT_STREQ("-1", buffer);
vsnprintf_builder_3(buffer, 3, -1000, "test");
EXPECT_STREQ("3 -1000 test", buffer);
}
TEST(xasprintf, test) {
void *pp;
ASSERT_STREQ("hello 123", (pp = xasprintf("hello %d", 123)));
free(pp);
}
TEST(xasprintf, hugeNtoa) {
ASSERT_STREQ(
"0b1111111111111111111111111111111111111111111111111111111111111111111111"
"1111111111111111111111111111111111111111111111111111111111",
_gc(xasprintf("%#jjb", UINT128_MAX)));
}
TEST(xasprintf, twosBane) {
ASSERT_STREQ("-2147483648", _gc(xasprintf("%d", 0x80000000)));
ASSERT_STREQ("-9223372036854775808",
_gc(xasprintf("%ld", 0x8000000000000000)));
}
TEST(snprintf, testFixedWidthString_wontOverrunInput) {
const int N = 2;
char *buf = malloc(N + 1);
char *inp = memcpy(malloc(N), "hi", N);
EXPECT_EQ(2, snprintf(buf, N + 1, "%.*s", N, inp));
EXPECT_BINEQ(u"hi ", buf);
free(inp);
free(buf);
}
TEST(snprintf, testFixedWidthStringIsNull_wontOverrunBuffer) {
int N = 3;
char *buf = malloc(N + 1);
EXPECT_EQ(3, snprintf(buf, N + 1, "%.*s", pushpop(N), pushpop(NULL)));
EXPECT_STREQ("(nu", buf);
EXPECT_EQ(3, snprintf(buf, N + 1, "%#.*s", pushpop(N), pushpop(NULL)));
EXPECT_STREQ("(nu", buf);
EXPECT_EQ(3, snprintf(buf, N + 1, "%`'.*s", pushpop(N), pushpop(NULL)));
EXPECT_STREQ("NUL", buf);
EXPECT_EQ(3, snprintf(buf, N + 1, "%`#.*s", pushpop(N), pushpop(NULL)));
EXPECT_STREQ("NUL", buf);
free(buf);
}
TEST(snprintf, twosBaneWithTypePromotion) {
int16_t x = 0x8000;
EXPECT_STREQ("-32768", Format("%hd", x));
}
TEST(snprintf, formatStringLiteral) {
EXPECT_STREQ("\"hi\\n\"", Format("%`'s", "hi\n"));
EXPECT_STREQ("\"\\000\"", Format("%`'.*s", 1, "\0"));
}
TEST(palandprintf, precisionStillRespectsNulTerminatorIfNotEscOrRepr) {
EXPECT_STREQ("Makefile - 25 lines ",
Format("%.20s - %d lines %s", "Makefile", 25, ""));
}
TEST(sprintf, commas) {
char buf[64];
sprintf(buf, "%,d", 123456789);
ASSERT_STREQ("123,456,789", buf);
}
TEST(vsnprintf, issue785) {
ASSERT_EQ(0, snprintf(0, 0, "%s", ""));
ASSERT_EQ(1, snprintf(0, 0, "%s", " "));
ASSERT_EQ(2, snprintf(0, 0, "%s", " "));
}
BENCH(palandprintf, bench) {
EZBENCH2("ascii", donothing, Format(VEIL("r", "hiuhcreohucreo")));
EZBENCH2("ascii %s", donothing, Format("%s", VEIL("r", "hiuhcreohucreo")));
EZBENCH2("ascii %`'s", donothing, Format("%`'s", VEIL("r", "hiuhcreohucre")));
EZBENCH2("utf8 %s", donothing, Format("%s", VEIL("r", "hi (╯°□°)╯")));
EZBENCH2("snprintf %hs", donothing, Format("%hs", VEIL("r", u"hi (╯°□°)╯")));
EZBENCH2("snprintf %ls", donothing, Format("%ls", VEIL("r", L"hi (╯°□°)╯")));
EZBENCH2("23 %x", donothing, Format("%x", VEIL("r", 23)));
EZBENCH2("23 %d", donothing, Format("%d", VEIL("r", 23)));
EZBENCH2("%f M_PI", donothing, Format("%f", VEIL("x", M_PI)));
EZBENCH2("%g M_PI", donothing, Format("%g", VEIL("x", M_PI)));
EZBENCH2("%a M_PI", donothing, Format("%a", VEIL("x", M_PI)));
EZBENCH2("%e M_PI", donothing, Format("%e", VEIL("x", M_PI)));
EZBENCH2("ULONG_MAX %lo", donothing, Format("%lo", VEIL("r", ULONG_MAX)));
EZBENCH2("INT_MIN %x", donothing, Format("%x", VEIL("r", INT_MIN)));
EZBENCH2("INT_MIN %d", donothing, Format("%d", VEIL("r", INT_MIN)));
EZBENCH2("INT_MIN %,d", donothing, Format("%,d", VEIL("r", INT_MIN)));
EZBENCH2("INT_MIN %ld", donothing, Format("%ld", (long)VEIL("r", INT_MIN)));
EZBENCH2("LONG_MIN %lx", donothing, Format("%lx", VEIL("r", LONG_MIN)));
EZBENCH2("LONG_MIN %ld", donothing, Format("%ld", VEIL("r", LONG_MIN)));
EZBENCH2("INT128_MIN %jjd", donothing, Format("%jjd", INT128_MIN));
EZBENCH2("INT128_MIN %jjx", donothing, Format("%jjx", INT128_MIN));
EZBENCH2("int64toarray 23", donothing, FormatInt64(buffer, 23));
EZBENCH2("int64toarray min", donothing, FormatInt64(buffer, INT_MIN));
#ifdef __x86__
EZBENCH2("%Lf M_PI", donothing, Format("%Lf", VEIL("t", M_PI)));
EZBENCH2("%Lg M_PI", donothing, Format("%Lg", VEIL("t", M_PI)));
EZBENCH2("%La M_PI", donothing, Format("%La", VEIL("t", M_PI)));
EZBENCH2("%Le M_PI", donothing, Format("%Le", VEIL("t", M_PI)));
#endif
}

29
test/libc/stdio/snprintf_test.c Normal file
View file

@ -0,0 +1,29 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2023 Gabriel Ravier │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/fmt/fmt.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
TEST(snprintf, testVeryLargePrecision) {
char buf[512] = {};
int i = snprintf(buf, sizeof(buf), "%.9999u", 10);
ASSERT_EQ(i, 9999);
ASSERT_EQ(strlen(buf), 511);
}

92
test/libc/stdio/sprintf_s.inc Normal file
View file

@ -0,0 +1,92 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2020 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
/* MODE=tiny makes these dependencies optional */
STATIC_YOINK("strnwidth");
STATIC_YOINK("strnwidth16");
STATIC_YOINK("wcsnwidth");
TEST(SUITE(sprintf), testStringLength) {
ASSERT_STREQ("This", Format(FORMAT("%.4"), STRING("This is a test")));
ASSERT_STREQ("test", Format(FORMAT("%.4"), STRING("test")));
ASSERT_STREQ("123", Format(FORMAT("%.7"), STRING("123")));
ASSERT_STREQ("", Format(FORMAT("%.7"), STRING("")));
ASSERT_STREQ("1234ab", Format(FORMAT("%.4") FORMAT("%.2"), STRING("123456"),
STRING("abcdef")));
ASSERT_STREQ(FORMAT(".2"), Format(FORMAT("%.4.2"), STRING("123456")));
ASSERT_STREQ("123", Format(FORMAT("%.*"), 3, STRING("123456")));
}
TEST(SUITE(sprintf), testCharacterCounting) {
ASSERT_STREQ(" ♥♦♣♠☺☻▲", Format(FORMAT("%16"), STRING("♥♦♣♠☺☻▲")));
}
TEST(SUITE(snprintf), testTableFlip) {
EXPECT_STREQ("Table flip ", Format("%-20ls", L"Table flip"));
EXPECT_STREQ("(╯°□°)╯︵L┻━┻ ", Format("%-20ls", L"(╯°□°)╯︵L┻━┻"));
EXPECT_STREQ("(╯°□°)╯︵u┻━┻ ", Format("%-20hs", u"(╯°□°)╯︵u┻━┻"));
EXPECT_STREQ("ちゃぶ台返し ", Format("%-20ls", L"ちゃぶ台返し"));
EXPECT_STREQ(" (╯°□°)╯︵L┻━┻", Format("%20ls", L"(╯°□°)╯︵L┻━┻"));
EXPECT_STREQ(" ちゃぶ台返し", Format("%20ls", L"ちゃぶ台返し"));
}
TEST(SUITE(snprintf), testCombiningWidth) {
EXPECT_STREQ("H̲E̲L̲L̲O̲ ",
Format("%-10ls", L"H\u0332E\u0332L\u0332L\u0332O\u0332"));
EXPECT_STREQ(" H̲E̲L̲L̲O̲",
Format("%10hs", u"H\u0332E\u0332L\u0332L\u0332O\u0332"));
}
TEST(SUITE(snprintf), testQuoting) {
EXPECT_STREQ("\\\"hi┻\\'━┻", Format("%'s", "\"hi┻'━┻"));
EXPECT_STREQ(STRINGIFY("\"hi┻\'━┻"), Format("%`'s", "\"hi┻'━┻"));
EXPECT_STREQ(STRINGIFY("\177\"hi┻\'━┻"), Format("%`'s", "\x7f\"hi┻'━┻"));
}
TEST(SUITE(snprintf), testBing_cString_stopsAtNulTerminator) {
EXPECT_STREQ("♥♦♣♠", Format("%#s", "\3\4\5\6\0\3\4\5\6"));
}
TEST(SUITE(snprintf), testBing_precisionString_showsTrueBinary) {
EXPECT_STREQ("♥♦♣♠ ♥♦♣♠", Format("%#.*s", 9, "\3\4\5\6\0\3\4\5\6"));
}
TEST(SUITE(snprintf), testStringPrecision_showsTrueBinary) {
EXPECT_STREQ("\3\4\0", Format("%.*s", 3, "\3\4\0"));
}
TEST(SUITE(snprintf), testPrecision_usesByteCount) {
EXPECT_STREQ("ちゃ", Format("%.*s", 6, "ちゃぶ台返し"));
}
TEST(SUITE(snprintf), testReprChar16) {
EXPECT_STREQ("u'♥'", Format("%`'hc", u'♥'));
}
TEST(SUITE(snprintf), testReprChar32) {
EXPECT_STREQ("L'♥'", Format("%`'lc", L'♥'));
}
TEST(SUITE(snprintf), testReprUtf8) {
EXPECT_STREQ("\"♥\"", Format("%`'s", u8"♥"));
}
TEST(SUITE(snprintf), testReprUtf8Precision_countsBytes) {
EXPECT_STREQ("\"♥\"", Format("%`'.*s", 3, u8"♥"));
}

61
test/libc/stdio/sprintf_s_test.c Normal file
View file

@ -0,0 +1,61 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2020 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/fmt/fmt.h"
#include "libc/intrin/bits.h"
#include "libc/intrin/safemacros.internal.h"
#include "libc/mem/gc.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
#include "libc/x/xasprintf.h"
static char buffer[128];
#define Format(...) _gc(xasprintf(__VA_ARGS__))
/**
* @fileoverview String formatting tests.
*
* We use textual includes here to test UTF-8, UTF-16, and UTF-32 at the
* same time, since Cosmopolitan is designed to support them all without
* conditions.
*/
#define SUITE(NAME) NAME##s
#define FORMAT(STR) STR "s"
#define STRING(STR) STR
#include "test/libc/stdio/sprintf_s.inc"
#undef SUITE
#undef FORMAT
#undef STRING
#define SUITE(NAME) NAME##hs
#define FORMAT(STR) STR "hs"
#define STRING(STR) u##STR
#include "test/libc/stdio/sprintf_s.inc"
#undef SUITE
#undef FORMAT
#undef STRING
#define SUITE(NAME) NAME##ls
#define FORMAT(STR) STR "ls"
#define STRING(STR) L##STR
#include "test/libc/stdio/sprintf_s.inc"
#undef SUITE
#undef FORMAT
#undef STRING

260
test/libc/stdio/sscanf_test.c Normal file
View file

@ -0,0 +1,260 @@
/*-*- mode:c;indent-tabs-mode:nil;c-basic-offset:2;tab-width:8;coding:utf-8 -*-│
│vi: set net ft=c ts=2 sts=2 sw=2 fenc=utf-8 :vi│
╞══════════════════════════════════════════════════════════════════════════════╡
│ Copyright 2020 Justine Alexandra Roberts Tunney │
│ │
│ Permission to use, copy, modify, and/or distribute this software for │
│ any purpose with or without fee is hereby granted, provided that the │
│ above copyright notice and this permission notice appear in all copies. │
│ │
│ THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL │
│ WARRANTIES WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED │
│ WARRANTIES OF MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE │
│ AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL │
│ DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR │
│ PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER │
│ TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR │
│ PERFORMANCE OF THIS SOFTWARE. │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/errno.h"
#include "libc/fmt/fmt.h"
#include "libc/intrin/bits.h"
#include "libc/inttypes.h"
#include "libc/limits.h"
#include "libc/mem/mem.h"
#include "libc/testlib/testlib.h"
#define sscanf1(STR, FMT) \
({ \
errno = 0; \
int128_t x = 0; \
EXPECT_EQ(1, sscanf(STR, FMT, &x)); \
x; \
})
TEST(sscanf, testMultiple) {
int a, b, c;
ASSERT_EQ(3, sscanf("123 123 123", "%d %x %o", &a, &b, &c));
EXPECT_EQ(123, a);
EXPECT_EQ(0x123, b);
EXPECT_EQ(0123, c);
}
TEST(sscanf, testDecimal) {
EXPECT_EQ(123, sscanf1("123", "%d"));
EXPECT_EQ(123, sscanf1("123", "%n"));
EXPECT_EQ(123, sscanf1("123", "%u"));
EXPECT_EQ((uint32_t)-123, sscanf1("-123", "%d"));
}
TEST(sscanf, testHex) {
EXPECT_EQ(0x123, sscanf1("123", "%x"));
EXPECT_EQ(0x123, sscanf1("0x123", "%x"));
EXPECT_EQ(0x123, sscanf1("0123", "%x"));
EXPECT_EQ(INT128_MAX,
sscanf1("170141183460469231731687303715884105727", "%jjd"));
EXPECT_EQ(INT128_MIN,
sscanf1("-170141183460469231731687303715884105728", "%jjd"));
EXPECT_EQ(UINT128_MAX, sscanf1("0xffffffffffffffffffffffffffffffff", "%jjx"));
}
TEST(sscanf, testOctal) {
EXPECT_EQ(0123, sscanf1("123", "%o"));
EXPECT_EQ(0123, sscanf1("0123", "%o"));
}
TEST(sscanf, testNonDirectiveCharacterMatching) {
EXPECT_EQ(0, sscanf("%", "%%"));
}
TEST(sscanf, testCharacter) {
char c = 0;
EXPECT_EQ(1, sscanf("a", "%c", &c));
EXPECT_EQ('a', c);
}
TEST(sscanf, testStringBuffer) {
char s1[32], s2[32];
ASSERT_EQ(2, sscanf("abc xyz", "%s %s", s1, s2));
EXPECT_STREQ("abc", &s1[0]);
EXPECT_STREQ("xyz", &s2[0]);
}
TEST(sscanf, testStringBuffer_gothicUtf8ToUtf8_roundTrips) {
char s1[64], s2[64];
ASSERT_EQ(2, sscanf("𐌰𐌱𐌲𐌳 𐌴𐌵𐌶𐌷", "%63s %63s", s1, s2));
EXPECT_STREQ("𐌰𐌱𐌲𐌳", s1);
EXPECT_STREQ("𐌴𐌵𐌶𐌷", s2);
}
TEST(sscanf, testStringBuffer_gothicUtf8to16) {
char16_t s1[64], s2[64];
ASSERT_EQ(2, sscanf("𐌰𐌱𐌲𐌳 𐌴𐌵𐌶𐌷", "%63hs %63hs", s1, s2));
EXPECT_STREQ(u"𐌰𐌱𐌲𐌳", s1);
EXPECT_STREQ(u"𐌴𐌵𐌶𐌷", s2);
}
TEST(sscanf, testStringBuffer_gothicUtf8ToUtf32) {
wchar_t s1[64], s2[64];
ASSERT_EQ(2, sscanf("𐌰𐌱𐌲𐌳 𐌴𐌵𐌶𐌷", "%63ls %63ls", s1, s2));
EXPECT_STREQ(L"𐌰𐌱𐌲𐌳", s1);
EXPECT_STREQ(L"𐌴𐌵𐌶𐌷", s2);
}
TEST(sscanf, testStringBuffer_allocatingBehavior) {
char *s1, *s2;
ASSERT_EQ(2, sscanf("𐌰𐌱𐌲𐌳 𐌴𐌵𐌶𐌷", "%ms %ms", &s1, &s2));
EXPECT_STREQ("𐌰𐌱𐌲𐌳", s1);
EXPECT_STREQ("𐌴𐌵𐌶𐌷", s2);
free(s1);
free(s2);
}
TEST(sscanf, testPracticalBusinessApplication) {
unsigned start, stop;
char width;
ASSERT_EQ(1, sscanf("0BF3..", "%x", &start));
EXPECT_EQ(0x0BF3, start);
ASSERT_EQ(3, sscanf("0BF3..0BF8;N # So [6] TAMIL DAY SIGN",
"%x..%x;%c", &start, &stop, &width));
EXPECT_EQ(0x0BF3, start);
EXPECT_EQ(0x0BF8, stop);
EXPECT_EQ('N', width);
}
TEST(sscanf, socketListenUri) {
char proto[4];
unsigned char ip4[4];
uint16_t port;
ASSERT_EQ(6, sscanf("tcp:127.0.0.1:31337", "%3s:%hhu.%hhu.%hhu.%hhu:%hu",
proto, &ip4[0], &ip4[1], &ip4[2], &ip4[3], &port));
ASSERT_STREQ("tcp", proto);
ASSERT_EQ(127, ip4[0]);
ASSERT_EQ(0, ip4[1]);
ASSERT_EQ(0, ip4[2]);
ASSERT_EQ(1, ip4[3]);
ASSERT_EQ(31337, port);
}
TEST(sscanf, testDiscard_notIncludedInCount) {
char buf[8];
ASSERT_EQ(1, sscanf("hello there", "%*s %8s", buf));
EXPECT_STREQ("there", buf);
}
TEST(sscanf, testFixedWidthFormat_Integer) {
int r, g, b;
ASSERT_EQ(3, sscanf("#321030", "#%2x%2b%2d", &r, &g, &b));
ASSERT_EQ(0x32, r);
ASSERT_EQ(2, g);
ASSERT_EQ(30, b);
}
TEST(sscanf, testInttypes_macros) {
int8_t i8 = (int8_t)0xFFFFFFFFFFFFFFFF;
uint8_t u8 = (uint8_t)0xFFFFFFFFFFFFFFFF;
int16_t i16 = (int16_t)0xFFFFFFFFFFFFFFFF;
uint16_t u16 = (uint16_t)0xFFFFFFFFFFFFFFFF;
int32_t i32 = (int32_t)0xFFFFFFFFFFFFFFFF;
uint32_t u32 = (uint32_t)0xFFFFFFFFFFFFFFFF;
int64_t i64 = (int64_t)0xFFFFFFFFFFFFFFFF;
uint64_t u64 = (uint64_t)0xFFFFFFFFFFFFFFFF;
intmax_t imax = (intmax_t)0xFFFFFFFFFFFFFFFF;
uintmax_t umax = (uintmax_t)0xFFFFFFFFFFFFFFFF;
int_least8_t il8 = (int_least8_t)0xFFFFFFFFFFFFFFFF;
uint_least8_t ul8 = (uint_least8_t)0xFFFFFFFFFFFFFFFF;
int_least16_t il16 = (int_least16_t)0xFFFFFFFFFFFFFFFF;
uint_least16_t ul16 = (uint_least16_t)0xFFFFFFFFFFFFFFFF;
int_least32_t il32 = (int_least32_t)0xFFFFFFFFFFFFFFFF;
uint_least32_t ul32 = (uint_least32_t)0xFFFFFFFFFFFFFFFF;
int_least64_t il64 = (int_least64_t)0xFFFFFFFFFFFFFFFF;
uint_least64_t ul64 = (uint_least64_t)0xFFFFFFFFFFFFFFFF;
int_fast8_t if8 = (int_fast8_t)0xFFFFFFFFFFFFFFFF;
uint_fast8_t uf8 = (uint_fast8_t)0xFFFFFFFFFFFFFFFF;
int_fast16_t if16 = (int_fast16_t)0xFFFFFFFFFFFFFFFF;
uint_fast16_t uf16 = (uint_fast16_t)0xFFFFFFFFFFFFFFFF;
int_fast32_t if32 = (int_fast32_t)0xFFFFFFFFFFFFFFFF;
uint_fast32_t uf32 = (uint_fast32_t)0xFFFFFFFFFFFFFFFF;
int_fast64_t if64 = (int_fast64_t)0xFFFFFFFFFFFFFFFF;
uint_fast64_t uf64 = (uint_fast64_t)0xFFFFFFFFFFFFFFFF;
ASSERT_EQ(sscanf("1", "%" SCNd8, &i8), 1);
ASSERT_EQ(sscanf("1", "%" SCNu8, &u8), 1);
ASSERT_EQ(sscanf("1", "%" SCNd16, &i16), 1);
ASSERT_EQ(sscanf("1", "%" SCNu16, &u16), 1);
ASSERT_EQ(sscanf("1", "%" SCNd32, &i32), 1);
ASSERT_EQ(sscanf("1", "%" SCNu32, &u32), 1);
ASSERT_EQ(sscanf("1", "%" SCNd64, &i64), 1);
ASSERT_EQ(sscanf("1", "%" SCNu64, &u64), 1);
ASSERT_EQ(sscanf("1", "%" SCNdMAX, &imax), 1);
ASSERT_EQ(sscanf("1", "%" SCNuMAX, &umax), 1);
ASSERT_EQ(sscanf("1", "%" SCNdLEAST8, &il8), 1);
ASSERT_EQ(sscanf("1", "%" SCNuLEAST8, &ul8), 1);
ASSERT_EQ(sscanf("1", "%" SCNdLEAST16, &il16), 1);
ASSERT_EQ(sscanf("1", "%" SCNuLEAST16, &ul16), 1);
ASSERT_EQ(sscanf("1", "%" SCNdLEAST32, &il32), 1);
ASSERT_EQ(sscanf("1", "%" SCNuLEAST32, &ul32), 1);
ASSERT_EQ(sscanf("1", "%" SCNdLEAST64, &il64), 1);
ASSERT_EQ(sscanf("1", "%" SCNuLEAST64, &ul64), 1);
ASSERT_EQ(sscanf("1", "%" SCNdFAST8, &if8), 1);
ASSERT_EQ(sscanf("1", "%" SCNuFAST8, &uf8), 1);
ASSERT_EQ(sscanf("1", "%" SCNdFAST16, &if16), 1);
ASSERT_EQ(sscanf("1", "%" SCNuFAST16, &uf16), 1);
ASSERT_EQ(sscanf("1", "%" SCNdFAST32, &if32), 1);
ASSERT_EQ(sscanf("1", "%" SCNuFAST32, &uf32), 1);
ASSERT_EQ(sscanf("1", "%" SCNdFAST64, &if64), 1);
ASSERT_EQ(sscanf("1", "%" SCNuFAST64, &uf64), 1);
ASSERT_EQ(i8, 1);
ASSERT_EQ(u8, 1);
ASSERT_EQ(i16, 1);
ASSERT_EQ(u16, 1);
ASSERT_EQ(i32, 1);
ASSERT_EQ(u32, 1);
ASSERT_EQ(i64, 1);
ASSERT_EQ(u64, 1);
ASSERT_EQ(imax, 1);
ASSERT_EQ(umax, 1);
ASSERT_EQ(il8, 1);
ASSERT_EQ(ul8, 1);
ASSERT_EQ(il16, 1);
ASSERT_EQ(ul16, 1);
ASSERT_EQ(il32, 1);
ASSERT_EQ(ul32, 1);
ASSERT_EQ(il64, 1);
ASSERT_EQ(ul64, 1);
ASSERT_EQ(if16, 1);
ASSERT_EQ(uf16, 1);
ASSERT_EQ(if32, 1);
ASSERT_EQ(uf32, 1);
ASSERT_EQ(if64, 1);
ASSERT_EQ(uf64, 1);
}
TEST(sscanf, test0) {
int v;
v = 0xFFFFFFFF;
ASSERT_EQ(sscanf("0", "%x", &v), 1);
ASSERT_EQ(v, 0);
v = 0xFFFFFFFF;
ASSERT_EQ(sscanf("0", "%X", &v), 1);
ASSERT_EQ(v, 0);
v = 0xFFFFFFFF;
ASSERT_EQ(sscanf("0", "%d", &v), 1);
ASSERT_EQ(v, 0);
v = 0xFFFFFFFF;
ASSERT_EQ(sscanf("0", "%o", &v), 1);
ASSERT_EQ(v, 0);
v = 0xFFFFFFFF;
ASSERT_EQ(sscanf("0", "%u", &v), 1);
ASSERT_EQ(v, 0);
v = 0xFFFFFFFF;
ASSERT_EQ(sscanf("0", "%b", &v), 1);
ASSERT_EQ(v, 0);
}