Vox/vlibc
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
a2f7c33601adb72cd27f35974e8acb1bfb1bf570
vlibc/tests/test_strtol.c
T

548 lines
17 KiB
C
Raw Blame History

/*
* vlibc — numeric string conversions test (todo 11).
*
* Exercises atoi/atol/atoll/atof, strtol/strtoul/strtoll/strtoull, and
* strtof/strtod/strtold against glibc-verified golden expectations (the
* corpus was diffed value+endptr+errno against glibc during development;
* the literals below are that diff's results):
*
* 1. base resolution: 0 (decimal/octal/0x-hex auto-detect), 2, 8, 10,
* 16, including the "0" / "0x" prefix edge cases ("0" base 0 is an
* octal subject of value 0 with the 0 consumed; "0x" base 0 with no
* hex digit has no subject at all; base 16 keeps "0" and stops at x);
* 2. leading C-locale whitespace and sign handling;
* 3. endptr correctness: past the last digit, at the first invalid
* character, or at nptr when no subject sequence exists;
* 4. exact boundaries without range errors: LONG_MAX / LONG_MIN /
* ULONG_MAX / ULLONG_MAX / DBL_MAX;
* 5. strtoul negative wrap (value-only, modulo 2^64, C23 7.24.1.4p8);
* 6. strtod: "inf"/"infinity"/"nan"/"nan(chars)" (case-insensitive),
* hex floats ("0x1.8p1"), "0.1" exact bits, "3.14159";
* 7. ato* wrappers.
*
* The `-f` failure mode runs the errno-writing scenarios (overflow clamps,
* EINVAL bases, HUGE_VAL, underflow-to-zero, hex subnormal). Because this
* standalone test is host-linked, vlibc's errno macro addresses glibc's
* TCB slot (%fs:0+8) — writing it corrupts the host. errno behavior is
* therefore verified only through the C23-mandated return-value clamps
* (LONG_MAX/LONG_MIN/HUGE_VAL presence proves ERANGE happened; EINVAL is
* proven by the zero return with endptr == nptr), never by reading errno,
* and the -f mode exits via a raw SYS_exit_group to skip host cleanup.
*
* No host headers: under -Iinclude the vlibc headers shadow GCC's
* internal ones, so all output goes through raw SYS_write. Not part of the
* library proper; compiled manually for this todo (the make check wiring
* is owned by a later todo).
*/
#include <stddef.h>
#include <float.h>
#include <limits.h>
#include "../include/stdlib.h"
#include "../src/internal/syscall.h"
static int failures;
static void
say(int fd, const char *s)
{
long n = 0;
while (s[n] != '\0')
{
n++;
}
__syscall3(SYS_write, fd, (long)s, n);
}
static void
say_dec(int fd, unsigned long v) // NOLINT(bugprone-easily-swappable-parameters)
{
char buf[24];
int i = (int)sizeof(buf);
buf[--i] = '\0';
do
{
buf[--i] = (char)('0' + (v % 10));
v /= 10;
} while (v != 0);
__syscall3(SYS_write, fd, (long)(buf + i), (long)(sizeof(buf) - 1 - i));
}
static void
check(int cond, const char *what)
{
if (cond)
{
say(1, "PASS: ");
say(1, what);
say(1, "\n");
}
else
{
say(2, "FAIL: ");
say(2, what);
say(2, "\n");
failures++;
}
}
static void
check_ptr(const char *got, const char *want,
const char *what) // NOLINT(bugprone-easily-swappable-parameters)
{
if (got == want)
{
say(1, "PASS: ");
say(1, what);
say(1, "\n");
}
else
{
say(2, "FAIL: ");
say(2, what);
say(2, " (endptr off by ");
say_dec(2, (unsigned long)(got - want));
say(2, ")\n");
failures++;
}
}
/* 1. Base resolution and prefix rules. */
static void
base_resolution(void)
{
const char *s;
char *e;
long v;
s = "0x1f";
v = strtol(s, &e, 0);
check(v == 31 && e == s + 4, "strtol(\"0x1f\",0)==31, endptr past digits");
s = "0x1f";
v = strtol(s, &e, 16);
check(v == 31 && e == s + 4, "strtol(\"0x1f\",16)==31");
s = "0x1F";
check(strtol(s, &e, 0) == 31 && e == s + 4, "strtol(\"0x1F\",0)==31 (upper hex)");
s = "101010";
check(strtol(s, &e, 2) == 42 && e == s + 6, "strtol(\"101010\",2)==42");
s = "777";
check(strtol(s, &e, 8) == 511 && e == s + 3, "strtol(\"777\",8)==511");
s = "42";
check(strtol(s, &e, 10) == 42 && e == s + 2, "strtol(\"42\",10)==42");
s = "ff";
check(strtol(s, &e, 16) == 255 && e == s + 2, "strtol(\"ff\",16)==255");
s = "ff";
v = strtol(s, &e, 10);
check(v == 0 && e == s, "strtol(\"ff\",10)==0, endptr at start (no digits)");
s = "0";
v = strtol(s, &e, 0);
check(v == 0 && e == s + 1, "strtol(\"0\",0)==0, octal-prefix 0 consumed");
s = "08";
v = strtol(s, &e, 0);
check(v == 0 && e == s + 1, "strtol(\"08\",0)==0, subject is the octal 0");
s = "0x";
v = strtol(s, &e, 0);
check(v == 0 && e == s, "strtol(\"0x\",0)==0, no subject sequence at all");
s = "0x";
v = strtol(s, &e, 16);
check(v == 0 && e == s + 1, "strtol(\"0x\",16)==0, the 0 is the subject");
s = "0xg";
v = strtol(s, &e, 0);
check(v == 0 && e == s, "strtol(\"0xg\",0): no hex digit, no subject");
s = "0b101";
v = strtol(s, &e, 0);
check(v == 0 && e == s + 1, "strtol(\"0b101\",0)==0, b is not octal");
s = "010";
check(strtol(s, &e, 0) == 8 && e == s + 3, "strtol(\"010\",0)==8 (octal)");
s = "1234";
check(strtol(s, &e, 36) == 49360 && e == s + 4, "strtol(\"1234\",36)==49360");
}
/* 2. Whitespace and signs. */
static void
whitespace_signs(void)
{
const char *s = " -42";
char *e;
check(strtol(s, &e, 0) == -42 && e == s + 5, "strtol(\" -42\",0)==-42");
s = "\t\n\v\f\r+42x";
check(strtol(s, &e, 10) == 42 && e == s + 8, "strtol(ws \"+42x\")==42, endptr at x");
s = " ";
check(strtol(s, &e, 10) == 0 && e == s, "strtol(whitespace only)==0, endptr at start");
s = "+";
check(strtol(s, &e, 10) == 0 && e == s, "strtol(\"+\")==0, endptr at start");
s = "-";
check(strtol(s, &e, 10) == 0 && e == s, "strtol(\"-\")==0, endptr at start");
s = "";
check(strtol(s, &e, 10) == 0 && e == s, "strtol(\"\")==0, endptr at start");
s = "-0x10";
check(strtol(s, &e, 0) == -16 && e == s + 5, "strtol(\"-0x10\",0)==-16");
s = " 0x10";
check(strtol(s, &e, 0) == 16 && e == s + 5, "strtol(\" 0x10\",0)==16");
}
/* 3. Endptr lands at the first invalid character. */
static void
endptr_positions(void)
{
const char *s = "12abc";
char *e;
check(strtol(s, &e, 10) == 12, "strtol(\"12abc\") value");
check_ptr(e, s + 2, "strtol(\"12abc\") endptr at 'a'");
s = "0x1fg";
check(strtol(s, &e, 0) == 31, "strtol(\"0x1fg\") value");
check_ptr(e, s + 4, "strtol(\"0x1fg\") endptr at 'g'");
s = "3.5";
check(strtol(s, &e, 10) == 3, "strtol(\"3.5\") value");
check_ptr(e, s + 1, "strtol(\"3.5\") endptr at '.'");
}
/* 4. Exact representable boundaries set no range error (proven by the
* exact return values; errno itself is never read here). */
static void
exact_boundaries(void)
{
check(strtol("9223372036854775807", NULL, 10) == LONG_MAX, "strtol max == LONG_MAX");
check(strtol("-9223372036854775808", NULL, 10) == LONG_MIN, "strtol min == LONG_MIN");
check(strtoll("9223372036854775807", NULL, 10) == LLONG_MAX, "strtoll max == LLONG_MAX");
check(strtoll("-9223372036854775808", NULL, 10) == LLONG_MIN, "strtoll min == LLONG_MIN");
check(strtoul("18446744073709551615", NULL, 10) == ULONG_MAX, "strtoul max == ULONG_MAX");
check(strtoull("18446744073709551615", NULL, 10) == ULLONG_MAX, "strtoull max == ULLONG_MAX");
check(strtol("9223372036854775807z", NULL, 10) == LONG_MAX, "strtol max with tail");
check(strtol("0x7fffffffffffffff", NULL, 0) == LONG_MAX, "strtol hex LONG_MAX");
check(strtol("-0x8000000000000000", NULL, 0) == LONG_MIN, "strtol hex LONG_MIN");
check(strtoul("0xffffffffffffffff", NULL, 0) == ULONG_MAX, "strtoul hex ULONG_MAX");
}
/* 5. strtoul negative wrap: value-only negation modulo 2^64 (C23
* 7.24.1.4p8) — never a range error, so this runs in default mode. */
static void
unsigned_negative_wrap(void)
{
check(strtoul("-1", NULL, 10) == ULONG_MAX, "strtoul(\"-1\") == ULONG_MAX (wrap)");
check(strtoull("-1", NULL, 10) == ULLONG_MAX, "strtoull(\"-1\") == ULLONG_MAX (wrap)");
check(strtoul("-4294967296", NULL, 10) == ULONG_MAX - 4294967295UL,
"strtoul(-2^32) == 2^64-2^32");
check(strtoul("-9223372036854775808", NULL, 10) == 9223372036854775808UL,
"strtoul(-2^63) == 2^63 (no range error)");
}
/* 6a. strtod special forms and hex floats. */
static void
strtod_special(void)
{
const char *s = "inf";
char *e;
double r;
r = strtod(s, &e);
check(r == __builtin_inf() && e == s + 3, "strtod(\"inf\") == +infinity");
s = "Infinity";
r = strtod(s, &e);
check(r == __builtin_inf() && e == s + 8, "strtod(\"Infinity\") == +infinity");
s = "-INF";
r = strtod(s, &e);
check(r == -__builtin_inf() && e == s + 4, "strtod(\"-INF\") == -infinity");
s = "infinityx";
r = strtod(s, &e);
check(r == __builtin_inf(), "strtod(\"infinityx\") value");
check_ptr(e, s + 8, "strtod(\"infinityx\") endptr at 'x'");
s = "nan";
r = strtod(s, &e);
check(r != r && e == s + 3, "strtod(\"nan\") is NaN, endptr past nan");
s = "NAN(xyz)";
r = strtod(s, &e);
check(r != r, "strtod(\"NAN(xyz)\") is NaN");
check_ptr(e, s + 8, "strtod(\"NAN(xyz)\") endptr past ')'");
s = "nan(x";
r = strtod(s, &e);
check(r != r, "strtod(\"nan(x\") is NaN");
check_ptr(e, s + 3, "strtod(\"nan(x\") endptr right after nan");
s = "in";
r = strtod(s, &e);
check(r == 0.0 && e == s, "strtod(\"in\")==0, endptr at start");
s = "0x1.8p1";
r = strtod(s, &e);
check(r == 3.0 && e == s + 7, "strtod(\"0x1.8p1\")==3.0");
s = "0x1p-2";
check(strtod(s, &e) == 0.25 && e == s + 6, "strtod(\"0x1p-2\")==0.25");
s = "0x1.8p1f";
r = strtod(s, &e);
check(r == 3.0, "strtod(\"0x1.8p1f\") value");
check_ptr(e, s + 7, "strtod(\"0x1.8p1f\") endptr at 'f'");
s = "0x8.8";
check(strtod(s, &e) == 8.5 && e == s + 5, "strtod(\"0x8.8\")==8.5");
s = "0x.8p1";
check(strtod(s, &e) == 1.0 && e == s + 6, "strtod(\"0x.8p1\")==1.0");
s = "0x1.fffffffffffffp+1023";
check(strtod(s, &e) == DBL_MAX && e == s + 23, "strtod(hex max normal) == DBL_MAX");
s = "0x";
r = strtod(s, &e);
check(r == 0.0, "strtod(\"0x\") value");
check_ptr(e, s + 1, "strtod(\"0x\") endptr after the 0 (glibc)");
}
/* 6b. strtod decimal conversions. */
static void
strtod_decimal(void)
{
const char *s = "0.1";
char *e;
double r;
r = strtod(s, &e);
check(r == 0x1.999999999999ap-4 && e == s + 3, "strtod(\"0.1\") has exact 0.1 bits");
s = "3.14159";
check(strtod(s, &e) == 3.14159 && e == s + 7, "strtod(\"3.14159\") == 3.14159");
s = "1.5e2";
check(strtod(s, &e) == 150.0 && e == s + 5, "strtod(\"1.5e2\")==150");
s = " -0.5";
check(strtod(s, &e) == -0.5 && e == s + 6, "strtod(\" -0.5\")==-0.5");
s = ".5";
check(strtod(s, &e) == 0.5 && e == s + 2, "strtod(\".5\")==0.5");
s = "1.";
check(strtod(s, &e) == 1.0 && e == s + 2, "strtod(\"1.\")==1.0");
s = ".";
r = strtod(s, &e);
check(r == 0.0 && e == s, "strtod(\".\")==0, endptr at start");
s = "1e";
r = strtod(s, &e);
check(r == 1.0 && e == s + 1, "strtod(\"1e\")==1.0, bare e not part of subject");
s = "0";
check(strtod(s, &e) == 0.0 && e == s + 1, "strtod(\"0\")==0.0");
s = "-0";
r = strtod(s, &e);
check(r == 0.0 && 1.0 / r == -__builtin_inf(), "strtod(\"-0\") == -0.0");
s = "123456789012345678901234567890";
r = strtod(s, &e);
check(r > 0.0 && e == s + 30, "strtod(30-digit integer) positive, endptr at end");
s = "9.999999999999999e22";
check(strtod(s, &e) == 9.999999999999999e22, "strtod(19-digit) exact");
}
/* 6c. strtof and strtold basics. */
static void
strtof_strtold(void)
{
const char *s = "0.1";
char *e;
check(strtof(s, &e) == 0.1f && e == s + 3, "strtof(\"0.1\") == 0.1f");
s = "inf";
check(strtof(s, &e) == __builtin_inff() && e == s + 3, "strtof(\"inf\") == +inf");
s = "nan";
{
float nf = strtof(s, &e);
check(nf != nf && e == s + 3, "strtof(\"nan\") is NaN");
}
s = "0x1.8p1";
check(strtof(s, &e) == 3.0f && e == s + 7, "strtof(\"0x1.8p1\")==3.0f");
s = "0.1";
check(strtold(s, &e) == 0.1L && e == s + 3, "strtold(\"0.1\") == 0.1L");
s = "3.14159";
check(strtold(s, &e) == 3.14159L && e == s + 7, "strtold(\"3.14159\") == 3.14159L");
s = "1e100";
check(strtold(s, &e) == 1e100L && e == s + 5, "strtold(\"1e100\") == 1e100L (exact)");
s = "0x1.8p1";
check(strtold(s, &e) == 3.0L && e == s + 7, "strtold(\"0x1.8p1\")==3.0L");
s = "nan";
{
long double nl = strtold(s, &e);
check(nl != nl && e == s + 3, "strtold(\"nan\") is NaN");
}
s = "1e999";
{
long double big = strtold(s, &e);
long double rel = big / 1e999L;
check(e == s + 5 && rel > 0.999999999999999L && rel < 1.000000000000001L,
"strtold(\"1e999\") within 1e-15 of 1e999 (no range error)");
}
}
/* 7. ato* wrappers. */
static void
ato_wrappers(void)
{
check(atoi("42") == 42, "atoi(\"42\")==42");
check(atoi(" -17") == -17, "atoi(\" -17\")==-17");
check(atol("2147483648") == 2147483648L, "atol(\"2147483648\")==2147483648");
check(atoll("9223372036854775807") == LLONG_MAX, "atoll max == LLONG_MAX");
check(atof("1.5") == 1.5, "atof(\"1.5\")==1.5");
check(atof(" +2.25e2") == 225.0, "atof(\" +2.25e2\")==225.0");
check(atof("0x1.8p1") == 3.0, "atof(\"0x1.8p1\")==3.0");
check(atof("x") == 0.0, "atof(\"x\")==0.0");
}
/*
* Failure scenarios (-f): every path that writes errno inside the library.
* Because the test is host-linked, those writes land in glibc's TCB slot,
* so errno is never read back — the C23 return-value clamps prove the
* ERANGE/EINVAL behavior — and the process exits through a raw
* SYS_exit_group without running host cleanup.
*/
static int
failure_scenarios(void)
{
const char *s;
char *e;
int bad = 0;
s = "9223372036854775808";
if (strtol(s, &e, 10) != LONG_MAX || e != s + 19)
{
bad++;
say(2, "FAIL: strtol overflow clamp\n");
}
s = "-9223372036854775809";
if (strtol(s, &e, 10) != LONG_MIN || e != s + 20)
{
bad++;
say(2, "FAIL: strtol negative overflow clamp\n");
}
s = "9223372036854775808";
if (strtoll(s, &e, 10) != LLONG_MAX || e != s + 19)
{
bad++;
say(2, "FAIL: strtoll overflow clamp\n");
}
s = "-9223372036854775809";
if (strtoll(s, &e, 10) != LLONG_MIN || e != s + 20)
{
bad++;
say(2, "FAIL: strtoll negative overflow clamp\n");
}
s = "18446744073709551616";
if (strtoul(s, &e, 10) != ULONG_MAX || e != s + 20)
{
bad++;
say(2, "FAIL: strtoul overflow clamp\n");
}
s = "18446744073709551617";
if (strtoull(s, &e, 10) != ULLONG_MAX || e != s + 20)
{
bad++;
say(2, "FAIL: strtoull overflow clamp\n");
}
s = "-18446744073709551616";
if (strtoul(s, &e, 10) != ULONG_MAX || e != s + 21)
{
bad++;
say(2, "FAIL: strtoul magnitude overflow (2^64) clamp\n");
}
s = "123";
if (strtol(s, &e, 1) != 0 || e != s)
{
bad++;
say(2, "FAIL: strtol base 1 (EINVAL): value/endptr\n");
}
s = "123";
if (strtol(s, &e, 37) != 0 || e != s)
{
bad++;
say(2, "FAIL: strtol base 37 (EINVAL): value/endptr\n");
}
s = "123";
if (strtoul(s, &e, -1) != 0 || e != s)
{
bad++;
say(2, "FAIL: strtoul base -1 (EINVAL): value/endptr\n");
}
s = "1e999";
if (strtod(s, &e) != __builtin_inf() || e != s + 5)
{
bad++;
say(2, "FAIL: strtod(\"1e999\") != +inf (HUGE_VAL)\n");
}
s = "-1e999";
if (strtod(s, &e) != -__builtin_inf() || e != s + 6)
{
bad++;
say(2, "FAIL: strtod(\"-1e999\") != -inf\n");
}
s = "1e-999";
if (strtod(s, &e) != 0.0 || e != s + 6)
{
bad++;
say(2, "FAIL: strtod(\"1e-999\") != 0.0 (underflow)\n");
}
s = "0x1.fffffffffffffp1024";
if (strtod(s, &e) != __builtin_inf() || e != s + 22)
{
bad++;
say(2, "FAIL: strtod(hex overflow) != +inf\n");
}
s = "0x0.0000000000001p-1022";
if (strtod(s, &e) != DBL_TRUE_MIN || e != s + 23)
{
bad++;
say(2, "FAIL: strtod(hex subnormal) != DBL_TRUE_MIN\n");
}
s = "1e999";
if (strtof(s, &e) != __builtin_inff() || e != s + 5)
{
bad++;
say(2, "FAIL: strtof(\"1e999\") != +inf\n");
}
s = "1e-999";
if (strtof(s, &e) != 0.0f || e != s + 6)
{
bad++;
say(2, "FAIL: strtof(\"1e-999\") != 0.0f\n");
}
s = "1e5000";
if (strtold(s, &e) != __builtin_infl() || e != s + 6)
{
bad++;
say(2, "FAIL: strtold(\"1e5000\") != +inf\n");
}
if (bad == 0)
{
say(1, "PASS: all overflow/EINVAL/underflow failure scenarios\n");
}
return bad > 0 ? 1 : 0;
}
int
main(int argc, char **argv)
{
int rc;
if (argc == 2 && argv[1][0] == '-' && argv[1][1] == 'f')
{
rc = failure_scenarios();
__syscall1(SYS_exit_group, rc);
return rc; /* not reached */
}
base_resolution();
whitespace_signs();
endptr_positions();
exact_boundaries();
unsigned_negative_wrap();
strtod_special();
strtod_decimal();
strtof_strtold();
ato_wrappers();
if (failures > 0)
{
say(2, "FAILED (");
say_dec(2, (unsigned long)failures);
say(2, " check(s))\n");
return 1;
}
say(1, "all strtol/strtod tests passed\n");
return 0;
}
Reference in New Issue View Git Blame Copy Permalink