diff options
| -rw-r--r-- | localedata/ChangeLog | 21 | ||||
| -rw-r--r-- | localedata/Makefile | 12 | ||||
| -rw-r--r-- | localedata/tests-mbwc/dat_mbtowc.c | 327 | ||||
| -rw-r--r-- | localedata/tests-mbwc/dat_strcoll.c | 144 | ||||
| -rw-r--r-- | localedata/tests-mbwc/dat_strxfrm.c | 112 | ||||
| -rw-r--r-- | localedata/tests-mbwc/dat_wctomb.c | 139 | ||||
| -rw-r--r-- | localedata/tests-mbwc/tst_mbtowc.c | 126 | ||||
| -rw-r--r-- | localedata/tests-mbwc/tst_strcoll.c | 87 | ||||
| -rw-r--r-- | localedata/tests-mbwc/tst_strxfrm.c | 136 | ||||
| -rw-r--r-- | localedata/tests-mbwc/tst_wctomb.c | 99 |
10 files changed, 1201 insertions, 2 deletions
diff --git a/localedata/ChangeLog b/localedata/ChangeLog index 8f1976de26..e7bfaf4d24 100644 --- a/localedata/ChangeLog +++ b/localedata/ChangeLog @@ -1,3 +1,24 @@ +2000-06-29 Andreas Jaeger <aj@suse.de> + + * Makefile (locale_test_suite): Add new test files. + (tst_mblen-ENV): New. + (tst_mbtowc-ENV): New. + (tst_strcoll-ENV): New. + (tst_strxfrm-ENV): New. + (tst_wctomb-ENV): New. + + * tests-mbwc/tst_wctomb.c: New test file from Shoji Kuwabara + <kuwahara@cthulhu.engr.sgi.com>. + * tests-mbwc/dat_wctomb.c: Likewise. + * tests-mbwc/tst_mbtowc.c: Likewise. + * tests-mbwc/dat_mbtowc.c: Likewise. + * tests-mbwc/tst_strxfrm.c: Likewise. + * tests-mbwc/dat_strxfrm.c: Likewise. + * tests-mbwc/dat_strcoll.c: Likewise. + * tests-mbwc/tst_strcoll.c: Likewise. + * tests-mbwc/tst_mblen.c: Likewise. + * tests-mbwc/dat_mblen.c: Likewise. + 2000-06-28 Ulrich Drepper <drepper@redhat.com> * locales/mk_MK: Updated (not to new format). diff --git a/localedata/Makefile b/localedata/Makefile index 2a4356dbb3..fe6ea109c7 100644 --- a/localedata/Makefile +++ b/localedata/Makefile @@ -76,7 +76,6 @@ include ../Makeconfig ifeq (no,$(cross-compiling)) ifeq (yes,$(build-shared)) -# Disable the tests for now - first the locales have to be generated locale_test_suite := tst_iswalnum tst_iswprint tst_towctrans tst_wcsncmp \ tst_wctrans tst_iswalpha tst_iswpunct tst_wcschr \ tst_wcspbrk tst_wctype tst_iswcntrl tst_iswspace \ @@ -85,7 +84,10 @@ locale_test_suite := tst_iswalnum tst_iswprint tst_towctrans tst_wcsncmp \ tst_wcscspn tst_wcswidth tst_iswlower tst_swscanf \ tst_wcslen tst_wctob tst_iswctype tst_towlower \ tst_wcscat tst_towupper tst_wcscmp tst_wcsncat \ - tst_wcsncpy tst_wcsxfrm tst_wcwidth tst_mbrlen + tst_wcsncpy tst_wcsxfrm tst_wcwidth tst_mbrlen \ + tst_mblen tst_strcoll tst_strxfrm tst_mbtowc \ + tst_wctomb + tests = $(locale_test_suite) endif endif @@ -149,6 +151,7 @@ install-locales: $(inst_localedir)/$$locale; \ done < SUPPORTED +# The mbwc-tests need some environment setup to find the locale data files TEST_MBWC_ENV:= LOCPATH=$(common-objpfx)localedata tst_iswalnum-ENV = $(TEST_MBWC_ENV) tst_iswalpha-ENV = $(TEST_MBWC_ENV) @@ -162,7 +165,11 @@ tst_iswpunct-ENV = $(TEST_MBWC_ENV) tst_iswspace-ENV = $(TEST_MBWC_ENV) tst_iswupper-ENV = $(TEST_MBWC_ENV) tst_iswxdigit-ENV = $(TEST_MBWC_ENV) +tst_mblen-ENV = $(TEST_MBWC_ENV) tst_mbrlen-ENV = $(TEST_MBWC_ENV) +tst_mbtowc-ENV = $(TEST_MBWC_ENV) +tst_strcoll-ENV = $(TEST_MBWC_ENV) +tst_strxfrm-ENV = $(TEST_MBWC_ENV) tst_swscanf-ENV = $(TEST_MBWC_ENV) tst_towctrans-ENV = $(TEST_MBWC_ENV) tst_towlower-ENV = $(TEST_MBWC_ENV) @@ -183,6 +190,7 @@ tst_wcsstr-ENV = $(TEST_MBWC_ENV) tst_wcswidth-ENV = $(TEST_MBWC_ENV) tst_wcsxfrm-ENV = $(TEST_MBWC_ENV) tst_wctob-ENV = $(TEST_MBWC_ENV) +tst_wctomb-ENV = $(TEST_MBWC_ENV) tst_wctrans-ENV = $(TEST_MBWC_ENV) tst_wctype-ENV = $(TEST_MBWC_ENV) tst_wcwidth-ENV = $(TEST_MBWC_ENV) diff --git a/localedata/tests-mbwc/dat_mbtowc.c b/localedata/tests-mbwc/dat_mbtowc.c new file mode 100644 index 0000000000..1e3359465c --- /dev/null +++ b/localedata/tests-mbwc/dat_mbtowc.c @@ -0,0 +1,327 @@ +/* + * TEST SUITE FOR MB/WC FUNCTIONS IN C LIBRARY + * + * FILE: dat_mbtowc.c + * + * MBTOWC: int mbtowc (wchar_t *wp, char *s, size_t n); + */ + +/* NOTE: + * + * int mbtowc (wchar_t *wp, char *s, size_t n); + * + * where n: a maximum number of bytes + * return: the number of bytes + * + * + * 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 put a 'NULL', it means a null string as well as "". + * + * 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_mbtowc(), set ret_flg=0 always. It's a special case + * and the test function takes care of it. + * + * w_flg + * | s: (a null string; can't be (char *)NULL) + * | | + * input. { 1, 0, (char)NULL, MB_LEN_MAX }, + * | + * s_flg=0: makes _s_ a null pointer. + * + * expect { 0,0,0,x, 0x0000 }, + * | | + * | ret_val: 0/+1 + * ret_flg=0 + * + * + * Test data for State dependent encodings: + * + * mbtowc( NULL, NULL, 0 ); ... first data + * mbtowc( &wc, s1, n1 ); ... second data + * mbtowc( &wc, s2, n2 ); ... third data + * */ + +#include <limits.h> + +TST_MBTOWC tst_mbtowc_loc [] = { + { + { Tmbtowc, TST_LOC_de }, + { + { /*----------------- #01 -----------------*/ + { + { + { 1, 1, "üäö", 1 }, + { 1, 1, "üäö", 2 }, + { 1, 1, "üäö", MB_LEN_MAX }, + } + }, + { + { + { 0, 0, 1, 1, 0x00FC }, + { 0, 0, 1, 1, 0x00FC }, + { 0, 0, 1, 1, 0x00FC }, + } + } + }, + { /*----------------- #02 -----------------*/ + { + { + { 1, 1, "\177", MB_LEN_MAX }, + { 1, 1, "\200", MB_LEN_MAX }, + { 1, 1, "\201", MB_LEN_MAX }, + } + }, + { + { + { 0, 0, 1, 1, 0x007F }, + { 1, 0, 1, 1, 0x0080 }, + { 1, 0, 1, 1, 0x0081 }, + } + } + }, + { /*----------------- #03 -----------------*/ + { + { + { 1, 1, "", MB_LEN_MAX }, + { 0, 1, "üäö", 1 }, + { 0, 1, "üäö", 2 }, + } + }, + { + { + { 0, 0, 1, 0, 0x0000 }, + { 0, 0, 1, 1, 0x0000 }, + { 0, 0, 1, 1, 0x0000 }, + } + } + }, + { /*----------------- #04 -----------------*/ + { + { + { 0, 1, "üäö", MB_LEN_MAX }, + { 0, 1, "\177", MB_LEN_MAX }, + { 0, 1, "", MB_LEN_MAX }, + } + }, + { + { + { 0, 0, 1, 1, 0x0000 }, + { 0, 0, 1, 1, 0x0000 }, + { 0, 0, 1, 0, 0x0000 }, + } + } + }, + { /*----------------- #05 -----------------*/ + { + { + { 0, 1, "üäö", MB_LEN_MAX }, + { 0, 1, "\177", MB_LEN_MAX }, + { 0, 0, (char)NULL, MB_LEN_MAX }, + } + }, + { + { + { 0, 0, 1, 1, 0x0000 }, + { 0, 0, 1, 1, 0x0000 }, + { 0, 0, 0, 0, 0x0000 }, + } + } + }, + { is_last: 1 } + } + }, + { + { Tmbtowc, TST_LOC_enUS }, + { + { /*----------------- #01 -----------------*/ + { + { + { 1, 1, "ABC", 1 }, + { 1, 1, "ABC", 2 }, + { 1, 1, "ABC", MB_LEN_MAX }, + } + }, + { + { + { 0, 0, 1, 1, 0x0041 }, + { 0, 0, 1, 1, 0x0041 }, + { 0, 0, 1, 1, 0x0041 }, + } + } + }, + { /*----------------- #02 -----------------*/ + { + { + { 1, 1, "\177", MB_LEN_MAX }, + { 1, 1, "\200", MB_LEN_MAX }, + { 1, 1, "\201", MB_LEN_MAX }, + } + }, + { + { + { 0, 0, 1, 1, 0x007F }, + { 1, EILSEQ, 1, -1, 0x0000 }, + { 1, EILSEQ, 1, -1, 0x0000 }, + } + } + }, + { /*----------------- #03 -----------------*/ + { + { + { 1, 1, "", MB_LEN_MAX }, + { 0, 1, "ABC", 1 }, + { 0, 1, "ABC", 2 }, + } + }, + { + { + { 0, 0, 1, 0, 0x0000 }, + { 0, 0, 1, 1, 0x0000 }, + { 0, 0, 1, 1, 0x0000 }, + } + } + }, + { /*----------------- #04 -----------------*/ + { + { + { 0, 1, "ABC", MB_LEN_MAX }, + { 0, 1, "\177", MB_LEN_MAX }, + { 0, 1, "", MB_LEN_MAX }, + } + }, + { + { + { 0, 0, 1, 1, 0x0000 }, + { 0, 0, 1, 1, 0x0000 }, + { 0, 0, 1, 0, 0x0000 }, + } + } + }, + { /*----------------- #05 -----------------*/ + { + { + { 0, 1, "ABC", MB_LEN_MAX }, + { 0, 1, "\177", MB_LEN_MAX }, + { 0, 0, (char)NULL, MB_LEN_MAX }, + } + }, + { + { + { 0, 0, 1, 1, 0x0000 }, + { 0, 0, 1, 1, 0x0000 }, + { 0, 0, 0, 0, 0x0000 }, + } + } + }, + { is_last: 1 } + } + }, + { + { Tmbtowc, TST_LOC_eucJP }, + { + { /*----------------- #01 -----------------*/ + { + { + { 1, 1, "\244\242A", 1 }, + { 1, 1, "\244\242A", 2 }, + { 1, 1, "\244\242A", MB_LEN_MAX }, + } + }, + { + { + { 1, EILSEQ, 1, -1, 0x0000 }, + { 0, 0, 1, 2, 0x3042 }, + { 0, 0, 1, 2, 0x3042 }, + } + } + }, + { /*----------------- #02 -----------------*/ + { + { + { 1, 1, "\177\244\242", MB_LEN_MAX }, + { 1, 1, "\200\244\242", MB_LEN_MAX }, + { 1, 1, "\201\244\242", MB_LEN_MAX }, + } + }, + { + { + { 0, 0, 1, +1, 0x007F }, + { 1, EILSEQ, 1, -1, 0x0000 }, + { 1, EILSEQ, 1, -1, 0x0000 }, + } + } + }, + { /*----------------- #03 -----------------*/ + { + { + { 1, 1, "", MB_LEN_MAX }, + { 0, 1, "\244\242A", 1 }, + { 0, 1, "\244\242A", 2 }, + } + }, + { + { + { 0, 0, 1, 0, 0x0000 }, + { 1, EILSEQ, 1, -1, 0x0000 }, + { 0, 0, 1, 2, 0x0000 }, + } + } + }, + { /*----------------- #04 -----------------*/ + { + { + { 0, 1, "\244\242A", MB_LEN_MAX }, + { 0, 1, "\177\244\242", MB_LEN_MAX }, + { 0, 1, "", MB_LEN_MAX }, + } + }, + { + { + { 0, 0, 1, 2, 0x0000 }, + { 0, 0, 1, +1, 0x0000 }, + { 0, 0, 1, 0, 0x0000 }, + } + } + }, + { /*----------------- #05 -----------------*/ + { + { + { 0, 1, "\244\242A", MB_LEN_MAX }, + { 0, 1, "\177\244\242", MB_LEN_MAX }, + { 0, 0, (char)NULL, MB_LEN_MAX }, + } + }, + { + { + { 0, 0, 1, 2, 0x0000 }, + { 0, 0, 1, +1, 0x0000 }, + { 0, 0, 0, 0, 0x0000 }, + } + } + }, + { is_last: 1 } + } + }, + { + { Tmbtowc, TST_LOC_end } + } +}; diff --git a/localedata/tests-mbwc/dat_strcoll.c b/localedata/tests-mbwc/dat_strcoll.c new file mode 100644 index 0000000000..6d7e7e5ee2 --- /dev/null +++ b/localedata/tests-mbwc/dat_strcoll.c @@ -0,0 +1,144 @@ +/* + * TEST SUITE FOR MB/WC FUNCTIONS IN C LIBRARY + * + * FILE: dat_strcoll.c + * + * STRCOLL: int strcoll (const char *s1, const char *s2); + */ + +/* + NOTE: + + If a return value is expected to be 0, set ret_flg=1 and the + expected value = 0. If a return value is expected to be a + positive/negative value, set ret_flg=0, and set the expected value + = +1/-1. + There is inconsistensy between tst_strcoll() and tst_wcscoll()(it + has cmp_flg) for input data. I'll fix it. + + Assuming en_US to be en_US.ascii. (maybe, should be iso8859-1). + + + + ASCII CODE : A,B,C, ... , a, b, c, ... B,a:-1 a,B:+1 + DICTIONARY : A,a,B,b,C,c,.... a,B:-1 B,a:+1 */ + +TST_STRCOLL tst_strcoll_loc [] = { + { + { Tstrcoll, TST_LOC_de }, + { + { /*input.*/ { "ÄBCDEFG", "ÄBCDEFG" }, /* #1 */ + /*expect*/ { 1,0,1,0, }, + }, + { /*input.*/ { "XX Ä XX", "XX B XX" }, /* #2 */ + /*expect*/ { 1,0,0,-1, }, + }, + { /*input.*/ { "XX B XX", "XX Ä XX" }, /* #3 */ + /*expect*/ { 1,0,0,+1, }, + }, + { /*input.*/ { "B", "a" }, /* #4 */ + /*expect*/ { 1,0,0,+1, }, + }, + { /*input.*/ { "a", "B" }, /* #5 */ + /*expect*/ { 1,0,0,-1, }, + }, + { /*input.*/ { "b", "A" }, /* #6 */ + /*expect*/ { 1,0,0,+1, }, + }, + { /*input.*/ { "A", "b" }, /* #7 */ + /*expect*/ { 1,0,0,-1, }, + }, + { /*input.*/ { "ä", "B" }, /* #8 */ + /*expect*/ { 1,0,0,-1, }, + }, + { /*input.*/ { "B", "ä" }, /* #9 */ + /*expect*/ { 1,0,0,+1, }, + }, + { is_last: 1 } /* Last element. */ + } + }, + { + { Tstrcoll, TST_LOC_enUS }, + { + { /*input.*/ { "ABCDEFG", "ABCDEFG" }, /* #1 */ + /*expect*/ { 1,0,1,0, }, + }, + { /*input.*/ { "XX a XX", "XX B XX" }, /* #2 */ + /*expect*/ { 1,0,0,-1, }, + }, + { /*input.*/ { "XX B XX", "XX a XX" }, /* #3 */ + /*expect*/ { 1,0,0,+1, }, + }, + { + /* <WAIVER> */ + /*input.*/ { "B", "a" }, /* #4 */ + /*expect*/ { 1,0,0,-1, }, + }, + { + /* <WAIVER> */ + /*input.*/ { "a", "B" }, /* #5 */ + /*expect*/ { 1,0,0,+1, }, + }, + { /*input.*/ { "b", "A" }, /* #6 */ + /*expect*/ { 1,0,0,+1, }, + }, + { /*input.*/ { "A", "b" }, /* #7 */ + /*expect*/ { 1,0,0,-1, }, + }, + { + /* #8 */ /* <WAIVER> */ + /*input.*/ { "\244\242\244\244\244\246\244\250\244\252", "ABCDEFG" }, + /*expect*/ { 1,EINVAL,0,0, }, + }, + { + /* #9 */ /* <WAIVER> */ + /*input.*/ { "ABCZEFG", "\244\242\244\244\244\246\244\250\244\252" }, + /*expect*/ { 1,EINVAL,0,0, }, + }, + { is_last: 1 } /* Last element. */ + } + }, + { + { Tstrcoll, TST_LOC_eucJP }, + { + { /*input.*/ { "\244\242\244\244\244\246\244\250\244\252", + "\244\242\244\244\244\246\244\250\244\252" }, /* #1 */ + /*expect*/ { 1,0,1,0, }, + }, + { /*input.*/ { "\244\242\244\244\244\246\244\250\244\252", + "\244\242\244\244\244\363\244\250\244\252" }, /* #2 */ + /*expect*/ { 1,0,0,-1, }, + }, + { /*input.*/ { "\244\242\244\244\244\363\244\250\244\252", + "\244\242\244\244\244\246\244\250\244\252" }, /* #3 */ + /*expect*/ { 1,0,0,+1, }, + }, + { /*input.*/ { "B", "a" }, /* #4 */ + /*expect*/ { 1,0,0,-1, }, + }, + { /*input.*/ { "a", "B" }, /* #5 */ + /*expect*/ { 1,0,0,+1, }, + }, + { /*input.*/ { "b", "A" }, /* #6 */ + /*expect*/ { 1,0,0,+1, }, + }, + { /*input.*/ { "A", "b" }, /* #7 */ + /*expect*/ { 1,0,0,-1, }, + }, + { + /* <WAIVER> */ + /*input.*/ { "\200\216\217", "ABCDEFG" }, /* #8 */ + /*expect*/ { 1,EINVAL,0,0, }, + }, + { + /* <WAIVER> */ + /*input.*/ { "ABCZEFG", "\200\216\217" }, /* #9 */ + /*expect*/ { 1,EINVAL,0,0, }, + }, + { is_last: 1 } /* Last element. */ + } + }, + { + { Tstrcoll, TST_LOC_end } + } +}; diff --git a/localedata/tests-mbwc/dat_strxfrm.c b/localedata/tests-mbwc/dat_strxfrm.c new file mode 100644 index 0000000000..2737f50383 --- /dev/null +++ b/localedata/tests-mbwc/dat_strxfrm.c @@ -0,0 +1,112 @@ +/* + * TEST SUITE FOR MB/WC FUNCTIONS IN CLIBRARY + * + * FILE: dat_strxfrm.c + * + * STRXFRM: size_t strxfrm (char *s1, const char s2, size_t n); + */ + + +/* + * NOTE: + * + * Return value and errno value are checked only for 2nd string: + * org2[]; n1 and n2 don't mean bytes to be translated. + * It means a buffer size including a null character. + * Results of this test depens on results of strcoll(). + * If you got errors, check both test results. + * + * The buffer size should be enough to contain a string including a + * null char. Returns the number of bytes of the string (NOT + * including a null char). + */ + + + +TST_STRXFRM tst_strxfrm_loc [] = { + { + { Tstrxfrm, TST_LOC_de }, + { + { /*inp*/ { "öÄäü", "öÄäü", 17, 17 }, /* #01 */ + /*exp*/ { 1,0,0,0, }, + }, + { /*inp*/ { "aA", "Aa", 10, 10 }, /* #02 */ + /*exp*/ { 1,0,0,0 , }, + }, + { /*inp*/ { "Aa", "aA", 10, 10 }, /* #03 */ + /*exp*/ { 1,0,0,0, }, + }, + { /*inp*/ { "abc", "", 13, 13 }, /* #04 */ + /*exp*/ { 1,0,0,0, }, + }, + { /*inp*/ { "a", "B", 7, 7 }, /* #05 */ + /*exp*/ { 1,0,0,0, }, + }, + { /*inp*/ { "B", "a", 7, 7 }, /* #06 */ + /*exp*/ { 1,0,0,0, }, + }, + { + /* hiragana == latin1 */ + /*inp*/ { "abc", "\244\241\244\242", 13, 9 }, /* #07 */ + /*exp*/ { 1,0,0,0, }, + }, + { is_last: 1 } + } + }, + { + { Tstrxfrm, TST_LOC_enUS }, + { + { /*inp*/ { "abcd", "abcd", 17, 17 }, /* #01 */ + /*exp*/ { 1,0,0,0, }, + }, + { /*inp*/ { "aA", "Aa", 10, 10 }, /* #02 */ + /*exp*/ { 1,0,0,0 , }, + }, + { /*inp*/ { "Aa", "aA", 10, 10 }, /* #03 */ + /*exp*/ { 1,0,0,0, }, + }, + { /*inp*/ { "abc", "", 13, 13 }, /* #04 */ + /*exp*/ { 1,0,0,0, }, + }, + { /*inp*/ { "a", "B", 7, 7 }, /* #05 */ + /*exp*/ { 1,0,0,0, }, + }, + { /*inp*/ { "B", "a", 7, 7 }, /* #06 */ + /*exp*/ { 1,0,0,0, }, + }, + { + /* <WAIVER> */ + /*inp*/ { "abc", "\244\241\244\242", 13, 9 }, /* #07 */ + /*exp*/ { 1,EINVAL,0,0, }, + }, + { is_last: 1 } + } + }, + { + { Tstrxfrm, TST_LOC_eucJP }, /* ??? */ + { + { + /* #01 */ + /*inp*/ { "\244\242\244\241", "\244\241\244\242", 5, 5 }, + /*exp*/ { 1,0,0,0, }, + }, + { + /* #02 */ + /*inp*/ { "\244\241\244\242", "\244\242\244\241", 5, 5 }, + /*exp*/ { 1,0,0,0, }, + }, + { + /* #03 */ + /*inp*/ { "\244\242\216\261", "\216\261\244\242", 5, 5 }, + /*exp*/ { 1,0,0,0, }, + }, + { /*inp*/ { "AAA", "\216\217", 5, 5 }, /* #04 */ /* <WAIVER> */ + /*exp*/ { 1,EINVAL,0,0, }, + }, + { is_last: 1 } + } + }, + { + { Tstrxfrm, TST_LOC_end } + } +}; diff --git a/localedata/tests-mbwc/dat_wctomb.c b/localedata/tests-mbwc/dat_wctomb.c new file mode 100644 index 0000000000..07e1d48402 --- /dev/null +++ b/localedata/tests-mbwc/dat_wctomb.c @@ -0,0 +1,139 @@ +/* + * TEST SUITE FOR MB/WC FUNCTIONS IN C LIBRARY + * + * FILE: dat_wctomb.c + * + * WCTOMB: int wctomb (char *s, wchar_t wc) + */ + + +/* + * FUNCTION: + * + * int wctomb (char *s, wchar_t wc); + * + * return: the number of bytes + * + * NOTE: + * + * 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 put a 'NULL', it means a null string as well as "". + * + * 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_wctomb(), set + * ret_flg=0 always. It's a special case, and the test + * function takes care of it. + * + * Input Expect + * + * s_flg=0 ret_flg=0 + * | | + * { 0, 0 }, { 0, 0, 0, x, "" } + * | | + * not used ret_val: 0/+1 + * (expected val) + */ + + +TST_WCTOMB tst_wctomb_loc [] = { + { + { Twctomb, TST_LOC_de }, + { + /* #01 : normal case */ + { /*input.*/ { 1, 0x00C4 }, + /*expect*/ { 0,0,1,1, "Ä" }, + }, + /* #02 : normal case */ + { /*input.*/ { 1, 0x00DC }, + /*expect*/ { 0,0,1,1, "Ü" }, + }, + /* #03 : normal case */ + { /*input.*/ { 1, 0x0092 }, + /*expect*/ { 0,0,1,1, "\222" }, + }, + /* #04 : error case */ + { /*input.*/ { 1, 0x3041 }, + /*expect*/ { 0,0,1,-1, "" }, + }, + /* #05 : state dependency */ + { /*input.*/ { 0, 0x0000 }, + /*expect*/ { 0,0,0,0, "" }, + }, + { is_last: 1 } + } + }, + { + { Twctomb, TST_LOC_enUS }, + { + /* #01 : normal case */ + { /*input.*/ { 1, 0x0041 }, + /*expect*/ { 0,0,1,1, "A" }, + }, + /* #02 : normal case */ + { /*input.*/ { 1, 0x0042 }, + /*expect*/ { 0,0,1,1, "B" }, + }, + /* #03 : error case */ + /* <WAIVER> */ + { /*input.*/ { 1, 0x00C4 }, + /*expect*/ { 0,0,1,-1, "" }, + }, + /* #04 : error case */ + { /*input.*/ { 1, 0x30A4 }, + /*expect*/ { 0,0,1,-1, "" }, + }, + /* #05 : state dependency */ + { /*input.*/ { 0, 0x0000 }, + /*expect*/ { 0,0,0,0, "" }, + }, + { is_last: 1 } + } + }, + { + { Twctomb, TST_LOC_eucJP }, + { + /* #01 : normal case */ + { /*input.*/ { 1, 0x3042 }, + /*expect*/ { 0,0,1,2, "\244\242" }, + }, + /* #02 : normal case */ + { /*input.*/ { 1, 0x3044 }, + /*expect*/ { 0,0,1,2, "\244\244" }, + }, + /* #03 : normal case */ + { /*input.*/ { 1, 0x008E }, + /*expect*/ { 0,0,1,-1, "" }, + }, + /* #04 : jisX0212 */ + { /*input.*/ { 1, 0x00C4 }, + /*expect*/ { 0,0,1,3, "\217\252\243" }, /* jisx0210 returns 3 */ + }, + /* #05 : state dependency */ + { /*input.*/ { 0, 0x008E }, + /*expect*/ { 0,0,0,0, "" }, + }, + { is_last: 1 } + } + }, + { + { Twctomb, TST_LOC_end } + } +}; diff --git a/localedata/tests-mbwc/tst_mbtowc.c b/localedata/tests-mbwc/tst_mbtowc.c new file mode 100644 index 0000000000..c525941f60 --- /dev/null +++ b/localedata/tests-mbwc/tst_mbtowc.c @@ -0,0 +1,126 @@ +/* + MBTOWC: int mbtowc (wchar_t *wc, char *s, size_t n) +*/ + +#define TST_FUNCTION mbtowc + +#include "tsp_common.c" +#include "dat_mbtowc.c" + + +int +tst_mbtowc (FILE * fp, int debug_flg) +{ + TST_DECL_VARS (int); + char w_flg, s_flg; + const char *s_in; + size_t n; + wchar_t wc, wc_ex, *wp; + + TST_DO_TEST (mbtowc) + { + TST_HEAD_LOCALE (mbtowc, S_MBTOWC); + TST_DO_REC (mbtowc) + { + if (mbstowcs (NULL, "", 0) != 0) + { + err_count++; + Result (C_FAILURE, S_MBSTOWCS, CASE_3, + "Initialization failed - skipping this test case."); + continue; + } + + TST_DO_SEQ (MBTOWC_SEQNUM) + { + TST_GET_ERRET_SEQ (mbtowc); + w_flg = TST_INPUT_SEQ (mbtowc).w_flg; + s_flg = TST_INPUT_SEQ (mbtowc).s_flg; + n = TST_INPUT_SEQ (mbtowc).n; + + if (n == USE_MBCURMAX) + { + n = MB_CUR_MAX; + } + + if (s_flg == 0) + s_in = NULL; + else + s_in = TST_INPUT_SEQ (mbtowc).s; + + wp = (wchar_t *) ((w_flg == 0) ? NULL : &wc); + + TST_CLEAR_ERRNO; + ret = mbtowc (wp, s_in, n); + TST_SAVE_ERRNO; + + if (debug_flg) + { + fprintf (stdout, "mbtowc() [ %s : %d ] ret = %d\n", locale, + rec + 1, ret); + fprintf (stdout, " errno = %d\n", + errno_save); + } + + TST_IF_RETURN (S_MBTOWC) + { + if (s_in == NULL) + { /* state dependency */ + if (ret_exp == +1) + { /* state-dependent */ + if (ret != 0) + { + /* Non-zero: state-dependent encoding. */ + Result (C_SUCCESS, S_MBTOWC, CASE_3, MS_PASSED); + } + else + { + err_count++; + Result (C_FAILURE, S_MBTOWC, CASE_3, + "should be state-dependent encoding, " + "but a 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_MBTOWC, CASE_3, MS_PASSED); + } + else + { + err_count++; + Result (C_FAILURE, S_MBTOWC, CASE_3, + "should be state-independent encoding, " + "but a return value shows it is " + "state-dependent"); + } + } + } + } + + if ((wp == NULL || s_in == NULL || s_in[0] == 0) || ret <= 0) + { + continue; + } + + wc_ex = TST_EXPECT_SEQ (mbtowc).wc; + + if (wc_ex == wc) + { + Result (C_SUCCESS, S_MBTOWC, CASE_4, MS_PASSED); + } + else + { + err_count++; + Result (C_FAILURE, S_MBTOWC, CASE_4, + "converted wc is different from an expected wc"); + } + } + } + } + + return err_count; +} diff --git a/localedata/tests-mbwc/tst_strcoll.c b/localedata/tests-mbwc/tst_strcoll.c new file mode 100644 index 0000000000..4c5a84f697 --- /dev/null +++ b/localedata/tests-mbwc/tst_strcoll.c @@ -0,0 +1,87 @@ +/* + STRCOLL: int strcoll (const char *s1, const char *s2) +*/ + +#define TST_FUNCTION strcoll + +#include "tsp_common.c" +#include "dat_strcoll.c" + +int +tst_strcoll (FILE * fp, int debug_flg) +{ + TST_DECL_VARS (int); + const char *s1, *s2; + + TST_DO_TEST (strcoll) + { + TST_HEAD_LOCALE (strcoll, S_STRCOLL); + TST_DO_REC (strcoll) + { + TST_GET_ERRET (strcoll); + s1 = TST_INPUT (strcoll).s1; + s2 = TST_INPUT (strcoll).s2; + + TST_CLEAR_ERRNO; + ret = strcoll (s1, s2); + TST_SAVE_ERRNO; + + if (debug_flg) + { + fprintf (stdout, "strcoll() [ %s : %d ] ret = %d\n", locale, + rec + 1, ret); + fprintf (stdout, " errno = %d\n", + errno_save); + fprintf (stdout, " LC_COLLATE = %s\n", + (setlocale (LC_COLLATE, NULL)) ? setlocale (LC_COLLATE, + NULL) : ""); + } + + TST_IF_RETURN (S_STRCOLL) + { + if (ret_exp == +1) + { + if (ret > 0) + { + Result (C_SUCCESS, S_STRCOLL, CASE_3, MS_PASSED); + } + else + { + err_count++; + Result (C_FAILURE, S_STRCOLL, CASE_3, + "the return value should be greater than 0," + " but is not ..."); + } + } + else if (ret_exp == -1) + { + if (ret < 0) + { + Result (C_SUCCESS, S_STRCOLL, CASE_3, MS_PASSED); + } + else + { + err_count++; + Result (C_FAILURE, S_STRCOLL, CASE_3, + "the return value should less than 0, but not ..."); + } + } + else if (ret_exp != 0) + { + if (debug_flg) + { + fprintf (stderr, "*** Warning *** : tst_strcoll : " + "(check the test data); should set ret_flg=1" + " to check a return value"); + } + + warn_count++; + Result (C_INVALID, S_WCSCHR, CASE_3, "(check the test data); " + "should set ret_flg=1 to check a return value"); + } + } + } + } + + return err_count; +} diff --git a/localedata/tests-mbwc/tst_strxfrm.c b/localedata/tests-mbwc/tst_strxfrm.c new file mode 100644 index 0000000000..0a3789399c --- /dev/null +++ b/localedata/tests-mbwc/tst_strxfrm.c @@ -0,0 +1,136 @@ +/* + STRXFRM: size_t strxfrm (char *s1, const char *s2, size_t n) +*/ + +#define TST_FUNCTION strxfrm + +#include "tsp_common.c" +#include "dat_strxfrm.c" + + +int +tst_strxfrm (FILE * fp, int debug_flg) +{ + TST_DECL_VARS (size_t); + const char *org1, *org2; + char frm1[MBSSIZE], frm2[MBSSIZE]; + size_t n1, n2; + int ret_coll, ret_cmp; + + TST_DO_TEST (strxfrm) + { + TST_HEAD_LOCALE (strxfrm, S_STRXFRM); + TST_DO_REC (strxfrm) + { + TST_GET_ERRET (strxfrm); + org1 = TST_INPUT (strxfrm).org1; + org2 = TST_INPUT (strxfrm).org2; + n1 = TST_INPUT (strxfrm).n1; + n2 = TST_INPUT (strxfrm).n2; + + if (n1 < 0 || sizeof (frm1) < n1 || sizeof (frm2) < n2) + { + warn_count++; + Result (C_IGNORED, S_STRXFRM, CASE_9, + "input data n1 or n2 is invalid"); + continue; + } + + /* An errno and a return value are checked + only for 2nd strxfrm() call. + A result of 1st call is used for comparing + those 2 values by using strcmp(). + */ + + /*-- First call --*/ + + TST_CLEAR_ERRNO; + ret = strxfrm (frm1, org1, n1); + TST_SAVE_ERRNO; + + if (debug_flg) + { + fprintf (stdout, "strxfrm() [ %s : %d ] ( 1st call )\n", locale, + rec + 1); + fprintf (stdout, " : err = %d | %s\n", errno_save, + strerror (errno)); + fprintf (stdout, " : ret = %u\n", ret); + fprintf (stdout, " : org = %s\n", org1); + } + + if (ret >= n1 || errno != 0) + { + warn_count++; + Result (C_INVALID, S_STRXFRM, CASE_8, + "got an error in fist strxfrm() call"); + continue; + } + + /*-- Second call --*/ + + TST_CLEAR_ERRNO; + ret = strxfrm (((n2 == 0) ? NULL : frm2), org2, n2); + TST_SAVE_ERRNO; + + if (debug_flg) + { + fprintf (stderr, " ..............( 2nd call )\n"); + fprintf (stdout, " : err = %d | %s\n", errno, + strerror (errno)); + fprintf (stdout, " : ret = %u\n", ret); + fprintf (stdout, " : org = %s\n", org2); + } + + TST_IF_RETURN (S_STRXFRM) + { + }; + + if (n2 == 0 || ret >= n2 || errno != 0) + { +#if 0 + warn_count++; + Result (C_IGNORED, S_STRXFRM, CASE_7, "did not get a result"); +#endif + continue; + } + + /*-- strcoll & strcmp --*/ + + TST_CLEAR_ERRNO; + /* Depends on strcoll() ... not good though ... */ + ret_coll = strcoll (org1, org2); + + if (errno != 0) + { + /* bug * bug may get correct results ... */ + warn_count++; + Result (C_INVALID, S_STRXFRM, CASE_6, + "got an error in strcoll() call"); + continue; + } + + ret_cmp = strcmp (frm1, frm2); + + if ((ret_coll == 0 && ret_cmp == 0) + || (ret_coll < 0 && ret_cmp < 0) || (ret_coll > 0 && ret_cmp > 0)) + { + Result (C_SUCCESS, S_STRXFRM, CASE_3, + MS_PASSED "(depends on strcoll & strcmp)"); + } + else + { + err_count++; + Result (C_FAILURE, S_STRXFRM, CASE_3, + "results from strcoll & strcmp() do not match"); + } + + if (debug_flg) + { + fprintf (stdout, ".......... strcoll = %d <-> %d = strcmp\n", + ret_coll, ret_cmp); + } + } + } + + return err_count; +} diff --git a/localedata/tests-mbwc/tst_wctomb.c b/localedata/tests-mbwc/tst_wctomb.c new file mode 100644 index 0000000000..aea89fed8b --- /dev/null +++ b/localedata/tests-mbwc/tst_wctomb.c @@ -0,0 +1,99 @@ +/* + WCTOMB: int wctomb (char *s, wchar_t wc) +*/ + +#define TST_FUNCTION wctomb + +#include "tsp_common.c" +#include "dat_wctomb.c" + +int +tst_wctomb (FILE * fp, int debug_flg) +{ + TST_DECL_VARS (int); + wchar_t wc; + char s[MBSSIZE], *s_in, *s_ex; + int err, i; + + TST_DO_TEST (wctomb) + { + TST_HEAD_LOCALE (wctomb, S_WCTOMB); + TST_DO_REC (wctomb) + { + TST_GET_ERRET (wctomb); + wc = TST_INPUT (wctomb).wc; + s_in = ((TST_INPUT (wctomb).s_flg) == 0) ? (char *) NULL : s; + ret = wctomb (s_in, wc); + + if (debug_flg) + { + fprintf (stdout, "wctomb() [ %s : %d ] ret = %d\n", locale, + rec + 1, ret); + } + + TST_IF_RETURN (S_WCTOMB) + { + if (s_in == NULL) /* state dependency */ + { + if (ret_exp == +1) /* state-dependent */ + { + if (ret != 0) + { + /* Non-zero means state-dependent encoding. */ + Result (C_SUCCESS, S_WCTOMB, CASE_3, MS_PASSED); + } + else + { + err_count++; + Result (C_FAILURE, S_WCTOMB, CASE_3, + "should be state-dependent encoding, " + "but a return value shows it is " + "state-independent"); + } + } + + if (ret_exp == 0) /* state-independent */ + { + if (ret == 0) + { + /* Non-zero means state-dependent encoding. */ + Result (C_SUCCESS, S_WCTOMB, CASE_3, MS_PASSED); + } + else + { + err_count++; + Result (C_FAILURE, S_WCTOMB, CASE_3, + "should be state-independent encoding, " + "but a return value shows it is state-dependent"); + } + } + } + } + + s_ex = TST_EXPECT (wctomb).s; + + if (s_in) + { + for (i = 0, err = 0; *(s_ex + i) != 0 && i < MBSSIZE; i++) + { + if (s_in[i] != s_ex[i]) + { + err++; + err_count++; + Result (C_FAILURE, S_WCTOMB, CASE_4, + "copied string is different from an" + " expected string"); + break; + } + } + + if (!err) + { + Result (C_SUCCESS, S_WCTOMB, CASE_4, MS_PASSED); + } + } + } + } + + return err_count; +} |