From a2bafb65aadaf63075b88786093b416231dcaaf4 Mon Sep 17 00:00:00 2001 From: schwarze <> Date: Tue, 15 Aug 2017 23:46:51 +0000 Subject: refactor in preparation for testing more functions; no functional change --- src/regress/lib/libc/locale/uselocale/Makefile | 3 +- src/regress/lib/libc/locale/uselocale/uselocale.c | 228 +++++++++++----------- 2 files changed, 117 insertions(+), 114 deletions(-) (limited to 'src') diff --git a/src/regress/lib/libc/locale/uselocale/Makefile b/src/regress/lib/libc/locale/uselocale/Makefile index 45c3b7e807..3c3f487df8 100644 --- a/src/regress/lib/libc/locale/uselocale/Makefile +++ b/src/regress/lib/libc/locale/uselocale/Makefile @@ -1,6 +1,7 @@ -# $OpenBSD: Makefile,v 1.1 2017/08/10 14:45:42 schwarze Exp $ +# $OpenBSD: Makefile,v 1.2 2017/08/15 23:46:51 schwarze Exp $ PROG = uselocale +CFLAGS += -Wno-macro-redefined LDFLAGS += -pthread run-regress-${PROG}: ${PROG} diff --git a/src/regress/lib/libc/locale/uselocale/uselocale.c b/src/regress/lib/libc/locale/uselocale/uselocale.c index a40f77397a..c33c1e21fa 100644 --- a/src/regress/lib/libc/locale/uselocale/uselocale.c +++ b/src/regress/lib/libc/locale/uselocale/uselocale.c @@ -1,7 +1,6 @@ -/* $OpenBSD: uselocale.c,v 1.1 2017/08/10 14:45:42 schwarze Exp $ */ +/* $OpenBSD: uselocale.c,v 1.2 2017/08/15 23:46:51 schwarze Exp $ */ /* * Copyright (c) 2017 Ingo Schwarze - * Copyright (c) 2015 Sebastien Marie * * Permission to use, copy, modify, and distribute this software for any * purpose with or without fee is hereby granted, provided that the above @@ -22,93 +21,96 @@ #include #include #include -#include +/* Keep in sync with /usr/src/lib/libc/locale/rune.h. */ #define _LOCALE_NONE (locale_t)0 -#define _LOCALE_C (locale_t)1 -#define _LOCALE_UTF8 (locale_t)2 -#define _LOCALE_BAD (locale_t)3 +#define _LOCALE_C (locale_t)1 +#define _LOCALE_UTF8 (locale_t)2 +#define _LOCALE_BAD (locale_t)3 -#define SWITCH_SIGNAL 1 -#define SWITCH_WAIT 2 +/* Options for switch_thread() below. */ +#define SWITCH_SIGNAL 1 /* Call pthread_cond_signal(3). */ +#define SWITCH_WAIT 2 /* Call pthread_cond_timedwait(3). */ + +/* Options for TESTFUNC(). */ +#define TOPT_ERR (1 << 0) +#define TOPT_STR (1 << 1) /* - * test helpers for __LINE__ + * Generate one test function for a specific interface. + * Fn = function name + * Ft = function return type + * FUNCPARA = function parameter list with types and names + * FUNCARGS = function argument list, names only, no types + * Af = format string to print the arguments + * Rf = format string to print the return value + * Op = options for the test function, see above + * line = source code line number in this test file + * ee = expected error number + * er = expected return value + * ar = actual return value + * errno = actual error number (global) */ -#define test_newlocale(_e, _ee, _m, _l) \ - _test_newlocale(_e, _ee, _m, _l, __LINE__) -#define test_duplocale(_e, _ee, _l) _test_duplocale(_e, _ee, _l, __LINE__) -#define test_uselocale(_e, _ee, _l) _test_uselocale(_e, _ee, _l, __LINE__) -#define test_setlocale(_e, _c, _l) _test_setlocale(_e, _c, _l, __LINE__) -#define test_MB_CUR_MAX(_e) _test_MB_CUR_MAX(_e, __LINE__) - - -static void -_test_newlocale(locale_t expected, int exp_err, - int mask, const char *locname, int line) -{ - locale_t result = newlocale(mask, locname, _LOCALE_NONE); - - if (result != expected) - errx(1, "[%d] newlocale(%d, \"%s\")=\"%d\" [expected: \"%d\"]", - line, mask, locname, (int)result, (int)expected); - if (errno != exp_err) - errx(1, "[%d] newlocale(%d, \"%s\") errno=\"%d\" [expected:" - " \"%d\"]", line, mask, locname, errno, exp_err); - errno = 0; +#define TESTFUNC(Fn, Ft, Af, Rf, Op) \ +static void \ +_test_##Fn(int line, int ee, Ft er, FUNCPARA) \ +{ \ + Ft ar; \ + errno = 0; \ + ar = Fn(FUNCARGS); \ + if (Op & TOPT_STR) { \ + if (er == (Ft)NULL) \ + er = (Ft)"NULL"; \ + if (ar == (Ft)NULL) \ + ar = (Ft)"NULL"; \ + } \ + if (Op & TOPT_STR ? strcmp((const char *)er, (const char *)ar) \ + : ar != er) \ + errx(1, "[%d] %s(" Af ")=" Rf " [exp: " Rf "]", \ + line, #Fn, FUNCARGS, ar, er); \ + if (Op & TOPT_ERR && errno != ee) \ + errx(1, "[%d] %s(" Af ") errno=%d [exp: %d]", \ + line, #Fn, FUNCARGS, errno, ee); \ } -static void -_test_duplocale(locale_t expected, int exp_err, locale_t oldloc, int line) -{ - locale_t result = duplocale(oldloc); +/* + * Test functions for all tested interfaces. + */ +#define FUNCPARA int mask, const char *locname +#define FUNCARGS mask, locname, _LOCALE_NONE +TESTFUNC(newlocale, locale_t, "%d, %s, %p", "%p", TOPT_ERR) - if (result != expected) - errx(1, "[%d] duplocale(%d)=\"%d\" [expected: \"%d\"]", - line, (int)oldloc, (int)result, (int)expected); - if (errno != exp_err) - errx(1, "[%d] duplocale(%d) errno=\"%d\" [expected:" - " \"%d\"]", line, (int)oldloc, errno, exp_err); - errno = 0; -} +#define FUNCPARA locale_t locale +#define FUNCARGS locale +TESTFUNC(duplocale, locale_t, "%p", "%p", TOPT_ERR) +TESTFUNC(uselocale, locale_t, "%p", "%p", TOPT_ERR) -static void -_test_uselocale(locale_t expected, int exp_err, locale_t newloc, int line) -{ - locale_t result = uselocale(newloc); - - if (result != expected) - errx(1, "[%d] uselocale(%d)=\"%d\" [expected: \"%d\"]", - line, (int)newloc, (int)result, (int)expected); - if (errno != exp_err) - errx(1, "[%d] uselocale(%d) errno=\"%d\" [expected:" - " \"%d\"]", line, (int)newloc, errno, exp_err); - errno = 0; -} +#define FUNCPARA int category, char *locname +#define FUNCARGS category, locname +TESTFUNC(setlocale, const char *, "%d, %s", "%s", TOPT_STR) static void -_test_setlocale(const char *expected, int category, char *locale, int line) +_test_MB_CUR_MAX(int line, int ee, size_t ar) { - const char *result = setlocale(category, locale); - - if (expected == NULL) - expected = "(null)"; - if (result == NULL) - result = "(null)"; - if (strcmp(expected, result) != 0) - errx(1, "[%d] setlocale(%d, \"%s\")=\"%s\" [expected: \"%s\"]", - line, category, locale, result, expected); - errno = 0; + if (MB_CUR_MAX != ar) + errx(1, "[%d] MB_CUR_MAX=%zd [exp: %zd]", + line, MB_CUR_MAX, ar); } -static void -_test_MB_CUR_MAX(size_t expected, int line) -{ - if (MB_CUR_MAX != expected) - errx(1, "[%d] MB_CUR_MAX=%ld [expected %ld]", - line, MB_CUR_MAX, expected); -} +/* + * Test macros: + * TEST_R(funcname, er, arguments) if you expect errno == 0. + * TEST_ER(funcname, ee, er, arguments) otherwise. + */ +#define TEST_R(Fn, ...) _test_##Fn(__LINE__, 0, __VA_ARGS__) +#define TEST_ER(Fn, ...) _test_##Fn(__LINE__, __VA_ARGS__) +/* + * SWITCH_SIGNAL wakes the other thread. + * SWITCH_WAIT goes to sleep. + * Both can be combined. + * The step argument is used for error reporting only. + */ static void switch_thread(int step, int flags) { @@ -154,67 +156,67 @@ static void * child_func(void *arg) { /* Test invalid newlocale(3) arguments. */ - test_newlocale(_LOCALE_NONE, EINVAL, LC_CTYPE_MASK, NULL); - test_MB_CUR_MAX(1); - test_newlocale(_LOCALE_NONE, EINVAL, LC_ALL_MASK + 1, "C.UTF-8"); - test_MB_CUR_MAX(1); - test_newlocale(_LOCALE_NONE, ENOENT, LC_COLLATE_MASK, "C.INV"); - test_MB_CUR_MAX(1); + TEST_ER(newlocale, EINVAL, _LOCALE_NONE, LC_CTYPE_MASK, NULL); + TEST_R(MB_CUR_MAX, 1); + TEST_ER(newlocale, EINVAL, _LOCALE_NONE, LC_ALL_MASK + 1, "C.UTF-8"); + TEST_R(MB_CUR_MAX, 1); + TEST_ER(newlocale, ENOENT, _LOCALE_NONE, LC_COLLATE_MASK, "C.INV"); + TEST_R(MB_CUR_MAX, 1); setenv("LC_TIME", "C.INV", 1); - test_newlocale(_LOCALE_NONE, ENOENT, LC_TIME_MASK, ""); + TEST_ER(newlocale, ENOENT, _LOCALE_NONE, LC_TIME_MASK, ""); unsetenv("LC_TIME"); - test_MB_CUR_MAX(1); + TEST_R(MB_CUR_MAX, 1); setenv("LC_CTYPE", "C.INV", 1); - test_newlocale(_LOCALE_NONE, ENOENT, LC_CTYPE_MASK, ""); - test_MB_CUR_MAX(1); + TEST_ER(newlocale, ENOENT, _LOCALE_NONE, LC_CTYPE_MASK, ""); + TEST_R(MB_CUR_MAX, 1); /* Test duplocale(3). */ - test_duplocale(_LOCALE_NONE, EINVAL, _LOCALE_UTF8); - test_duplocale(_LOCALE_C, 0, _LOCALE_C); - test_duplocale(_LOCALE_C, 0, LC_GLOBAL_LOCALE); + TEST_ER(duplocale, EINVAL, _LOCALE_NONE, _LOCALE_UTF8); + TEST_R(duplocale, _LOCALE_C, _LOCALE_C); + TEST_R(duplocale, _LOCALE_C, LC_GLOBAL_LOCALE); /* Test premature UTF-8 uselocale(3). */ - test_uselocale(_LOCALE_NONE, EINVAL, _LOCALE_UTF8); - test_MB_CUR_MAX(1); - test_uselocale(LC_GLOBAL_LOCALE, 0, _LOCALE_NONE); + TEST_ER(uselocale, EINVAL, _LOCALE_NONE, _LOCALE_UTF8); + TEST_R(MB_CUR_MAX, 1); + TEST_R(uselocale, LC_GLOBAL_LOCALE, _LOCALE_NONE); /* Test UTF-8 initialization. */ setenv("LC_CTYPE", "C.UTF-8", 1); - test_newlocale(_LOCALE_UTF8, 0, LC_CTYPE_MASK, ""); + TEST_R(newlocale, _LOCALE_UTF8, LC_CTYPE_MASK, ""); unsetenv("LC_CTYPE"); - test_MB_CUR_MAX(1); - test_duplocale(_LOCALE_UTF8, 0, _LOCALE_UTF8); + TEST_R(MB_CUR_MAX, 1); + TEST_R(duplocale, _LOCALE_UTF8, _LOCALE_UTF8); /* Test invalid uselocale(3) argument. */ - test_uselocale(_LOCALE_NONE, EINVAL, _LOCALE_BAD); - test_MB_CUR_MAX(1); - test_uselocale(LC_GLOBAL_LOCALE, 0, _LOCALE_NONE); + TEST_ER(uselocale, EINVAL, _LOCALE_NONE, _LOCALE_BAD); + TEST_R(MB_CUR_MAX, 1); + TEST_R(uselocale, LC_GLOBAL_LOCALE, _LOCALE_NONE); /* Test switching the thread locale. */ - test_uselocale(LC_GLOBAL_LOCALE, 0, _LOCALE_UTF8); - test_MB_CUR_MAX(4); - test_uselocale(_LOCALE_UTF8, 0, _LOCALE_NONE); + TEST_R(uselocale, LC_GLOBAL_LOCALE, _LOCALE_UTF8); + TEST_R(MB_CUR_MAX, 4); + TEST_R(uselocale, _LOCALE_UTF8, _LOCALE_NONE); /* Test non-ctype newlocale(3). */ - test_newlocale(_LOCALE_C, 0, LC_MESSAGES_MASK, "en_US.UTF-8"); + TEST_R(newlocale, _LOCALE_C, LC_MESSAGES_MASK, "en_US.UTF-8"); /* Temporarily switch to the main thread. */ switch_thread(2, SWITCH_SIGNAL | SWITCH_WAIT); /* Test displaying the global locale while a local one is set. */ - test_setlocale("C/C.UTF-8/C/C/C/C", LC_ALL, NULL); + TEST_R(setlocale, "C/C.UTF-8/C/C/C/C", LC_ALL, NULL); /* Test switching the thread locale back. */ - test_MB_CUR_MAX(4); - test_duplocale(_LOCALE_UTF8, 0, LC_GLOBAL_LOCALE); - test_uselocale(_LOCALE_UTF8, 0, _LOCALE_C); - test_MB_CUR_MAX(1); - test_uselocale(_LOCALE_C, 0, _LOCALE_NONE); + TEST_R(MB_CUR_MAX, 4); + TEST_R(duplocale, _LOCALE_UTF8, LC_GLOBAL_LOCALE); + TEST_R(uselocale, _LOCALE_UTF8, _LOCALE_C); + TEST_R(MB_CUR_MAX, 1); + TEST_R(uselocale, _LOCALE_C, _LOCALE_NONE); /* Test switching back to the global locale. */ - test_uselocale(_LOCALE_C, 0, LC_GLOBAL_LOCALE); - test_MB_CUR_MAX(4); - test_uselocale(LC_GLOBAL_LOCALE, 0, _LOCALE_NONE); + TEST_R(uselocale, _LOCALE_C, LC_GLOBAL_LOCALE); + TEST_R(MB_CUR_MAX, 4); + TEST_R(uselocale, LC_GLOBAL_LOCALE, _LOCALE_NONE); /* Hand control back to the main thread. */ switch_thread(4, SWITCH_SIGNAL); @@ -243,13 +245,13 @@ main(void) switch_thread(1, SWITCH_WAIT); /* Check that the global locale is undisturbed. */ - test_setlocale("C", LC_ALL, NULL); - test_MB_CUR_MAX(1); + TEST_R(setlocale, "C", LC_ALL, NULL); + TEST_R(MB_CUR_MAX, 1); /* Test setting the globale locale. */ - test_setlocale("C.UTF-8", LC_CTYPE, "C.UTF-8"); - test_MB_CUR_MAX(4); - test_uselocale(LC_GLOBAL_LOCALE, 0, _LOCALE_NONE); + TEST_R(setlocale, "C.UTF-8", LC_CTYPE, "C.UTF-8"); + TEST_R(MB_CUR_MAX, 4); + TEST_R(uselocale, LC_GLOBAL_LOCALE, _LOCALE_NONE); /* Let the child do some more tests, then clean up. */ switch_thread(3, SWITCH_SIGNAL); -- cgit v1.2.3-55-g6feb