diff options
| -rw-r--r-- | localedata/tests-mbwc/dat_mblen.c | 115 | ||||
| -rw-r--r-- | localedata/tests-mbwc/tst_mblen.c | 85 |
2 files changed, 200 insertions, 0 deletions
diff --git a/localedata/tests-mbwc/dat_mblen.c b/localedata/tests-mbwc/dat_mblen.c new file mode 100644 index 0000000..0868ec4 --- /dev/null +++ b/localedata/tests-mbwc/dat_mblen.c @@ -0,0 +1,115 @@ +/* + * TEST SUITE FOR MB/WC FUNCTIONS IN C LIBRARY + * + * FILE: dat_mblen.c + * + * MBLEN: int mblen (char *s, size_t n); + */ + + +/* + * NOTE: + * int mblen (char *s, size_t n); + * + * where n: a maximum number of bytes + * + * return - the number of bytes + * + * CAUTION: + * + * o When you feed a null pointer for a string (s) to the function, + * set s_flg=0 instead of putting just a 'NULL' there. + * Even if you set a 'NULL', it doens't mean a NULL pointer. + * + * o When s is a null pointer, the function checks state dependency. + * + * state-dependent encoding - return NON-zero + * state-independent encoding - return 0 + * + * If state-dependent encoding is expected, set + * + * s_flg = 0, ret_flg = 0, ret_val = +1 + * + * If state-independent encoding is expected, set + * + * s_flg = 0, ret_flg = 0, ret_val = 0 + * + * + * When you set ret_flg=1, the test program simply compares an + * actual return value with an expected value. You can check + * state-independent case (return value is 0) in that way, but + * you can not check state-dependent case. So when you check + * state- dependency in this test function: tst_mblen(), set + * ret_flg=0 always. It's a special case, and the test + * function takes care of it. + * + * s_flg=0 ret_flg=0 + * | | + * { 0, 0 }, { 0, 0, 0, x } + * | | + * not used ret_val: 0/+1 + * (expected val) */ + + +TST_MBLEN tst_mblen_loc [] = { + { + { Tmblen, TST_LOC_de }, + { + /* 01: a character. */ + { { 1, "\300", USE_MBCURMAX }, { 0, 0, 1, 1 } }, + /* 02: a character. */ + { { 1, "\309", USE_MBCURMAX }, { 0, 0, 1, 1 } }, + /* 03: a character + an invalid byte. */ + { { 1, "Z\204", USE_MBCURMAX }, { 0, 0, 1, +1 } }, + /* 04: control/invalid characters. */ + { { 1, "\177\000", USE_MBCURMAX }, { 0, 0, 1, +1 } }, + /* 05: a null string. */ + { { 1, "", USE_MBCURMAX }, { 0, 0, 1, 0 } }, + /* 06: a null pointer. */ + { { 0, "", USE_MBCURMAX }, { 0, 0, 0, 0 } }, + /* Last element. */ + { is_last: 1 } + } + }, + { + { Tmblen, TST_LOC_enUS }, + { + /* 01: a character. */ + { { 1, "A", USE_MBCURMAX }, { 0, 0, 1, 1 } }, + /* 02: a character. */ + { { 1, "a", USE_MBCURMAX }, { 0, 0, 1, 1 } }, + /* 03: a character + an invalid byte. */ + { { 1, "Z\204", USE_MBCURMAX }, { 0, 0, 1, +1 } }, + /* 04: control/invalid characters. */ + { { 1, "\177\000", USE_MBCURMAX }, { 0, 0, 1, +1 } }, + /* 05: a null string. */ + { { 1, "", USE_MBCURMAX }, { 0, 0, 1, 0 } }, + /* 06: a null pointer. */ + { { 0, "", USE_MBCURMAX }, { 0, 0, 0, 0 } }, + /* Last element. */ + { is_last: 1 } + } + }, + { + { Tmblen, TST_LOC_eucJP }, + { + /* 01: a character. */ + { { 1, "\264\301", USE_MBCURMAX }, { 0, 0, 1, 2 } }, + /* 02: a character. */ + { { 1, "\216\261", USE_MBCURMAX }, { 0, 0, 1, 2 } }, + /* 03: a character + an invalid byte. */ + { { 1, "\260\241\200", USE_MBCURMAX }, { 0, 0, 1, 2 } }, + /* 04: control/invalid characters. */ + { { 1, "\200\202", USE_MBCURMAX }, { 1, EILSEQ, 1, -1 } }, + /* 05: a null string. */ + { { 1, "", USE_MBCURMAX }, { 0, 0, 1, 0 } }, + /* 06: a null pointer. */ + { { 0, "", USE_MBCURMAX }, { 0, 0, 0, 0 } }, + /* Last element. */ + { is_last: 1 } + } + }, + { + { Tmblen, TST_LOC_end} + } +}; diff --git a/localedata/tests-mbwc/tst_mblen.c b/localedata/tests-mbwc/tst_mblen.c new file mode 100644 index 0000000..35ccf6c --- /dev/null +++ b/localedata/tests-mbwc/tst_mblen.c @@ -0,0 +1,85 @@ +/* + MBLEN: int mblen (char *s, size_t n) +*/ + +#define TST_FUNCTION mblen + +#include "tsp_common.c" +#include "dat_mblen.c" + +int +tst_mblen (FILE * fp, int debug_flg) +{ + TST_DECL_VARS (int); + char s_flg; + const char *s_in; + size_t n; + + TST_DO_TEST (mblen) + { + TST_HEAD_LOCALE (mblen, S_MBLEN); + TST_DO_REC (mblen) + { + TST_GET_ERRET (mblen); + s_flg = TST_INPUT (mblen).s_flg; + s_in = TST_INPUT (mblen).s; + n = TST_INPUT (mblen).n; + + if (s_flg == 0) + { + s_in = NULL; + } + + if (n == USE_MBCURMAX) + { + n = MB_CUR_MAX; + } + + TST_CLEAR_ERRNO; + ret = mblen (s_in, n); + TST_SAVE_ERRNO; + + TST_IF_RETURN (S_MBLEN) + { + if (s_in == NULL) + { /* state dependency */ + if (ret_exp == +1) + { /* state-dependent */ + if (ret != 0) + { + /* non-zero: state-dependent encoding */ + Result (C_SUCCESS, S_MBLEN, CASE_3, MS_PASSED); + } + else + { + err_count++; + Result (C_FAILURE, S_MBLEN, CASE_3, + "should be state-dependent encoding, " + "but the return value shows it is" + " state-independent"); + } + } + + if (ret_exp == 0) + { /* state-independent */ + if (ret == 0) + { + /* non-zero: state-dependent encoding */ + Result (C_SUCCESS, S_MBLEN, CASE_3, MS_PASSED); + } + else + { + err_count++; + Result (C_FAILURE, S_MBLEN, CASE_3, + "should be state-independent encoding, " + "but the return value shows it is" + " state-dependent"); + } + } + } + } + } + } + + return err_count; +} |