Ignore:
Timestamp:
Apr 25, 2007, 9:44:55 AM (14 years ago)
Author:
Paul Smedley
Message:

Code updated to Samba 3.0.25rc2 level

File:
1 edited

Legend:

Unmodified
Added
Removed
  • trunk/samba/source/lib/replace/test/testsuite.c

    r1 r30  
    116116static int test_strlcat(void)
    117117{
    118         /* FIXME */
     118        char tmp[10];
     119        printf("test: strlcat\n");
     120        strlcpy(tmp, "", sizeof(tmp));
     121        if (strlcat(tmp, "bla", 3) != 3) {
     122                printf("failure: strlcat [\ninvalid return code\n]\n");
     123                return false;
     124        }
     125        if (strcmp(tmp, "bl") != 0) {
     126                printf("failure: strlcat [\nexpected \"bl\", got \"%s\"\n]\n",
     127                           tmp);
     128                return false;
     129        }
     130
     131        strlcpy(tmp, "da", sizeof(tmp));
     132        if (strlcat(tmp, "me", 4) != 4) {
     133                printf("failure: strlcat [\nexpected \"dam\", got \"%s\"\n]\n",
     134                           tmp);
     135                return false;
     136        }
     137
     138        printf("success: strlcat\n");
    119139        return true;
    120140}
     
    126146}
    127147
    128 static int test_innetgr(void)
    129 {
    130         /* FIXME */
    131         return true;
    132 }
    133 
    134148static int test_initgroups(void)
    135149{
     
    146160static int test_strdup(void)
    147161{
    148         /* FIXME */
     162        char *x;
     163        printf("test: strdup\n");
     164        x = strdup("bla");
     165        if (strcmp("bla", x) != 0) {
     166                printf("failure: strdup [\nfailed: expected \"bla\", got \"%s\"\n]\n",
     167                           x);
     168                return false;
     169        }
     170        free(x);
     171        printf("success: strdup\n");
    149172        return true;
    150173}       
     
    172195static int test_setenv(void)
    173196{
    174         /* FIXME */
     197#define TEST_SETENV(key, value, overwrite, result) do { \
     198        int _ret; \
     199        char *_v; \
     200        _ret = setenv(key, value, overwrite); \
     201        if (_ret != 0) { \
     202                printf("failure: setenv [\n" \
     203                        "setenv(%s, %s, %d) failed\n" \
     204                        "]\n", \
     205                        key, value, overwrite); \
     206                return false; \
     207        } \
     208        _v=getenv(key); \
     209        if (!_v) { \
     210                printf("failure: setenv [\n" \
     211                        "getenv(%s) returned NULL\n" \
     212                        "]\n", \
     213                        key); \
     214                return false; \
     215        } \
     216        if (strcmp(result, _v) != 0) { \
     217                printf("failure: setenv [\n" \
     218                        "getenv(%s): '%s' != '%s'\n" \
     219                        "]\n", \
     220                        key, result, _v); \
     221                return false; \
     222        } \
     223} while(0)
     224
     225#define TEST_UNSETENV(key) do { \
     226        char *_v; \
     227        unsetenv(key); \
     228        _v=getenv(key); \
     229        if (_v) { \
     230                printf("failure: setenv [\n" \
     231                        "getenv(%s): NULL != '%s'\n" \
     232                        "]\n", \
     233                        SETENVTEST_KEY, _v); \
     234                return false; \
     235        } \
     236} while (0)
     237
     238#define SETENVTEST_KEY "SETENVTESTKEY"
     239#define SETENVTEST_VAL "SETENVTESTVAL"
     240
     241        printf("test: setenv\n");
     242        TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"1", 0, SETENVTEST_VAL"1");
     243        TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"2", 0, SETENVTEST_VAL"1");
     244        TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"3", 1, SETENVTEST_VAL"3");
     245        TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"4", 1, SETENVTEST_VAL"4");
     246        TEST_UNSETENV(SETENVTEST_KEY);
     247        TEST_UNSETENV(SETENVTEST_KEY);
     248        TEST_SETENV(SETENVTEST_KEY, SETENVTEST_VAL"5", 0, SETENVTEST_VAL"5");
     249        TEST_UNSETENV(SETENVTEST_KEY);
     250        TEST_UNSETENV(SETENVTEST_KEY);
     251        printf("success: setenv\n");
    175252        return true;
    176253}
     
    178255static int test_strndup(void)
    179256{
    180         /* FIXME */
     257        char *x;
     258        printf("test: strndup\n");
     259        x = strndup("bla", 0);
     260        if (strcmp(x, "") != 0) {
     261                printf("failure: strndup [\ninvalid\n]\n");
     262                return false;
     263        }
     264        free(x);
     265        x = strndup("bla", 2);
     266        if (strcmp(x, "bl") != 0) {
     267                printf("failure: strndup [\ninvalid\n]\n");
     268                return false;
     269        }
     270        free(x);
     271        x = strndup("bla", 10);
     272        if (strcmp(x, "bla") != 0) {
     273                printf("failure: strndup [\ninvalid\n]\n");
     274                return false;
     275        }
     276        free(x);
     277        printf("success: strndup\n");
    181278        return true;
    182279}
     
    184281static int test_strnlen(void)
    185282{
    186         /* FIXME */
     283        printf("test: strnlen\n");
     284        if (strnlen("bla", 2) != 2) {
     285                printf("failure: strnlen [\nunexpected length\n]\n");
     286                return false;
     287        }
     288
     289        if (strnlen("some text\n", 0) != 0) {
     290                printf("failure: strnlen [\nunexpected length\n]\n");
     291                return false;
     292        }
     293
     294        if (strnlen("some text", 20) != 9) {
     295                printf("failure: strnlen [\nunexpected length\n]\n");
     296                return false;
     297        }
     298
     299        printf("success: strnlen\n");
    187300        return true;
    188301}
     
    208321static int test_asprintf(void)
    209322{
    210         /* FIXME */
     323        char *x;
     324        printf("test: asprintf\n");
     325        if (asprintf(&x, "%d", 9) != 1) {
     326                printf("failure: asprintf [\ngenerate asprintf\n]\n");
     327                return false;
     328        }
     329        if (strcmp(x, "9") != 0) {
     330                printf("failure: asprintf [\ngenerate asprintf\n]\n");
     331                return false;
     332        }
     333        if (asprintf(&x, "dat%s", "a") != 4) {
     334                printf("failure: asprintf [\ngenerate asprintf\n]\n");
     335                return false;
     336        }
     337        if (strcmp(x, "data") != 0) {
     338                printf("failure: asprintf [\ngenerate asprintf\n]\n");
     339                return false;
     340        }
     341        printf("success: asprintf\n");
    211342        return true;
    212343}
     
    214345static int test_snprintf(void)
    215346{
    216         /* FIXME */
     347        char tmp[10];
     348        printf("test: snprintf\n");
     349        if (snprintf(tmp, 3, "foo%d", 9) != 4) {
     350                printf("failure: snprintf [\nsnprintf return code failed\n]\n");
     351                return false;
     352        }
     353
     354        if (strcmp(tmp, "fo") != 0) {
     355                printf("failure: snprintf [\nsnprintf failed\n]\n");
     356                return false;
     357        }
     358
     359        printf("success: snprintf\n");
    217360        return true;
    218361}
     
    287430static int test_errno(void)
    288431{
    289         /* FIXME */
     432        printf("test: errno\n");
     433        errno = 3;
     434        if (errno != 3) {
     435                printf("failure: errno [\nerrno failed\n]\n");
     436                return false;
     437        }
     438
     439        printf("success: errno\n");
    290440        return true;
    291441}
     
    327477}
    328478
     479#define TEST_STRTO_X(type,fmt,func,str,base,res,diff,rrnoo) do {\
     480        type _v; \
     481        char _s[64]; \
     482        char *_p = NULL;\
     483        char *_ep = NULL; \
     484        strlcpy(_s, str, sizeof(_s));\
     485        if (diff >= 0) { \
     486                _ep = &_s[diff]; \
     487        } \
     488        errno = 0; \
     489        _v = func(_s, &_p, base); \
     490        if (errno != rrnoo) { \
     491                printf("failure: %s [\n" \
     492                       "\t%s\n" \
     493                       "\t%s(\"%s\",%d,%d): " fmt " (=/!)= " fmt "\n" \
     494                       "\terrno: %d != %d\n" \
     495                       "]\n", \
     496                        __STRING(func), __location__, __STRING(func), \
     497                       str, diff, base, res, _v, rrnoo, errno); \
     498                return false; \
     499        } else if (_v != res) { \
     500                printf("failure: %s [\n" \
     501                       "\t%s\n" \
     502                       "\t%s(\"%s\",%d,%d): " fmt " != " fmt "\n" \
     503                       "]\n", \
     504                       __STRING(func), __location__, __STRING(func), \
     505                       str, diff, base, res, _v); \
     506                return false; \
     507        } else if (_p != _ep) { \
     508                printf("failure: %s [\n" \
     509                       "\t%s\n" \
     510                       "\t%s(\"%s\",%d,%d): " fmt " (=/!)= " fmt "\n" \
     511                       "\tptr: %p - %p = %d != %d\n" \
     512                       "]\n", \
     513                       __STRING(func), __location__, __STRING(func), \
     514                       str, diff, base, res, _v, _ep, _p, diff - (_ep - _p), diff); \
     515                return false; \
     516        } \
     517} while (0)
     518
    329519static int test_strtoll(void)
    330520{
    331         /* FIXME */
     521        printf("test: strtoll\n");
     522
     523#define TEST_STRTOLL(str,base,res,diff,errnoo) TEST_STRTO_X(int64_t, "%lld", strtoll,str,base,res,diff,errnoo)
     524
     525        TEST_STRTOLL("15",      10,     15LL,   2, 0);
     526        TEST_STRTOLL("  15",    10,     15LL,   4, 0);
     527        TEST_STRTOLL("15",      0,      15LL,   2, 0);
     528        TEST_STRTOLL(" 15 ",    0,      15LL,   3, 0);
     529        TEST_STRTOLL("+15",     10,     15LL,   3, 0);
     530        TEST_STRTOLL("  +15",   10,     15LL,   5, 0);
     531        TEST_STRTOLL("+15",     0,      15LL,   3, 0);
     532        TEST_STRTOLL(" +15 ",   0,      15LL,   4, 0);
     533        TEST_STRTOLL("-15",     10,     -15LL,  3, 0);
     534        TEST_STRTOLL("  -15",   10,     -15LL,  5, 0);
     535        TEST_STRTOLL("-15",     0,      -15LL,  3, 0);
     536        TEST_STRTOLL(" -15 ",   0,      -15LL,  4, 0);
     537        TEST_STRTOLL("015",     10,     15LL,   3, 0);
     538        TEST_STRTOLL("  015",   10,     15LL,   5, 0);
     539        TEST_STRTOLL("015",     0,      13LL,   3, 0);
     540        TEST_STRTOLL("  015",   0,      13LL,   5, 0);
     541        TEST_STRTOLL("0x15",    10,     0LL,    1, 0);
     542        TEST_STRTOLL("  0x15",  10,     0LL,    3, 0);
     543        TEST_STRTOLL("0x15",    0,      21LL,   4, 0);
     544        TEST_STRTOLL("  0x15",  0,      21LL,   6, 0);
     545
     546        TEST_STRTOLL("10",      16,     16LL,   2, 0);
     547        TEST_STRTOLL("  10 ",   16,     16LL,   4, 0);
     548        TEST_STRTOLL("0x10",    16,     16LL,   4, 0);
     549        TEST_STRTOLL("0x10",    0,      16LL,   4, 0);
     550        TEST_STRTOLL(" 0x10 ",  0,      16LL,   5, 0);
     551        TEST_STRTOLL("+10",     16,     16LL,   3, 0);
     552        TEST_STRTOLL("  +10 ",  16,     16LL,   5, 0);
     553        TEST_STRTOLL("+0x10",   16,     16LL,   5, 0);
     554        TEST_STRTOLL("+0x10",   0,      16LL,   5, 0);
     555        TEST_STRTOLL(" +0x10 ", 0,      16LL,   6, 0);
     556        TEST_STRTOLL("-10",     16,     -16LL,  3, 0);
     557        TEST_STRTOLL("  -10 ",  16,     -16LL,  5, 0);
     558        TEST_STRTOLL("-0x10",   16,     -16LL,  5, 0);
     559        TEST_STRTOLL("-0x10",   0,      -16LL,  5, 0);
     560        TEST_STRTOLL(" -0x10 ", 0,      -16LL,  6, 0);
     561        TEST_STRTOLL("010",     16,     16LL,   3, 0);
     562        TEST_STRTOLL("  010 ",  16,     16LL,   5, 0);
     563        TEST_STRTOLL("-010",    16,     -16LL,  4, 0);
     564
     565        TEST_STRTOLL("11",      8,      9LL,    2, 0);
     566        TEST_STRTOLL("011",     8,      9LL,    3, 0);
     567        TEST_STRTOLL("011",     0,      9LL,    3, 0);
     568        TEST_STRTOLL("-11",     8,      -9LL,   3, 0);
     569        TEST_STRTOLL("-011",    8,      -9LL,   4, 0);
     570        TEST_STRTOLL("-011",    0,      -9LL,   4, 0);
     571
     572        TEST_STRTOLL("011",     8,      9LL,    3, 0);
     573        TEST_STRTOLL("011",     0,      9LL,    3, 0);
     574        TEST_STRTOLL("-11",     8,      -9LL,   3, 0);
     575        TEST_STRTOLL("-011",    8,      -9LL,   4, 0);
     576        TEST_STRTOLL("-011",    0,      -9LL,   4, 0);
     577
     578        TEST_STRTOLL("Text",    0,      0LL,    0, 0);
     579
     580        TEST_STRTOLL("9223372036854775807",     10,     9223372036854775807LL,  19, 0);
     581        TEST_STRTOLL("9223372036854775807",     0,      9223372036854775807LL,  19, 0);
     582        TEST_STRTOLL("9223372036854775808",     0,      9223372036854775807LL,  19, ERANGE);
     583        TEST_STRTOLL("9223372036854775808",     10,     9223372036854775807LL,  19, ERANGE);
     584        TEST_STRTOLL("0x7FFFFFFFFFFFFFFF",      0,      9223372036854775807LL,  18, 0);
     585        TEST_STRTOLL("0x7FFFFFFFFFFFFFFF",      16,     9223372036854775807LL,  18, 0);
     586        TEST_STRTOLL("7FFFFFFFFFFFFFFF",        16,     9223372036854775807LL,  16, 0);
     587        TEST_STRTOLL("0x8000000000000000",      0,      9223372036854775807LL,  18, ERANGE);
     588        TEST_STRTOLL("0x8000000000000000",      16,     9223372036854775807LL,  18, ERANGE);
     589        TEST_STRTOLL("80000000000000000",       16,     9223372036854775807LL,  17, ERANGE);
     590        TEST_STRTOLL("0777777777777777777777",  0,      9223372036854775807LL,  22, 0);
     591        TEST_STRTOLL("0777777777777777777777",  8,      9223372036854775807LL,  22, 0);
     592        TEST_STRTOLL("777777777777777777777",   8,      9223372036854775807LL,  21, 0);
     593        TEST_STRTOLL("01000000000000000000000", 0,      9223372036854775807LL,  23, ERANGE);
     594        TEST_STRTOLL("01000000000000000000000", 8,      9223372036854775807LL,  23, ERANGE);
     595        TEST_STRTOLL("1000000000000000000000",  8,      9223372036854775807LL,  22, ERANGE);
     596
     597        TEST_STRTOLL("-9223372036854775808",    10,     -9223372036854775807LL -1,      20, 0);
     598        TEST_STRTOLL("-9223372036854775808",    0,      -9223372036854775807LL -1,      20, 0);
     599        TEST_STRTOLL("-9223372036854775809",    0,      -9223372036854775807LL -1,      20, ERANGE);
     600        TEST_STRTOLL("-9223372036854775809",    10,     -9223372036854775807LL -1,      20, ERANGE);
     601        TEST_STRTOLL("-0x8000000000000000",     0,      -9223372036854775807LL -1,      19, 0);
     602        TEST_STRTOLL("-0x8000000000000000",     16,     -9223372036854775807LL -1,      19, 0);
     603        TEST_STRTOLL("-8000000000000000",       16,     -9223372036854775807LL -1,      17, 0);
     604        TEST_STRTOLL("-0x8000000000000001",     0,      -9223372036854775807LL -1,      19, ERANGE);
     605        TEST_STRTOLL("-0x8000000000000001",     16,     -9223372036854775807LL -1,      19, ERANGE);
     606        TEST_STRTOLL("-80000000000000001",      16,     -9223372036854775807LL -1,      18, ERANGE);
     607        TEST_STRTOLL("-01000000000000000000000",0,      -9223372036854775807LL -1,      24, 0);
     608        TEST_STRTOLL("-01000000000000000000000",8,      -9223372036854775807LL -1,      24, 0);
     609        TEST_STRTOLL("-1000000000000000000000", 8,      -9223372036854775807LL -1,      23, 0);
     610        TEST_STRTOLL("-01000000000000000000001",0,      -9223372036854775807LL -1,      24, ERANGE);
     611        TEST_STRTOLL("-01000000000000000000001",8,      -9223372036854775807LL -1,      24, ERANGE);
     612        TEST_STRTOLL("-1000000000000000000001", 8,      -9223372036854775807LL -1,      23, ERANGE);
     613
     614        printf("success: strtoll\n");
    332615        return true;
    333616}
     
    335618static int test_strtoull(void)
    336619{
    337         /* FIXME */
     620        printf("test: strtoull\n");
     621
     622#define TEST_STRTOULL(str,base,res,diff,errnoo) TEST_STRTO_X(uint64_t,"%llu",strtoull,str,base,res,diff,errnoo)
     623
     624        TEST_STRTOULL("15",     10,     15LLU,  2, 0);
     625        TEST_STRTOULL("  15",   10,     15LLU,  4, 0);
     626        TEST_STRTOULL("15",     0,      15LLU,  2, 0);
     627        TEST_STRTOULL(" 15 ",   0,      15LLU,  3, 0);
     628        TEST_STRTOULL("+15",    10,     15LLU,  3, 0);
     629        TEST_STRTOULL("  +15",  10,     15LLU,  5, 0);
     630        TEST_STRTOULL("+15",    0,      15LLU,  3, 0);
     631        TEST_STRTOULL(" +15 ",  0,      15LLU,  4, 0);
     632        TEST_STRTOULL("-15",    10,     18446744073709551601LLU,        3, 0);
     633        TEST_STRTOULL("  -15",  10,     18446744073709551601LLU,        5, 0);
     634        TEST_STRTOULL("-15",    0,      18446744073709551601LLU,        3, 0);
     635        TEST_STRTOULL(" -15 ",  0,      18446744073709551601LLU,        4, 0);
     636        TEST_STRTOULL("015",    10,     15LLU,  3, 0);
     637        TEST_STRTOULL("  015",  10,     15LLU,  5, 0);
     638        TEST_STRTOULL("015",    0,      13LLU,  3, 0);
     639        TEST_STRTOULL("  015",  0,      13LLU,  5, 0);
     640        TEST_STRTOULL("0x15",   10,     0LLU,   1, 0);
     641        TEST_STRTOULL("  0x15", 10,     0LLU,   3, 0);
     642        TEST_STRTOULL("0x15",   0,      21LLU,  4, 0);
     643        TEST_STRTOULL("  0x15", 0,      21LLU,  6, 0);
     644
     645        TEST_STRTOULL("10",     16,     16LLU,  2, 0);
     646        TEST_STRTOULL("  10 ",  16,     16LLU,  4, 0);
     647        TEST_STRTOULL("0x10",   16,     16LLU,  4, 0);
     648        TEST_STRTOULL("0x10",   0,      16LLU,  4, 0);
     649        TEST_STRTOULL(" 0x10 ", 0,      16LLU,  5, 0);
     650        TEST_STRTOULL("+10",    16,     16LLU,  3, 0);
     651        TEST_STRTOULL("  +10 ", 16,     16LLU,  5, 0);
     652        TEST_STRTOULL("+0x10",  16,     16LLU,  5, 0);
     653        TEST_STRTOULL("+0x10",  0,      16LLU,  5, 0);
     654        TEST_STRTOULL(" +0x10 ",        0,      16LLU,  6, 0);
     655        TEST_STRTOULL("-10",    16,     -16LLU, 3, 0);
     656        TEST_STRTOULL("  -10 ", 16,     -16LLU, 5, 0);
     657        TEST_STRTOULL("-0x10",  16,     -16LLU, 5, 0);
     658        TEST_STRTOULL("-0x10",  0,      -16LLU, 5, 0);
     659        TEST_STRTOULL(" -0x10 ",        0,      -16LLU, 6, 0);
     660        TEST_STRTOULL("010",    16,     16LLU,  3, 0);
     661        TEST_STRTOULL("  010 ", 16,     16LLU,  5, 0);
     662        TEST_STRTOULL("-010",   16,     -16LLU, 4, 0);
     663
     664        TEST_STRTOULL("11",     8,      9LLU,   2, 0);
     665        TEST_STRTOULL("011",    8,      9LLU,   3, 0);
     666        TEST_STRTOULL("011",    0,      9LLU,   3, 0);
     667        TEST_STRTOULL("-11",    8,      -9LLU,  3, 0);
     668        TEST_STRTOULL("-011",   8,      -9LLU,  4, 0);
     669        TEST_STRTOULL("-011",   0,      -9LLU,  4, 0);
     670
     671        TEST_STRTOULL("011",    8,      9LLU,   3, 0);
     672        TEST_STRTOULL("011",    0,      9LLU,   3, 0);
     673        TEST_STRTOULL("-11",    8,      -9LLU,  3, 0);
     674        TEST_STRTOULL("-011",   8,      -9LLU,  4, 0);
     675        TEST_STRTOULL("-011",   0,      -9LLU,  4, 0);
     676
     677        TEST_STRTOULL("Text",   0,      0LLU,   0, 0);
     678
     679        TEST_STRTOULL("9223372036854775807",    10,     9223372036854775807LLU, 19, 0);
     680        TEST_STRTOULL("9223372036854775807",    0,      9223372036854775807LLU, 19, 0);
     681        TEST_STRTOULL("9223372036854775808",    0,      9223372036854775808LLU, 19, 0);
     682        TEST_STRTOULL("9223372036854775808",    10,     9223372036854775808LLU, 19, 0);
     683        TEST_STRTOULL("0x7FFFFFFFFFFFFFFF",     0,      9223372036854775807LLU, 18, 0);
     684        TEST_STRTOULL("0x7FFFFFFFFFFFFFFF",     16,     9223372036854775807LLU, 18, 0);
     685        TEST_STRTOULL("7FFFFFFFFFFFFFFF",       16,     9223372036854775807LLU, 16, 0);
     686        TEST_STRTOULL("0x8000000000000000",     0,      9223372036854775808LLU, 18, 0);
     687        TEST_STRTOULL("0x8000000000000000",     16,     9223372036854775808LLU, 18, 0);
     688        TEST_STRTOULL("8000000000000000",       16,     9223372036854775808LLU, 16, 0);
     689        TEST_STRTOULL("0777777777777777777777", 0,      9223372036854775807LLU, 22, 0);
     690        TEST_STRTOULL("0777777777777777777777", 8,      9223372036854775807LLU, 22, 0);
     691        TEST_STRTOULL("777777777777777777777",  8,      9223372036854775807LLU, 21, 0);
     692        TEST_STRTOULL("01000000000000000000000",0,      9223372036854775808LLU, 23, 0);
     693        TEST_STRTOULL("01000000000000000000000",8,      9223372036854775808LLU, 23, 0);
     694        TEST_STRTOULL("1000000000000000000000", 8,      9223372036854775808LLU, 22, 0);
     695
     696        TEST_STRTOULL("-9223372036854775808",   10,     9223372036854775808LLU, 20, 0);
     697        TEST_STRTOULL("-9223372036854775808",   0,      9223372036854775808LLU, 20, 0);
     698        TEST_STRTOULL("-9223372036854775809",   0,      9223372036854775807LLU, 20, 0);
     699        TEST_STRTOULL("-9223372036854775809",   10,     9223372036854775807LLU, 20, 0);
     700        TEST_STRTOULL("-0x8000000000000000",    0,      9223372036854775808LLU, 19, 0);
     701        TEST_STRTOULL("-0x8000000000000000",    16,     9223372036854775808LLU, 19, 0);
     702        TEST_STRTOULL("-8000000000000000",      16,     9223372036854775808LLU, 17, 0);
     703        TEST_STRTOULL("-0x8000000000000001",    0,      9223372036854775807LLU, 19, 0);
     704        TEST_STRTOULL("-0x8000000000000001",    16,     9223372036854775807LLU, 19, 0);
     705        TEST_STRTOULL("-8000000000000001",      16,     9223372036854775807LLU, 17, 0);
     706        TEST_STRTOULL("-01000000000000000000000",0,     9223372036854775808LLU, 24, 0);
     707        TEST_STRTOULL("-01000000000000000000000",8,     9223372036854775808LLU, 24, 0);
     708        TEST_STRTOULL("-1000000000000000000000",8,      9223372036854775808LLU, 23, 0);
     709        TEST_STRTOULL("-01000000000000000000001",0,     9223372036854775807LLU, 24, 0);
     710        TEST_STRTOULL("-01000000000000000000001",8,     9223372036854775807LLU, 24, 0);
     711        TEST_STRTOULL("-1000000000000000000001",8,      9223372036854775807LLU, 23, 0);
     712
     713        TEST_STRTOULL("18446744073709551615",   0,      18446744073709551615LLU,        20, 0);
     714        TEST_STRTOULL("18446744073709551615",   10,     18446744073709551615LLU,        20, 0);
     715        TEST_STRTOULL("18446744073709551616",   0,      18446744073709551615LLU,        20, ERANGE);
     716        TEST_STRTOULL("18446744073709551616",   10,     18446744073709551615LLU,        20, ERANGE);
     717        TEST_STRTOULL("0xFFFFFFFFFFFFFFFF",     0,      18446744073709551615LLU,        18, 0);
     718        TEST_STRTOULL("0xFFFFFFFFFFFFFFFF",     16,     18446744073709551615LLU,        18, 0);
     719        TEST_STRTOULL("FFFFFFFFFFFFFFFF",       16,     18446744073709551615LLU,        16, 0);
     720        TEST_STRTOULL("0x10000000000000000",    0,      18446744073709551615LLU,        19, ERANGE);
     721        TEST_STRTOULL("0x10000000000000000",    16,     18446744073709551615LLU,        19, ERANGE);
     722        TEST_STRTOULL("10000000000000000",      16,     18446744073709551615LLU,        17, ERANGE);
     723        TEST_STRTOULL("01777777777777777777777",0,      18446744073709551615LLU,        23, 0);
     724        TEST_STRTOULL("01777777777777777777777",8,      18446744073709551615LLU,        23, 0);
     725        TEST_STRTOULL("1777777777777777777777", 8,      18446744073709551615LLU,        22, 0);
     726        TEST_STRTOULL("02000000000000000000000",0,      18446744073709551615LLU,        23, ERANGE);
     727        TEST_STRTOULL("02000000000000000000000",8,      18446744073709551615LLU,        23, ERANGE);
     728        TEST_STRTOULL("2000000000000000000000", 8,      18446744073709551615LLU,        22, ERANGE);
     729
     730        TEST_STRTOULL("-18446744073709551615",  0,      1LLU,                           21, 0);
     731        TEST_STRTOULL("-18446744073709551615",  10,     1LLU,                           21, 0);
     732        TEST_STRTOULL("-18446744073709551616",  0,      18446744073709551615LLU,        21, ERANGE);
     733        TEST_STRTOULL("-18446744073709551616",  10,     18446744073709551615LLU,        21, ERANGE);
     734        TEST_STRTOULL("-0xFFFFFFFFFFFFFFFF",    0,      1LLU,                           19, 0);
     735        TEST_STRTOULL("-0xFFFFFFFFFFFFFFFF",    16,     1LLU,                           19, 0);
     736        TEST_STRTOULL("-FFFFFFFFFFFFFFFF",      16,     1LLU,                           17, 0);
     737        TEST_STRTOULL("-0x10000000000000000",   0,      18446744073709551615LLU,        20, ERANGE);
     738        TEST_STRTOULL("-0x10000000000000000",   16,     18446744073709551615LLU,        20, ERANGE);
     739        TEST_STRTOULL("-10000000000000000",     16,     18446744073709551615LLU,        18, ERANGE);
     740        TEST_STRTOULL("-01777777777777777777777",0,     1LLU,                           24, 0);
     741        TEST_STRTOULL("-01777777777777777777777",8,     1LLU,                           24, 0);
     742        TEST_STRTOULL("-1777777777777777777777",8,      1LLU,                           23, 0);
     743        TEST_STRTOULL("-02000000000000000000000",0,     18446744073709551615LLU,        24, ERANGE);
     744        TEST_STRTOULL("-02000000000000000000000",8,     18446744073709551615LLU,        24, ERANGE);
     745        TEST_STRTOULL("-2000000000000000000000",8,      18446744073709551615LLU,        23, ERANGE);
     746
     747        printf("success: strtuoll\n");
    338748        return true;
    339749}
     
    363773static int test_FUNCTION(void)
    364774{
    365         /* FIXME: test __FUNCTION__ macro */
     775        printf("test: FUNCTION\n");
     776        if (strcmp(__FUNCTION__, "test_FUNCTION") != 0) {
     777                printf("failure: FAILURE [\nFAILURE invalid\n]\n");
     778                return false;
     779        }
     780        printf("success: FUNCTION\n");
    366781        return true;
    367782}
     
    369784static int test_MIN(void)
    370785{
    371         /* FIXME */
     786        printf("test: MIN\n");
     787        if (MIN(20, 1) != 1) {
     788                printf("failure: MIN [\nMIN invalid\n]\n");
     789                return false;
     790        }
     791        if (MIN(1, 20) != 1) {
     792                printf("failure: MIN [\nMIN invalid\n]\n");
     793                return false;
     794        }
     795        printf("success: MIN\n");
    372796        return true;
    373797}
     
    375799static int test_MAX(void)
    376800{
    377         /* FIXME */
     801        printf("test: MAX\n");
     802        if (MAX(20, 1) != 20) {
     803                printf("failure: MAX [\nMAX invalid\n]\n");
     804                return false;
     805        }
     806        if (MAX(1, 20) != 20) {
     807                printf("failure: MAX [\nMAX invalid\n]\n");
     808                return false;
     809        }
     810        printf("success: MAX\n");
    378811        return true;
    379812}
     
    417850
    418851        return true;
     852}
     853
     854extern int libreplace_test_strptime(void);
     855
     856static int test_strptime(void)
     857{
     858        return libreplace_test_strptime();
    419859}
    420860
     
    427867        ret &= test_strlcat();
    428868        ret &= test_mktime();
    429         ret &= test_innetgr();
    430869        ret &= test_initgroups();
    431870        ret &= test_memmove();
     
    460899        ret &= test_inet_ntoa();
    461900        ret &= test_strtoll();
    462         ret &= test_strtoll();
    463901        ret &= test_strtoull();
    464902        ret &= test_va_copy();
     
    467905        ret &= test_MAX();
    468906        ret &= test_socketpair();
     907        ret &= test_strptime();
    469908
    470909        return ret;
Note: See TracChangeset for help on using the changeset viewer.