From e18c25d23de0e845f0ee7e11d02c1be044738a3c Mon Sep 17 00:00:00 2001
From: Jason Evans <je@fb.com>
Date: Mon, 6 Jan 2014 20:33:48 -0800
Subject: Add util unit tests, and fix discovered bugs.
Add unit tests for pow2_ceil(), malloc_strtoumax(), and
malloc_snprintf().
Fix numerous bugs in malloc_strotumax() error handling/reporting. These
bugs could have caused application-visible issues for some seldom used
(0X... and 0... prefixes) or malformed MALLOC_CONF or mallctl() argument
strings, but otherwise they had no impact.
Fix numerous bugs in malloc_snprintf(). These bugs were not exercised
by existing malloc_*printf() calls, so they had no impact.
---
Makefile.in | 2 +-
include/jemalloc/internal/util.h | 3 +-
src/util.c | 64 +++++----
test/include/test/test.h | 83 +++++++++++
test/unit/util.c | 294 +++++++++++++++++++++++++++++++++++++++
5 files changed, 416 insertions(+), 30 deletions(-)
create mode 100644 test/unit/util.c
diff --git a/Makefile.in b/Makefile.in
index 78f16af..470495c 100644
--- a/Makefile.in
+++ b/Makefile.in
@@ -114,7 +114,7 @@ TESTS_UNIT := $(srcroot)test/unit/bitmap.c $(srcroot)test/unit/ckh.c \
$(srcroot)test/unit/qr.c $(srcroot)test/unit/quarantine.c \
$(srcroot)test/unit/rb.c $(srcroot)test/unit/rtree.c \
$(srcroot)test/unit/SFMT.c $(srcroot)test/unit/stats.c \
- $(srcroot)test/unit/tsd.c
+ $(srcroot)test/unit/tsd.c $(srcroot)test/unit/util.c
TESTS_INTEGRATION := $(srcroot)test/integration/aligned_alloc.c \
$(srcroot)test/integration/allocated.c \
$(srcroot)test/integration/mallocx.c \
diff --git a/include/jemalloc/internal/util.h b/include/jemalloc/internal/util.h
index 302444d..6b938f7 100644
--- a/include/jemalloc/internal/util.h
+++ b/include/jemalloc/internal/util.h
@@ -85,7 +85,8 @@
#ifdef JEMALLOC_H_EXTERNS
int buferror(int err, char *buf, size_t buflen);
-uintmax_t malloc_strtoumax(const char *nptr, char **endptr, int base);
+uintmax_t malloc_strtoumax(const char *restrict nptr,
+ char **restrict endptr, int base);
void malloc_write(const char *s);
/*
diff --git a/src/util.c b/src/util.c
index 6cedf8c..2006255 100644
--- a/src/util.c
+++ b/src/util.c
@@ -97,22 +97,24 @@ buferror(int err, char *buf, size_t buflen)
}
uintmax_t
-malloc_strtoumax(const char *nptr, char **endptr, int base)
+malloc_strtoumax(const char *restrict nptr, char **restrict endptr, int base)
{
uintmax_t ret, digit;
int b;
bool neg;
const char *p, *ns;
+ p = nptr;
if (base < 0 || base == 1 || base > 36) {
+ ns = p;
set_errno(EINVAL);
- return (UINTMAX_MAX);
+ ret = UINTMAX_MAX;
+ goto label_return;
}
b = base;
/* Swallow leading whitespace and get sign, if any. */
neg = false;
- p = nptr;
while (true) {
switch (*p) {
case '\t': case '\n': case '\v': case '\f': case '\r': case ' ':
@@ -146,7 +148,7 @@ malloc_strtoumax(const char *nptr, char **endptr, int base)
if (b == 8)
p++;
break;
- case 'x':
+ case 'X': case 'x':
switch (p[2]) {
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9':
@@ -164,7 +166,9 @@ malloc_strtoumax(const char *nptr, char **endptr, int base)
}
break;
default:
- break;
+ p++;
+ ret = 0;
+ goto label_return;
}
}
if (b == 0)
@@ -181,13 +185,22 @@ malloc_strtoumax(const char *nptr, char **endptr, int base)
if (ret < pret) {
/* Overflow. */
set_errno(ERANGE);
- return (UINTMAX_MAX);
+ ret = UINTMAX_MAX;
+ goto label_return;
}
p++;
}
if (neg)
ret = -ret;
+ if (p == ns) {
+ /* No conversion performed. */
+ set_errno(EINVAL);
+ ret = UINTMAX_MAX;
+ goto label_return;
+ }
+
+label_return:
if (endptr != NULL) {
if (p == ns) {
/* No characters were converted. */
@@ -195,7 +208,6 @@ malloc_strtoumax(const char *nptr, char **endptr, int base)
} else
*endptr = (char *)p;
}
-
return (ret);
}
@@ -354,6 +366,9 @@ malloc_vsnprintf(char *str, size_t size, const char *format, va_list ap)
case 'j': \
val = va_arg(ap, intmax_t); \
break; \
+ case 'j' | 0x80: \
+ val = va_arg(ap, uintmax_t); \
+ break; \
case 't': \
val = va_arg(ap, ptrdiff_t); \
break; \
@@ -419,6 +434,10 @@ malloc_vsnprintf(char *str, size_t size, const char *format, va_list ap)
case '*':
width = va_arg(ap, int);
f++;
+ if (width < 0) {
+ left_justify = true;
+ width = -width;
+ }
break;
case '0': case '1': case '2': case '3': case '4':
case '5': case '6': case '7': case '8': case '9': {
@@ -428,19 +447,16 @@ malloc_vsnprintf(char *str, size_t size, const char *format, va_list ap)
assert(uwidth != UINTMAX_MAX || get_errno() !=
ERANGE);
width = (int)uwidth;
- if (*f == '.') {
- f++;
- goto label_precision;
- } else
- goto label_length;
break;
- } case '.':
- f++;
- goto label_precision;
- default: goto label_length;
+ } default:
+ break;
}
+ /* Width/precision separator. */
+ if (*f == '.')
+ f++;
+ else
+ goto label_length;
/* Precision. */
- label_precision:
switch (*f) {
case '*':
prec = va_arg(ap, int);
@@ -469,16 +485,8 @@ malloc_vsnprintf(char *str, size_t size, const char *format, va_list ap)
} else
len = 'l';
break;
- case 'j':
- len = 'j';
- f++;
- break;
- case 't':
- len = 't';
- f++;
- break;
- case 'z':
- len = 'z';
+ case 'q': case 'j': case 't': case 'z':
+ len = *f;
f++;
break;
default: break;
@@ -540,7 +548,7 @@ malloc_vsnprintf(char *str, size_t size, const char *format, va_list ap)
assert(len == '?' || len == 'l');
assert_not_implemented(len != 'l');
s = va_arg(ap, char *);
- slen = (prec == -1) ? strlen(s) : prec;
+ slen = (prec < 0) ? strlen(s) : prec;
APPEND_PADDED_S(s, slen, width, left_justify);
f++;
break;
diff --git a/test/include/test/test.h b/test/include/test/test.h
index 5f98575..8cc97af 100644
--- a/test/include/test/test.h
+++ b/test/include/test/test.h
@@ -48,6 +48,84 @@
#define assert_u_ge(a, b, fmt...) assert_cmp(int, a, b, >=, <, "u", fmt)
#define assert_u_gt(a, b, fmt...) assert_cmp(int, a, b, >, <=, "u", fmt)
+#define assert_ld_eq(a, b, fmt...) assert_cmp(long, a, b, ==, \
+ !=, "ld", fmt)
+#define assert_ld_ne(a, b, fmt...) assert_cmp(long, a, b, !=, \
+ ==, "ld", fmt)
+#define assert_ld_lt(a, b, fmt...) assert_cmp(long, a, b, <, \
+ >=, "ld", fmt)
+#define assert_ld_le(a, b, fmt...) assert_cmp(long, a, b, <=, \
+ >, "ld", fmt)
+#define assert_ld_ge(a, b, fmt...) assert_cmp(long, a, b, >=, \
+ <, "ld", fmt)
+#define assert_ld_gt(a, b, fmt...) assert_cmp(long, a, b, >, \
+ <=, "ld", fmt)
+
+#define assert_lu_eq(a, b, fmt...) assert_cmp(unsigned long, \
+ a, b, ==, !=, "lu", fmt)
+#define assert_lu_ne(a, b, fmt...) assert_cmp(unsigned long, \
+ a, b, !=, ==, "lu", fmt)
+#define assert_lu_lt(a, b, fmt...) assert_cmp(unsigned long, \
+ a, b, <, >=, "lu", fmt)
+#define assert_lu_le(a, b, fmt...) assert_cmp(unsigned long, \
+ a, b, <=, >, "lu", fmt)
+#define assert_lu_ge(a, b, fmt...) assert_cmp(unsigned long, \
+ a, b, >=, <, "lu", fmt)
+#define assert_lu_gt(a, b, fmt...) assert_cmp(unsigned long, \
+ a, b, >, <=, "lu", fmt)
+
+#define assert_qd_eq(a, b, fmt...) assert_cmp(long long, a, b, ==, \
+ !=, "qd", fmt)
+#define assert_qd_ne(a, b, fmt...) assert_cmp(long long, a, b, !=, \
+ ==, "qd", fmt)
+#define assert_qd_lt(a, b, fmt...) assert_cmp(long long, a, b, <, \
+ >=, "qd", fmt)
+#define assert_qd_le(a, b, fmt...) assert_cmp(long long, a, b, <=, \
+ >, "qd", fmt)
+#define assert_qd_ge(a, b, fmt...) assert_cmp(long long, a, b, >=, \
+ <, "qd", fmt)
+#define assert_qd_gt(a, b, fmt...) assert_cmp(long long, a, b, >, \
+ <=, "qd", fmt)
+
+#define assert_qu_eq(a, b, fmt...) assert_cmp(unsigned long long, \
+ a, b, ==, !=, "qu", fmt)
+#define assert_qu_ne(a, b, fmt...) assert_cmp(unsigned long long, \
+ a, b, !=, ==, "qu", fmt)
+#define assert_qu_lt(a, b, fmt...) assert_cmp(unsigned long long, \
+ a, b, <, >=, "qu", fmt)
+#define assert_qu_le(a, b, fmt...) assert_cmp(unsigned long long, \
+ a, b, <=, >, "qu", fmt)
+#define assert_qu_ge(a, b, fmt...) assert_cmp(unsigned long long, \
+ a, b, >=, <, "qu", fmt)
+#define assert_qu_gt(a, b, fmt...) assert_cmp(unsigned long long, \
+ a, b, >, <=, "qu", fmt)
+
+#define assert_jd_eq(a, b, fmt...) assert_cmp(intmax_t, a, b, ==, \
+ !=, "jd", fmt)
+#define assert_jd_ne(a, b, fmt...) assert_cmp(intmax_t, a, b, !=, \
+ ==, "jd", fmt)
+#define assert_jd_lt(a, b, fmt...) assert_cmp(intmax_t, a, b, <, \
+ >=, "jd", fmt)
+#define assert_jd_le(a, b, fmt...) assert_cmp(intmax_t, a, b, <=, \
+ >, "jd", fmt)
+#define assert_jd_ge(a, b, fmt...) assert_cmp(intmax_t, a, b, >=, \
+ <, "jd", fmt)
+#define assert_jd_gt(a, b, fmt...) assert_cmp(intmax_t, a, b, >, \
+ <=, "jd", fmt)
+
+#define assert_ju_eq(a, b, fmt...) assert_cmp(uintmax_t, a, b, ==, \
+ !=, "ju", fmt)
+#define assert_ju_ne(a, b, fmt...) assert_cmp(uintmax_t, a, b, !=, \
+ ==, "ju", fmt)
+#define assert_ju_lt(a, b, fmt...) assert_cmp(uintmax_t, a, b, <, \
+ >=, "ju", fmt)
+#define assert_ju_le(a, b, fmt...) assert_cmp(uintmax_t, a, b, <=, \
+ >, "ju", fmt)
+#define assert_ju_ge(a, b, fmt...) assert_cmp(uintmax_t, a, b, >=, \
+ <, "ju", fmt)
+#define assert_ju_gt(a, b, fmt...) assert_cmp(uintmax_t, a, b, >, \
+ <=, "ju", fmt)
+
#define assert_zd_eq(a, b, fmt...) assert_cmp(ssize_t, a, b, ==, \
!=, "zd", fmt)
#define assert_zd_ne(a, b, fmt...) assert_cmp(ssize_t, a, b, !=, \
@@ -172,6 +250,11 @@
} \
} while (0)
+#define assert_not_reached(fmt...) do { \
+ p_test_fail("%s:%s:%d: Unreachable code reached: ", \
+ __func__, __FILE__, __LINE__, fmt); \
+} while (0)
+
/*
* If this enum changes, corresponding changes in test/test.sh.in are also
* necessary.
diff --git a/test/unit/util.c b/test/unit/util.c
new file mode 100644
index 0000000..1f2f575
--- /dev/null
+++ b/test/unit/util.c
@@ -0,0 +1,294 @@
+#include "test/jemalloc_test.h"
+
+TEST_BEGIN(test_pow2_ceil)
+{
+ unsigned i, pow2;
+ size_t x;
+
+ assert_zu_eq(pow2_ceil(0), 0, "Unexpected result");
+
+ for (i = 0; i < sizeof(size_t) * 8; i++) {
+ assert_zu_eq(pow2_ceil(ZU(1) << i), ZU(1) << i,
+ "Unexpected result");
+ }
+
+ for (i = 2; i < sizeof(size_t) * 8; i++) {
+ assert_zu_eq(pow2_ceil((ZU(1) << i) - 1), ZU(1) << i,
+ "Unexpected result");
+ }
+
+ for (i = 0; i < sizeof(size_t) * 8 - 1; i++) {
+ assert_zu_eq(pow2_ceil((ZU(1) << i) + 1), ZU(1) << (i+1),
+ "Unexpected result");
+ }
+
+ for (pow2 = 1; pow2 < 25; pow2++) {
+ for (x = (ZU(1) << (pow2-1)) + 1; x <= ZU(1) << pow2; x++) {
+ assert_zu_eq(pow2_ceil(x), ZU(1) << pow2,
+ "Unexpected result, x=%zu", x);
+ }
+ }
+}
+TEST_END
+
+TEST_BEGIN(test_malloc_strtoumax_no_endptr)
+{
+ int err;
+
+ set_errno(0);
+ assert_ju_eq(malloc_strtoumax("0", NULL, 0), 0, "Unexpected result");
+ err = get_errno();
+ assert_d_eq(err, 0, "Unexpected failure");
+}
+TEST_END
+
+TEST_BEGIN(test_malloc_strtoumax)
+{
+ struct test_s {
+ const char *input;
+ const char *expected_remainder;
+ int base;
+ int expected_errno;
+ const char *expected_errno_name;
+ uintmax_t expected_x;
+ };
+#define ERR(e) e, #e
+#define UMAX(x) ((uintmax_t)x##ULL)
+ struct test_s tests[] = {
+ {"0", "0", -1, ERR(EINVAL), UINTMAX_MAX},
+ {"0", "0", 1, ERR(EINVAL), UINTMAX_MAX},
+ {"0", "0", 37, ERR(EINVAL), UINTMAX_MAX},
+
+ {"", "", 0, ERR(EINVAL), UINTMAX_MAX},
+ {"+", "+", 0, ERR(EINVAL), UINTMAX_MAX},
+ {"++3", "++3", 0, ERR(EINVAL), UINTMAX_MAX},
+ {"-", "-", 0, ERR(EINVAL), UINTMAX_MAX},
+
+ {"42", "", 0, ERR(0), UMAX(42)},
+ {"+42", "", 0, ERR(0), UMAX(42)},
+ {"-42", "", 0, ERR(0), UMAX(-42)},
+ {"042", "", 0, ERR(0), UMAX(042)},
+ {"+042", "", 0, ERR(0), UMAX(042)},
+ {"-042", "", 0, ERR(0), UMAX(-042)},
+ {"0x42", "", 0, ERR(0), UMAX(0x42)},
+ {"+0x42", "", 0, ERR(0), UMAX(0x42)},
+ {"-0x42", "", 0, ERR(0), UMAX(-0x42)},
+
+ {"0", "", 0, ERR(0), UMAX(0)},
+ {"1", "", 0, ERR(0), UMAX(1)},
+
+ {"42", "", 0, ERR(0), UMAX(42)},
+ {" 42", "", 0, ERR(0), UMAX(42)},
+ {"42 ", " ", 0, ERR(0), UMAX(42)},
+ {"0x", "x", 0, ERR(0), UMAX(0)},
+ {"42x", "x", 0, ERR(0), UMAX(42)},
+
+ {"07", "", 0, ERR(0), UMAX(7)},
+ {"010", "", 0, ERR(0), UMAX(8)},
+ {"08", "8", 0, ERR(0), UMAX(0)},
+ {"0_", "_", 0, ERR(0), UMAX(0)},
+
+ {"0x", "x", 0, ERR(0), UMAX(0)},
+ {"0X", "X", 0, ERR(0), UMAX(0)},
+ {"0xg", "xg", 0, ERR(0), UMAX(0)},
+ {"0XA", "", 0, ERR(0), UMAX(10)},
+
+ {"010", "", 10, ERR(0), UMAX(10)},
+ {"0x3", "x3", 10, ERR(0), UMAX(0)},
+
+ {"12", "2", 2, ERR(0), UMAX(1)},
+ {"78", "8", 8, ERR(0), UMAX(7)},
+ {"9a", "a", 10, ERR(0), UMAX(9)},
+ {"9A", "A", 10, ERR(0), UMAX(9)},
+ {"fg", "g", 16, ERR(0), UMAX(15)},
+ {"FG", "G", 16, ERR(0), UMAX(15)},
+ {"0xfg", "g", 16, ERR(0), UMAX(15)},
+ {"0XFG", "G", 16, ERR(0), UMAX(15)},
+ {"z_", "_", 36, ERR(0), UMAX(35)},
+ {"Z_", "_", 36, ERR(0), UMAX(35)}
+ };
+#undef ERR
+#undef UMAX
+ unsigned i;
+
+ for (i = 0; i < sizeof(tests)/sizeof(struct test_s); i++) {
+ struct test_s *test = &tests[i];
+ int err;
+ uintmax_t result;
+ char *remainder;
+
+ set_errno(0);
+ result = malloc_strtoumax(test->input, &remainder, test->base);
+ err = get_errno();
+ assert_d_eq(err, test->expected_errno,
+ "Expected errno %s for \"%s\", base %d",
+ test->expected_errno_name, test->input, test->base);
+ assert_str_eq(remainder, test->expected_remainder,
+ "Unexpected remainder for \"%s\", base %d",
+ test->input, test->base);
+ if (err == 0) {
+ assert_ju_eq(result, test->expected_x,
+ "Unexpected result for \"%s\", base %d",
+ test->input, test->base);
+ }
+ }
+}
+TEST_END
+
+TEST_BEGIN(test_malloc_snprintf_truncated)
+{
+#define BUFLEN 15
+ char buf[BUFLEN];
+ int result;
+ size_t len;
+#define TEST(expected_str_untruncated, fmt...) do { \
+ result = malloc_snprintf(buf, len, fmt); \
+ assert_d_eq(strncmp(buf, expected_str_untruncated, len-1), 0, \
+ "Unexpected string inequality (\"%s\" vs \"%s\")", \
+ buf, expected_str_untruncated); \
+ assert_d_eq(result, strlen(expected_str_untruncated), \
+ "Unexpected result"); \
+} while (0)
+
+ for (len = 1; len < BUFLEN; len++) {
+ TEST("", "");
+ TEST("012346789", "012346789");
+ TEST("a0123b", "a%sb", "0123");
+ TEST("a01234567", "a%s%s", "0123", "4567");
+ TEST("a0123 ", "a%-6s", "0123");
+ TEST("a 0123", "a%6s", "0123");
+ TEST("a 012", "a%6.3s", "0123");
+ TEST("a 012", "a%*.*s", 6, 3, "0123");
+ TEST("a 123b", "a% db", 123);
+ TEST("a123b", "a%-db", 123);
+ TEST("a-123b", "a%-db", -123);
+ TEST("a+123b", "a%+db", 123);
+ }
+#undef BUFLEN
+#undef TEST
+}
+TEST_END
+
+TEST_BEGIN(test_malloc_snprintf)
+{
+#define BUFLEN 128
+ char buf[BUFLEN];
+ int result;
+#define TEST(expected_str, fmt...) do { \
+ result = malloc_snprintf(buf, sizeof(buf), fmt); \
+ assert_str_eq(buf, expected_str, "Unexpected output"); \
+ assert_d_eq(result, strlen(expected_str), "Unexpected result"); \
+} while (0)
+
+ TEST("", "");
+ TEST("hello", "hello");
+
+ TEST("a0123b", "a%sb", "0123");
+
+ TEST("a 0123b", "a%5sb", "0123");
+ TEST("a 0123b", "a%*sb", 5, "0123");
+
+ TEST("a0123 b", "a%-5sb", "0123");
+ TEST("a0123b", "a%*sb", -1, "0123");
+ TEST("a0123 b", "a%*sb", -5, "0123");
+ TEST("a0123 b", "a%-*sb", -5, "0123");
+
+ TEST("a012b", "a%.3sb", "0123");
+ TEST("a012b", "a%.*sb", 3, "0123");
+ TEST("a0123b", "a%.*sb", -3, "0123");
+
+ TEST("a 012b", "a%5.3sb", "0123");
+ TEST("a 012b", "a%5.*sb", 3, "0123");
+ TEST("a 012b", "a%*.3sb", 5, "0123");
+ TEST("a 012b", "a%*.*sb", 5, 3, "0123");
+ TEST("a 0123b", "a%*.*sb", 5, -3, "0123");
+
+ TEST("_abcd_", "_%x_", 0xabcd);
+ TEST("_0xabcd_", "_%#x_", 0xabcd);
+ TEST("_1234_", "_%o_", 01234);
+ TEST("_01234_", "_%#o_", 01234);
+ TEST("_1234_", "_%u_", 1234);
+
+ TEST("_1234_", "_%d_", 1234);
+ TEST("_ 1234_", "_% d_", 1234);
+ TEST("_+1234_", "_%+d_", 1234);
+ TEST("_-1234_", "_%d_", -1234);
+ TEST("_-1234_", "_% d_", -1234);
+ TEST("_-1234_", "_%+d_", -1234);
+
+ TEST("_-1234_", "_%d_", -1234);
+ TEST("_1234_", "_%d_", 1234);
+ TEST("_-1234_", "_%i_", -1234);
+ TEST("_1234_", "_%i_", 1234);
+ TEST("_01234_", "_%#o_", 01234);
+ TEST("_1234_", "_%u_", 1234);
+ TEST("_0x1234abc_", "_%#x_", 0x1234abc);
+ TEST("_0X1234ABC_", "_%#X_", 0x1234abc);
+ TEST("_c_", "_%c_", 'c');
+ TEST("_string_", "_%s_", "string");
+ TEST("_0x42_", "_%p_", ((void *)0x42));
+
+ TEST("_-1234_", "_%ld_", ((long)-1234));
+ TEST("_1234_", "_%ld_", ((long)1234));
+ TEST("_-1234_", "_%li_", ((long)-1234));
+ TEST("_1234_", "_%li_", ((long)1234));
+ TEST("_01234_", "_%#lo_", ((long)01234));
+ TEST("_1234_", "_%lu_", ((long)1234));
+ TEST("_0x1234abc_", "_%#lx_", ((long)0x1234abc));
+ TEST("_0X1234ABC_", "_%#lX_", ((long)0x1234ABC));
+
+ TEST("_-1234_", "_%lld_", ((long long)-1234));
+ TEST("_1234_", "_%lld_", ((long long)1234));
+ TEST("_-1234_", "_%lli_", ((long long)-1234));
+ TEST("_1234_", "_%lli_", ((long long)1234));
+ TEST("_01234_", "_%#llo_", ((long long)01234));
+ TEST("_1234_", "_%llu_", ((long long)1234));
+ TEST("_0x1234abc_", "_%#llx_", ((long long)0x1234abc));
+ TEST("_0X1234ABC_", "_%#llX_", ((long long)0x1234ABC));
+
+ TEST("_-1234_", "_%qd_", ((long long)-1234));
+ TEST("_1234_", "_%qd_", ((long long)1234));
+ TEST("_-1234_", "_%qi_", ((long long)-1234));
+ TEST("_1234_", "_%qi_", ((long long)1234));
+ TEST("_01234_", "_%#qo_", ((long long)01234));
+ TEST("_1234_", "_%qu_", ((long long)1234));
+ TEST("_0x1234abc_", "_%#qx_", ((long long)0x1234abc));
+ TEST("_0X1234ABC_", "_%#qX_", ((long long)0x1234ABC));
+
+ TEST("_-1234_", "_%jd_", ((intmax_t)-1234));
+ TEST("_1234_", "_%jd_", ((intmax_t)1234));
+ TEST("_-1234_", "_%ji_", ((intmax_t)-1234));
+ TEST("_1234_", "_%ji_", ((intmax_t)1234));
+ TEST("_01234_", "_%#jo_", ((intmax_t)01234));
+ TEST("_1234_", "_%ju_", ((intmax_t)1234));
+ TEST("_0x1234abc_", "_%#jx_", ((intmax_t)0x1234abc));
+ TEST("_0X1234ABC_", "_%#jX_", ((intmax_t)0x1234ABC));
+
+ TEST("_1234_", "_%td_", ((ptrdiff_t)1234));
+ TEST("_-1234_", "_%td_", ((ptrdiff_t)-1234));
+ TEST("_1234_", "_%ti_", ((ptrdiff_t)1234));
+ TEST("_-1234_", "_%ti_", ((ptrdiff_t)-1234));
+
+ TEST("_-1234_", "_%zd_", ((ssize_t)-1234));
+ TEST("_1234_", "_%zd_", ((ssize_t)1234));
+ TEST("_-1234_", "_%zi_", ((ssize_t)-1234));
+ TEST("_1234_", "_%zi_", ((ssize_t)1234));
+ TEST("_01234_", "_%#zo_", ((ssize_t)01234));
+ TEST("_1234_", "_%zu_", ((ssize_t)1234));
+ TEST("_0x1234abc_", "_%#zx_", ((ssize_t)0x1234abc));
+ TEST("_0X1234ABC_", "_%#zX_", ((ssize_t)0x1234ABC));
+#undef BUFLEN
+}
+TEST_END
+
+int
+main(void)
+{
+
+ return (test(
+ test_pow2_ceil,
+ test_malloc_strtoumax_no_endptr,
+ test_malloc_strtoumax,
+ test_malloc_snprintf_truncated,
+ test_malloc_snprintf));
+}
--
cgit v0.12