r22280: merge from samba4:

add a lot more detailed strtoll() and strtoull() tests

metze
(This used to be commit 737b445007109e3005e4c5fb278b56f00b8c157d)

diff --git a/source3/lib/replace/test/testsuite.c b/source3/lib/replace/test/testsuite.c
index 025e5256f933f93f79f579db8219c3dd12b2d126..2d068c559f3f3bb5a96d231a59f63249eb4844c8 100644 (file)
--- a/source3/lib/replace/test/testsuite.c
+++ b/source3/lib/replace/test/testsuite.c
@@ -476,38 +476,140 @@ static int test_inet_ntoa(void)
        return true;
 }
 
+#define TEST_STRTO_X(type,fmt,func,str,base,res,diff,rrnoo) do {\
+       type _v; \
+       char _s[64]; \
+       char *_p = NULL;\
+       char *_ep = NULL; \
+       strlcpy(_s, str, sizeof(_s));\
+       if (diff >= 0) { \
+               _ep = &_s[diff]; \
+       } \
+       errno = 0; \
+       _v = func(_s, &_p, base); \
+       if (errno != rrnoo) { \
+               printf("failure: %s [\n" \
+                      "\t%s\n" \
+                      "\t%s(\"%s\",%d,%d): " fmt " (=/!)= " fmt "\n" \
+                      "\terrno: %d != %d\n" \
+                      "]\n", \
+                       __STRING(func), __location__, __STRING(func), \
+                      str, diff, base, res, _v, rrnoo, errno); \
+               return false; \
+       } else if (_v != res) { \
+               printf("failure: %s [\n" \
+                      "\t%s\n" \
+                      "\t%s(\"%s\",%d,%d): " fmt " != " fmt "\n" \
+                      "]\n", \
+                      __STRING(func), __location__, __STRING(func), \
+                      str, diff, base, res, _v); \
+               return false; \
+       } else if (_p != _ep) { \
+               printf("failure: %s [\n" \
+                      "\t%s\n" \
+                      "\t%s(\"%s\",%d,%d): " fmt " (=/!)= " fmt "\n" \
+                      "\tptr: %p - %p = %d != %d\n" \
+                      "]\n", \
+                      __STRING(func), __location__, __STRING(func), \
+                      str, diff, base, res, _v, _ep, _p, diff - (_ep - _p), diff); \
+               return false; \
+       } \
+} while (0)
+
 static int test_strtoll(void)
 {
-       int64_t v;
-
        printf("test: strtoll\n");
 
-       v = strtoll("15", NULL, 10);
-       if (v != 15) {
-               printf("failure: strtoll [\n"
-                      "strtoll failed: %lld != 15\n"
-                      "]\n",
-                      v);
-               return false;
-       }
-
-       v = strtoll("10", NULL, 16);
-       if (v != 16) {
-               printf("failure: strtoll [\n"
-                      "strtoll hex failed: %lld != 16\n"
-                      "]\n",
-                      v);
-               return false;
-       }
-
-       v = strtoll("11", NULL, 2);
-       if (v != 3) {
-               printf("failure: strtoll [\n"
-                      "strtoll binary failed: %lld != 3\n"
-                      "]\n",
-                      v);
-               return false;
-       }
+#define TEST_STRTOLL(str,base,res,diff,errnoo) TEST_STRTO_X(int64_t, "%lld", strtoll,str,base,res,diff,errnoo)
+
+       TEST_STRTOLL("15",      10,     15LL,   2, 0);
+       TEST_STRTOLL("  15",    10,     15LL,   4, 0);
+       TEST_STRTOLL("15",      0,      15LL,   2, 0);
+       TEST_STRTOLL(" 15 ",    0,      15LL,   3, 0);
+       TEST_STRTOLL("+15",     10,     15LL,   3, 0);
+       TEST_STRTOLL("  +15",   10,     15LL,   5, 0);
+       TEST_STRTOLL("+15",     0,      15LL,   3, 0);
+       TEST_STRTOLL(" +15 ",   0,      15LL,   4, 0);
+       TEST_STRTOLL("-15",     10,     -15LL,  3, 0);
+       TEST_STRTOLL("  -15",   10,     -15LL,  5, 0);
+       TEST_STRTOLL("-15",     0,      -15LL,  3, 0);
+       TEST_STRTOLL(" -15 ",   0,      -15LL,  4, 0);
+       TEST_STRTOLL("015",     10,     15LL,   3, 0);
+       TEST_STRTOLL("  015",   10,     15LL,   5, 0);
+       TEST_STRTOLL("015",     0,      13LL,   3, 0);
+       TEST_STRTOLL("  015",   0,      13LL,   5, 0);
+       TEST_STRTOLL("0x15",    10,     0LL,    1, 0);
+       TEST_STRTOLL("  0x15",  10,     0LL,    3, 0);
+       TEST_STRTOLL("0x15",    0,      21LL,   4, 0);
+       TEST_STRTOLL("  0x15",  0,      21LL,   6, 0);
+
+       TEST_STRTOLL("10",      16,     16LL,   2, 0);
+       TEST_STRTOLL("  10 ",   16,     16LL,   4, 0);
+       TEST_STRTOLL("0x10",    16,     16LL,   4, 0);
+       TEST_STRTOLL("0x10",    0,      16LL,   4, 0);
+       TEST_STRTOLL(" 0x10 ",  0,      16LL,   5, 0);
+       TEST_STRTOLL("+10",     16,     16LL,   3, 0);
+       TEST_STRTOLL("  +10 ",  16,     16LL,   5, 0);
+       TEST_STRTOLL("+0x10",   16,     16LL,   5, 0);
+       TEST_STRTOLL("+0x10",   0,      16LL,   5, 0);
+       TEST_STRTOLL(" +0x10 ", 0,      16LL,   6, 0);
+       TEST_STRTOLL("-10",     16,     -16LL,  3, 0);
+       TEST_STRTOLL("  -10 ",  16,     -16LL,  5, 0);
+       TEST_STRTOLL("-0x10",   16,     -16LL,  5, 0);
+       TEST_STRTOLL("-0x10",   0,      -16LL,  5, 0);
+       TEST_STRTOLL(" -0x10 ", 0,      -16LL,  6, 0);
+       TEST_STRTOLL("010",     16,     16LL,   3, 0);
+       TEST_STRTOLL("  010 ",  16,     16LL,   5, 0);
+       TEST_STRTOLL("-010",    16,     -16LL,  4, 0);
+
+       TEST_STRTOLL("11",      8,      9LL,    2, 0);
+       TEST_STRTOLL("011",     8,      9LL,    3, 0);
+       TEST_STRTOLL("011",     0,      9LL,    3, 0);
+       TEST_STRTOLL("-11",     8,      -9LL,   3, 0);
+       TEST_STRTOLL("-011",    8,      -9LL,   4, 0);
+       TEST_STRTOLL("-011",    0,      -9LL,   4, 0);
+
+       TEST_STRTOLL("011",     8,      9LL,    3, 0);
+       TEST_STRTOLL("011",     0,      9LL,    3, 0);
+       TEST_STRTOLL("-11",     8,      -9LL,   3, 0);
+       TEST_STRTOLL("-011",    8,      -9LL,   4, 0);
+       TEST_STRTOLL("-011",    0,      -9LL,   4, 0);
+
+       TEST_STRTOLL("Text",    0,      0LL,    0, 0);
+
+       TEST_STRTOLL("9223372036854775807",     10,     9223372036854775807LL,  19, 0);
+       TEST_STRTOLL("9223372036854775807",     0,      9223372036854775807LL,  19, 0);
+       TEST_STRTOLL("9223372036854775808",     0,      9223372036854775807LL,  19, ERANGE);
+       TEST_STRTOLL("9223372036854775808",     10,     9223372036854775807LL,  19, ERANGE);
+       TEST_STRTOLL("0x7FFFFFFFFFFFFFFF",      0,      9223372036854775807LL,  18, 0);
+       TEST_STRTOLL("0x7FFFFFFFFFFFFFFF",      16,     9223372036854775807LL,  18, 0);
+       TEST_STRTOLL("7FFFFFFFFFFFFFFF",        16,     9223372036854775807LL,  16, 0);
+       TEST_STRTOLL("0x8000000000000000",      0,      9223372036854775807LL,  18, ERANGE);
+       TEST_STRTOLL("0x8000000000000000",      16,     9223372036854775807LL,  18, ERANGE);
+       TEST_STRTOLL("80000000000000000",       16,     9223372036854775807LL,  17, ERANGE);
+       TEST_STRTOLL("0777777777777777777777",  0,      9223372036854775807LL,  22, 0);
+       TEST_STRTOLL("0777777777777777777777",  8,      9223372036854775807LL,  22, 0);
+       TEST_STRTOLL("777777777777777777777",   8,      9223372036854775807LL,  21, 0);
+       TEST_STRTOLL("01000000000000000000000", 0,      9223372036854775807LL,  23, ERANGE);
+       TEST_STRTOLL("01000000000000000000000", 8,      9223372036854775807LL,  23, ERANGE);
+       TEST_STRTOLL("1000000000000000000000",  8,      9223372036854775807LL,  22, ERANGE);
+
+       TEST_STRTOLL("-9223372036854775808",    10,     -9223372036854775807LL -1,      20, 0);
+       TEST_STRTOLL("-9223372036854775808",    0,      -9223372036854775807LL -1,      20, 0);
+       TEST_STRTOLL("-9223372036854775809",    0,      -9223372036854775807LL -1,      20, ERANGE);
+       TEST_STRTOLL("-9223372036854775809",    10,     -9223372036854775807LL -1,      20, ERANGE);
+       TEST_STRTOLL("-0x8000000000000000",     0,      -9223372036854775807LL -1,      19, 0);
+       TEST_STRTOLL("-0x8000000000000000",     16,     -9223372036854775807LL -1,      19, 0);
+       TEST_STRTOLL("-8000000000000000",       16,     -9223372036854775807LL -1,      17, 0);
+       TEST_STRTOLL("-0x8000000000000001",     0,      -9223372036854775807LL -1,      19, ERANGE);
+       TEST_STRTOLL("-0x8000000000000001",     16,     -9223372036854775807LL -1,      19, ERANGE);
+       TEST_STRTOLL("-80000000000000001",      16,     -9223372036854775807LL -1,      18, ERANGE);
+       TEST_STRTOLL("-01000000000000000000000",0,      -9223372036854775807LL -1,      24, 0);
+       TEST_STRTOLL("-01000000000000000000000",8,      -9223372036854775807LL -1,      24, 0);
+       TEST_STRTOLL("-1000000000000000000000", 8,      -9223372036854775807LL -1,      23, 0);
+       TEST_STRTOLL("-01000000000000000000001",0,      -9223372036854775807LL -1,      24, ERANGE);
+       TEST_STRTOLL("-01000000000000000000001",8,      -9223372036854775807LL -1,      24, ERANGE);
+       TEST_STRTOLL("-1000000000000000000001", 8,      -9223372036854775807LL -1,      23, ERANGE);
 
        printf("success: strtoll\n");
        return true;
@@ -515,36 +617,132 @@ static int test_strtoll(void)
 
 static int test_strtoull(void)
 {
-       uint64_t v;
-
        printf("test: strtoull\n");
 
-       v = strtoull("15", NULL, 10);
-       if (v != 15) {
-               printf("failure: strtoull [\n"
-                      "strtoull failed: %llu != 15\n"
-                      "]\n",
-                      v);
-               return false;
-       }
-
-       v = strtoull("10", NULL, 16);
-       if (v != 16) {
-               printf("failure: strtoull [\n"
-                      "strtoull hex failed: %llu != 16\n"
-                      "]\n",
-                      v);
-               return false;
-       }
-
-       v = strtoull("11", NULL, 2);
-       if (v != 3) {
-               printf("failure: strtoull [\n"
-                      "strtoull binary failed: %llu != 3\n"
-                      "]\n",
-                      v);
-               return false;
-       }
+#define TEST_STRTOULL(str,base,res,diff,errnoo) TEST_STRTO_X(uint64_t,"%llu",strtoull,str,base,res,diff,errnoo)
+
+       TEST_STRTOULL("15",     10,     15LLU,  2, 0);
+       TEST_STRTOULL("  15",   10,     15LLU,  4, 0);
+       TEST_STRTOULL("15",     0,      15LLU,  2, 0);
+       TEST_STRTOULL(" 15 ",   0,      15LLU,  3, 0);
+       TEST_STRTOULL("+15",    10,     15LLU,  3, 0);
+       TEST_STRTOULL("  +15",  10,     15LLU,  5, 0);
+       TEST_STRTOULL("+15",    0,      15LLU,  3, 0);
+       TEST_STRTOULL(" +15 ",  0,      15LLU,  4, 0);
+       TEST_STRTOULL("-15",    10,     18446744073709551601LLU,        3, 0);
+       TEST_STRTOULL("  -15",  10,     18446744073709551601LLU,        5, 0);
+       TEST_STRTOULL("-15",    0,      18446744073709551601LLU,        3, 0);
+       TEST_STRTOULL(" -15 ",  0,      18446744073709551601LLU,        4, 0);
+       TEST_STRTOULL("015",    10,     15LLU,  3, 0);
+       TEST_STRTOULL("  015",  10,     15LLU,  5, 0);
+       TEST_STRTOULL("015",    0,      13LLU,  3, 0);
+       TEST_STRTOULL("  015",  0,      13LLU,  5, 0);
+       TEST_STRTOULL("0x15",   10,     0LLU,   1, 0);
+       TEST_STRTOULL("  0x15", 10,     0LLU,   3, 0);
+       TEST_STRTOULL("0x15",   0,      21LLU,  4, 0);
+       TEST_STRTOULL("  0x15", 0,      21LLU,  6, 0);
+
+       TEST_STRTOULL("10",     16,     16LLU,  2, 0);
+       TEST_STRTOULL("  10 ",  16,     16LLU,  4, 0);
+       TEST_STRTOULL("0x10",   16,     16LLU,  4, 0);
+       TEST_STRTOULL("0x10",   0,      16LLU,  4, 0);
+       TEST_STRTOULL(" 0x10 ", 0,      16LLU,  5, 0);
+       TEST_STRTOULL("+10",    16,     16LLU,  3, 0);
+       TEST_STRTOULL("  +10 ", 16,     16LLU,  5, 0);
+       TEST_STRTOULL("+0x10",  16,     16LLU,  5, 0);
+       TEST_STRTOULL("+0x10",  0,      16LLU,  5, 0);
+       TEST_STRTOULL(" +0x10 ",        0,      16LLU,  6, 0);
+       TEST_STRTOULL("-10",    16,     -16LLU, 3, 0);
+       TEST_STRTOULL("  -10 ", 16,     -16LLU, 5, 0);
+       TEST_STRTOULL("-0x10",  16,     -16LLU, 5, 0);
+       TEST_STRTOULL("-0x10",  0,      -16LLU, 5, 0);
+       TEST_STRTOULL(" -0x10 ",        0,      -16LLU, 6, 0);
+       TEST_STRTOULL("010",    16,     16LLU,  3, 0);
+       TEST_STRTOULL("  010 ", 16,     16LLU,  5, 0);
+       TEST_STRTOULL("-010",   16,     -16LLU, 4, 0);
+
+       TEST_STRTOULL("11",     8,      9LLU,   2, 0);
+       TEST_STRTOULL("011",    8,      9LLU,   3, 0);
+       TEST_STRTOULL("011",    0,      9LLU,   3, 0);
+       TEST_STRTOULL("-11",    8,      -9LLU,  3, 0);
+       TEST_STRTOULL("-011",   8,      -9LLU,  4, 0);
+       TEST_STRTOULL("-011",   0,      -9LLU,  4, 0);
+
+       TEST_STRTOULL("011",    8,      9LLU,   3, 0);
+       TEST_STRTOULL("011",    0,      9LLU,   3, 0);
+       TEST_STRTOULL("-11",    8,      -9LLU,  3, 0);
+       TEST_STRTOULL("-011",   8,      -9LLU,  4, 0);
+       TEST_STRTOULL("-011",   0,      -9LLU,  4, 0);
+
+       TEST_STRTOULL("Text",   0,      0LLU,   0, 0);
+
+       TEST_STRTOULL("9223372036854775807",    10,     9223372036854775807LLU, 19, 0);
+       TEST_STRTOULL("9223372036854775807",    0,      9223372036854775807LLU, 19, 0);
+       TEST_STRTOULL("9223372036854775808",    0,      9223372036854775808LLU, 19, 0);
+       TEST_STRTOULL("9223372036854775808",    10,     9223372036854775808LLU, 19, 0);
+       TEST_STRTOULL("0x7FFFFFFFFFFFFFFF",     0,      9223372036854775807LLU, 18, 0);
+       TEST_STRTOULL("0x7FFFFFFFFFFFFFFF",     16,     9223372036854775807LLU, 18, 0);
+       TEST_STRTOULL("7FFFFFFFFFFFFFFF",       16,     9223372036854775807LLU, 16, 0);
+       TEST_STRTOULL("0x8000000000000000",     0,      9223372036854775808LLU, 18, 0);
+       TEST_STRTOULL("0x8000000000000000",     16,     9223372036854775808LLU, 18, 0);
+       TEST_STRTOULL("8000000000000000",       16,     9223372036854775808LLU, 16, 0);
+       TEST_STRTOULL("0777777777777777777777", 0,      9223372036854775807LLU, 22, 0);
+       TEST_STRTOULL("0777777777777777777777", 8,      9223372036854775807LLU, 22, 0);
+       TEST_STRTOULL("777777777777777777777",  8,      9223372036854775807LLU, 21, 0);
+       TEST_STRTOULL("01000000000000000000000",0,      9223372036854775808LLU, 23, 0);
+       TEST_STRTOULL("01000000000000000000000",8,      9223372036854775808LLU, 23, 0);
+       TEST_STRTOULL("1000000000000000000000", 8,      9223372036854775808LLU, 22, 0);
+
+       TEST_STRTOULL("-9223372036854775808",   10,     9223372036854775808LLU, 20, 0);
+       TEST_STRTOULL("-9223372036854775808",   0,      9223372036854775808LLU, 20, 0);
+       TEST_STRTOULL("-9223372036854775809",   0,      9223372036854775807LLU, 20, 0);
+       TEST_STRTOULL("-9223372036854775809",   10,     9223372036854775807LLU, 20, 0);
+       TEST_STRTOULL("-0x8000000000000000",    0,      9223372036854775808LLU, 19, 0);
+       TEST_STRTOULL("-0x8000000000000000",    16,     9223372036854775808LLU, 19, 0);
+       TEST_STRTOULL("-8000000000000000",      16,     9223372036854775808LLU, 17, 0);
+       TEST_STRTOULL("-0x8000000000000001",    0,      9223372036854775807LLU, 19, 0);
+       TEST_STRTOULL("-0x8000000000000001",    16,     9223372036854775807LLU, 19, 0);
+       TEST_STRTOULL("-8000000000000001",      16,     9223372036854775807LLU, 17, 0);
+       TEST_STRTOULL("-01000000000000000000000",0,     9223372036854775808LLU, 24, 0);
+       TEST_STRTOULL("-01000000000000000000000",8,     9223372036854775808LLU, 24, 0);
+       TEST_STRTOULL("-1000000000000000000000",8,      9223372036854775808LLU, 23, 0);
+       TEST_STRTOULL("-01000000000000000000001",0,     9223372036854775807LLU, 24, 0);
+       TEST_STRTOULL("-01000000000000000000001",8,     9223372036854775807LLU, 24, 0);
+       TEST_STRTOULL("-1000000000000000000001",8,      9223372036854775807LLU, 23, 0);
+
+       TEST_STRTOULL("18446744073709551615",   0,      18446744073709551615LLU,        20, 0);
+       TEST_STRTOULL("18446744073709551615",   10,     18446744073709551615LLU,        20, 0);
+       TEST_STRTOULL("18446744073709551616",   0,      18446744073709551615LLU,        20, ERANGE);
+       TEST_STRTOULL("18446744073709551616",   10,     18446744073709551615LLU,        20, ERANGE);
+       TEST_STRTOULL("0xFFFFFFFFFFFFFFFF",     0,      18446744073709551615LLU,        18, 0);
+       TEST_STRTOULL("0xFFFFFFFFFFFFFFFF",     16,     18446744073709551615LLU,        18, 0);
+       TEST_STRTOULL("FFFFFFFFFFFFFFFF",       16,     18446744073709551615LLU,        16, 0);
+       TEST_STRTOULL("0x10000000000000000",    0,      18446744073709551615LLU,        19, ERANGE);
+       TEST_STRTOULL("0x10000000000000000",    16,     18446744073709551615LLU,        19, ERANGE);
+       TEST_STRTOULL("10000000000000000",      16,     18446744073709551615LLU,        17, ERANGE);
+       TEST_STRTOULL("01777777777777777777777",0,      18446744073709551615LLU,        23, 0);
+       TEST_STRTOULL("01777777777777777777777",8,      18446744073709551615LLU,        23, 0);
+       TEST_STRTOULL("1777777777777777777777", 8,      18446744073709551615LLU,        22, 0);
+       TEST_STRTOULL("02000000000000000000000",0,      18446744073709551615LLU,        23, ERANGE);
+       TEST_STRTOULL("02000000000000000000000",8,      18446744073709551615LLU,        23, ERANGE);
+       TEST_STRTOULL("2000000000000000000000", 8,      18446744073709551615LLU,        22, ERANGE);
+
+       TEST_STRTOULL("-18446744073709551615",  0,      1LLU,                           21, 0);
+       TEST_STRTOULL("-18446744073709551615",  10,     1LLU,                           21, 0);
+       TEST_STRTOULL("-18446744073709551616",  0,      18446744073709551615LLU,        21, ERANGE);
+       TEST_STRTOULL("-18446744073709551616",  10,     18446744073709551615LLU,        21, ERANGE);
+       TEST_STRTOULL("-0xFFFFFFFFFFFFFFFF",    0,      1LLU,                           19, 0);
+       TEST_STRTOULL("-0xFFFFFFFFFFFFFFFF",    16,     1LLU,                           19, 0);
+       TEST_STRTOULL("-FFFFFFFFFFFFFFFF",      16,     1LLU,                           17, 0);
+       TEST_STRTOULL("-0x10000000000000000",   0,      18446744073709551615LLU,        20, ERANGE);
+       TEST_STRTOULL("-0x10000000000000000",   16,     18446744073709551615LLU,        20, ERANGE);
+       TEST_STRTOULL("-10000000000000000",     16,     18446744073709551615LLU,        18, ERANGE);
+       TEST_STRTOULL("-01777777777777777777777",0,     1LLU,                           24, 0);
+       TEST_STRTOULL("-01777777777777777777777",8,     1LLU,                           24, 0);
+       TEST_STRTOULL("-1777777777777777777777",8,      1LLU,                           23, 0);
+       TEST_STRTOULL("-02000000000000000000000",0,     18446744073709551615LLU,        24, ERANGE);
+       TEST_STRTOULL("-02000000000000000000000",8,     18446744073709551615LLU,        24, ERANGE);
+       TEST_STRTOULL("-2000000000000000000000",8,      18446744073709551615LLU,        23, ERANGE);
 
        printf("success: strtuoll\n");
        return true;