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

Initial import

Browse source
This commit is contained in:
Justine Tunney 2020-06-15 07:18:57 -07:00
commit c91b3c5006
14915 changed files with 590219 additions and 0 deletions
Download patch file Download diff file Expand all files Collapse all files

653
test/libc/fmt/palandprintf_test.c Normal file
View file

@ -0,0 +1,653 @@
/*-*- 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/bits/progn.h"
#include "libc/bits/pushpop.h"
#include "libc/bits/safemacros.h"
#include "libc/errno.h"
#include "libc/fmt/fmt.h"
#include "libc/math.h"
#include "libc/mem/mem.h"
#include "libc/runtime/gc.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
#include "libc/x/x.h"
static char buffer[128];
#define Format(...) PROGN(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("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));
/* this testcase checks, that the precision is truncated to 9 digits. */
/* a perfect working float should return the whole number */
EXPECT_STREQ("42.895223123000", Format("%.12f", 42.89522312345678));
/* this testcase checks, that the precision is truncated AND rounded to 9 */
/* digits. a perfect working float should return the whole number */
EXPECT_STREQ("42.895223877000", Format("%.12f", 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.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));
/* out of range in the moment, need to be fixed by someone */
EXPECT_STREQ("INFINITY", 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));
EXPECT_EQ(ERANGE, errno);
errno = 0;
EXPECT_STREQ("Test16 65535", Format("%s%hhi %hu", "Test", 10000, 0xFFFFFFFF));
EXPECT_EQ(ERANGE, errno);
}
TEST(sprintf, test_pointer) {
sprintf(buffer, "%p", (void *)0x1234U);
if (sizeof(void *) == 4U) {
EXPECT_STREQ("00001234", buffer);
} else {
EXPECT_STREQ("000000001234", buffer);
}
sprintf(buffer, "%p", (void *)0x12345678U);
if (sizeof(void *) == 4U) {
EXPECT_STREQ("12345678", buffer);
} else {
EXPECT_STREQ("000012345678", buffer);
}
sprintf(buffer, "%p-%p", (void *)0x12345678U, (void *)0x7EDCBA98U);
if (sizeof(void *) == 4U) {
EXPECT_STREQ("12345678-7edcba98", buffer);
} else {
EXPECT_STREQ("000012345678-00007edcba98", buffer);
}
if (sizeof(uintptr_t) == sizeof(uint64_t)) {
sprintf(buffer, "%p", (void *)(uintptr_t)0xFFFFFFFFU);
EXPECT_STREQ("0000ffffffff", buffer);
} else {
sprintf(buffer, "%p", (void *)(uintptr_t)0xFFFFFFFFU);
EXPECT_STREQ("ffffffff", buffer);
}
}
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);
}
testonly void vsnprintf_builder_1(char *buf, ...) {
va_list args;
va_start(args, buf);
vsnprintf(buf, 100U, "%d", args);
va_end(args);
}
testonly 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, pointer_doesntShowNonCanonicalZeroes) {
ASSERT_STREQ("100000000010", gc(xasprintf("%p", 0x0000100000000010)));
ASSERT_STREQ("0x100000000010", gc(xasprintf("%#p", 0x0000100000000010)));
}
TEST(xasprintf, nonCanonicalPointer_discardsHighBits_ratherThanSaturate) {
ASSERT_STREQ("100000000010", gc(xasprintf("%p", 0x1000100000000010)));
ASSERT_STREQ("0x100000000010", gc(xasprintf("%#p", 0x1000100000000010)));
ASSERT_STREQ("7fffffffffff", gc(xasprintf("%p", 0x7fffffffffff)));
ASSERT_STREQ("0x7fffffffffff", gc(xasprintf("%#p", 0x7fffffffffff)));
}
TEST(snprintf, testFixedWidthString_wontOverrunInput) {
const int N = 2;
char *buf = tmalloc(N + 1);
char *inp = memcpy(tmalloc(N), "hi", N);
EXPECT_EQ(2, snprintf(buf, N + 1, "%.*s", N, inp));
EXPECT_BINEQ(u"hi ", buf);
tfree(inp);
tfree(buf);
}
TEST(snprintf, testFixedWidthStringIsNull_wontOverrunBuffer) {
int N = 3;
char *buf = tmalloc(N + 1);
EXPECT_EQ(6, snprintf(buf, N + 1, "%.*s", pushpop(N), pushpop(NULL)));
EXPECT_BINEQ(u"(nu ", buf);
EXPECT_EQ(6, snprintf(buf, N + 1, "%#.*s", pushpop(N), pushpop(NULL)));
EXPECT_BINEQ(u"(nu ", buf);
EXPECT_EQ(4, snprintf(buf, N + 1, "%`.*s", pushpop(N), pushpop(NULL)));
EXPECT_BINEQ(u"NUL ", buf);
EXPECT_EQ(4, snprintf(buf, N + 1, "%`#.*s", pushpop(N), pushpop(NULL)));
EXPECT_BINEQ(u"NUL ", buf);
tfree(buf);
}
TEST(snprintf, testFixedWidthStringIsNull_wontLeakMemory) {
int N = 16;
char *buf = tmalloc(N + 1);
memset(buf, 0, N + 1);
EXPECT_EQ(6, snprintf(buf, N + 1, "%.*s", pushpop(N), pushpop(NULL)));
EXPECT_BINEQ(u"(null)           ", buf);
memset(buf, 0, N + 1);
EXPECT_EQ(6, snprintf(buf, N + 1, "%#.*s", pushpop(N), pushpop(NULL)));
EXPECT_BINEQ(u"(null)           ", buf);
memset(buf, 0, N + 1);
EXPECT_EQ(4, snprintf(buf, N + 1, "%`.*s", pushpop(N), pushpop(NULL)));
EXPECT_BINEQ(u"NULL             ", buf);
memset(buf, 0, N + 1);
EXPECT_EQ(4, snprintf(buf, N + 1, "%`#.*s", pushpop(N), pushpop(NULL)));
EXPECT_BINEQ(u"NULL             ", buf);
tfree(buf);
}

76
test/libc/fmt/sprintf_s.inc Normal file
View file

@ -0,0 +1,76 @@
/*-*- 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 │
│ │
│ This program is free software; you can redistribute it and/or modify │
│ it under the terms of the GNU General Public License as published by │
│ the Free Software Foundation; version 2 of the License. │
│ │
│ This program is distributed in the hope that it will be useful, but │
│ WITHOUT ANY WARRANTY; without even the implied warranty of │
│ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU │
│ General Public License for more details. │
│ │
│ You should have received a copy of the GNU General Public License │
│ along with this program; if not, write to the Free Software │
│ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA │
│ 02110-1301 USA │
╚─────────────────────────────────────────────────────────────────────────────*/
/* 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("(╯°□°)╯︵ ┻━┻ ", Format("%-20ls", L"(╯°□°)╯︵ ┻━┻"));
EXPECT_STREQ("ちゃぶ台返し ", Format("%-20ls", L"ちゃぶ台返し"));
EXPECT_STREQ(" (╯°□°)╯︵ ┻━┻", Format("%20ls", 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_usesCodepointCount) {
EXPECT_STREQ("ちゃぶ台返し", Format("%.*s", 6, "ちゃぶ台返し"));
}

60
test/libc/fmt/sprintf_s_test.c Normal file
View file

@ -0,0 +1,60 @@
/*-*- 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 │
│ │
│ This program is free software; you can redistribute it and/or modify │
│ it under the terms of the GNU General Public License as published by │
│ the Free Software Foundation; version 2 of the License. │
│ │
│ This program is distributed in the hope that it will be useful, but │
│ WITHOUT ANY WARRANTY; without even the implied warranty of │
│ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU │
│ General Public License for more details. │
│ │
│ You should have received a copy of the GNU General Public License │
│ along with this program; if not, write to the Free Software │
│ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA │
│ 02110-1301 USA │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/bits/bits.h"
#include "libc/bits/progn.h"
#include "libc/bits/safemacros.h"
#include "libc/fmt/fmt.h"
#include "libc/testlib/testlib.h"
static char buffer[128];
#define Format(...) PROGN(snprintf(buffer, sizeof(buffer), __VA_ARGS__), buffer)
/**
* @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/fmt/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/fmt/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/fmt/sprintf_s.inc"
#undef SUITE
#undef FORMAT
#undef STRING

144
test/libc/fmt/sscanf_test.c Normal file
View file

@ -0,0 +1,144 @@
/*-*- 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 │
│ │
│ This program is free software; you can redistribute it and/or modify │
│ it under the terms of the GNU General Public License as published by │
│ the Free Software Foundation; version 2 of the License. │
│ │
│ This program is distributed in the hope that it will be useful, but │
│ WITHOUT ANY WARRANTY; without even the implied warranty of │
│ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU │
│ General Public License for more details. │
│ │
│ You should have received a copy of the GNU General Public License │
│ along with this program; if not, write to the Free Software │
│ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA │
│ 02110-1301 USA │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/bits/bits.h"
#include "libc/errno.h"
#include "libc/fmt/fmt.h"
#include "libc/limits.h"
#include "libc/mem/mem.h"
#include "libc/testlib/testlib.h"
#define sscanf1(STR, FMT) \
({ \
errno = 0; \
intmax_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(INTMAX_MAX,
sscanf1("170141183460469231731687303715884105727", "%jd"));
EXPECT_EQ(INTMAX_MIN,
sscanf1("-170141183460469231731687303715884105728", "%jd"));
EXPECT_EQ(UINTMAX_MAX, sscanf1("0xffffffffffffffffffffffffffffffff", "%jx"));
}
TEST(sscanf, testOctal) {
EXPECT_EQ(0123, sscanf1("123", "%o"));
EXPECT_EQ(0123, sscanf1("0123", "%o"));
}
TEST(sscanf, testNonDirectiveCharacterMatching) {
EXPECT_EQ(0, sscanf("", ""));
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_gothicUtf8ToUtf16) {
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);
}

54
test/libc/fmt/strerror_test.c Normal file
View file

@ -0,0 +1,54 @@
/*-*- 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 │
│ │
│ This program is free software; you can redistribute it and/or modify │
│ it under the terms of the GNU General Public License as published by │
│ the Free Software Foundation; version 2 of the License. │
│ │
│ This program is distributed in the hope that it will be useful, but │
│ WITHOUT ANY WARRANTY; without even the implied warranty of │
│ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU │
│ General Public License for more details. │
│ │
│ You should have received a copy of the GNU General Public License │
│ along with this program; if not, write to the Free Software │
│ Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA │
│ 02110-1301 USA │
╚─────────────────────────────────────────────────────────────────────────────*/
#include "libc/bits/bits.h"
#include "libc/dce.h"
#include "libc/errno.h"
#include "libc/fmt/fmt.h"
#include "libc/str/str.h"
#include "libc/testlib/testlib.h"
/*
* If these tests break, it's probably because
* libc/sysv/consts.sh changed and
* libc/sysv/kErrnoNames.S needs updating.
*/
TEST(strerror, enosys) {
if (IsTiny()) return;
EXPECT_STARTSWITH("ENOSYS", strerror(ENOSYS));
}
TEST(strerror, symbolizingTheseNumbersAsErrorsIsHeresyInUnixStyle) {
EXPECT_STARTSWITH("E?/err=0/errno:0/GetLastError:0", strerror(0));
EXPECT_STARTSWITH("E?", strerror(-1));
}
TEST(strerror, enotconn_orLinkerIsntUsingLocaleC_orCodeIsOutOfSync) {
if (IsTiny()) return;
EXPECT_STARTSWITH("ENOTCONN", strerror(ENOTCONN));
}
TEST(strerror, exfull_orLinkerIsntUsingLocaleC_orCodeIsOutOfSync) {
if (IsLinux() && !IsTiny()) {
EXPECT_STARTSWITH("EXFULL", strerror(EXFULL));
} else {
EXPECT_STARTSWITH("E?", strerror(EXFULL));
}
}

55
test/libc/fmt/test.mk Normal file
View file

@ -0,0 +1,55 @@
#-*-mode:makefile-gmake;indent-tabs-mode:t;tab-width:8;coding:utf-8-*-┐
#───vi: set et ft=make ts=8 tw=8 fenc=utf-8 :vi───────────────────────┘
PKGS += TEST_LIBC_FMT
TEST_LIBC_FMT_SRCS := $(wildcard test/libc/fmt/*.c)
TEST_LIBC_FMT_SRCS_TEST = $(filter %_test.c,$(TEST_LIBC_FMT_SRCS))
TEST_LIBC_FMT_COMS = $(TEST_LIBC_FMT_OBJS:%.o=%.com)
TEST_LIBC_FMT_BINS = $(TEST_LIBC_FMT_COMS) $(TEST_LIBC_FMT_COMS:%=%.dbg)
TEST_LIBC_FMT_TESTS = $(TEST_LIBC_FMT_SRCS_TEST:%.c=o/$(MODE)/%.com.ok)
TEST_LIBC_FMT_OBJS = \
$(TEST_LIBC_FMT_SRCS:%=o/$(MODE)/%.zip.o) \
$(TEST_LIBC_FMT_SRCS:%.c=o/$(MODE)/%.o)
TEST_LIBC_FMT_CHECKS = \
$(TEST_LIBC_FMT_SRCS_TEST:%.c=o/$(MODE)/%.com.runs)
TEST_LIBC_FMT_DIRECTDEPS = \
LIBC_CALLS_HEFTY \
LIBC_FMT \
LIBC_MEM \
LIBC_NEXGEN32E \
LIBC_RUNTIME \
LIBC_STR \
LIBC_STUBS \
LIBC_SYSV \
LIBC_TESTLIB \
LIBC_UNICODE \
LIBC_X
TEST_LIBC_FMT_DEPS := \
$(call uniq,$(foreach x,$(TEST_LIBC_FMT_DIRECTDEPS),$($(x))))
o/$(MODE)/test/libc/fmt/fmt.pkg: \
$(TEST_LIBC_FMT_OBJS) \
$(foreach x,$(TEST_LIBC_FMT_DIRECTDEPS),$($(x)_A).pkg)
o/$(MODE)/test/libc/fmt/%.com.dbg: \
$(TEST_LIBC_FMT_DEPS) \
o/$(MODE)/test/libc/fmt/%.o \
o/$(MODE)/test/libc/fmt/fmt.pkg \
$(LIBC_TESTMAIN) \
$(CRT) \
$(APE)
@$(APELINK)
$(TEST_LIBC_FMT_OBJS): \
$(BUILD_FILES) \
test/libc/fmt/test.mk
.PHONY: o/$(MODE)/test/libc/fmt
o/$(MODE)/test/libc/fmt: \
$(TEST_LIBC_FMT_BINS) \
$(TEST_LIBC_FMT_CHECKS)