U00A0 is now print.
[kopensolaris-gnu/glibc.git] / localedata / tests-mbwc / tst_funcs.h
1 /*
2  *  TEST SUITE FOR MB/WC FUNCTIONS IN C LIBRARY
3  *
4  *       FILE:  tst_funcs.h
5  *
6  *       Definitions of macros
7  */
8
9
10 #ifndef TST_FUNCS_H
11 #define TST_FUNCS_H
12
13 #define C_SUCCESS          'S'  /* test case test passed                 */
14 #define C_FAILURE          'F'  /* test case failed                      */
15 #define C_IGNORED          'I'  /* test case/result ignored (not tested) */
16 #define C_INVALID          'D'  /* test data may be wrong                */
17 #define C_LOCALES          'L'  /* can't set locale (skip)               */
18
19
20 extern int result (FILE * fp, char res, const char *func, const char *loc,
21                    int rec_no, int seq_num, int case_no, const char *msg);
22
23 #define Result(C, S, E, M) \
24   result (fp, (C), (S), locale, rec+1, seq_num+1, (E), (M))
25
26 #define CASE_0    0
27 #define CASE_1    1
28 #define CASE_2    2
29 #define CASE_3    3
30 #define CASE_4    4
31 #define CASE_5    5
32 #define CASE_6    6
33 #define CASE_7    7
34 #define CASE_8    8
35 #define CASE_9    9
36
37 #define MS_PASSED "PASSED"
38 #define MS_SPACE  "      "
39 #define MS_FAILED "      "
40 #define MS_NOTEST "NOTEST"
41 #define MS_ABORTU "ABEND0"
42 #define MS_ABORT  "ABEND1"
43
44 #define MK_PASSED 0x00
45 #define MK_SPACE  0x01
46 #define MK_NOTEST 0x02
47 #define MK_ABORTU 0x04
48 #define MK_ABORT  0x08
49
50
51
52 /* ------------------ COMMON MACROS ------------------ */
53
54 #define TST_ABS(x)  (((x) > 0) ? (x) : -(x))
55
56 #define TMD_ERRET(_type_)   int   err_val; \
57                             int   ret_flg; \
58                             _type_ ret_val
59
60 #define TMD_RECHEAD(_FUNC_)                                   \
61                                                                          \
62                               typedef struct {                           \
63                                   TIN_##_FUNC_##_REC  input;             \
64                                   TEX_##_FUNC_##_REC  expect;            \
65                                   int is_last;                           \
66                               }   TST_##_FUNC_##_REC;                    \
67                               typedef struct {                           \
68                                   TST_HEAD            hd;                \
69                                   TST_##_FUNC_##_REC  rec[ MAX_LOC_TEST ]; \
70                               }   TST_##_FUNC_
71
72 #define TST_FTYP(func)          tst_##func##_loc
73 #define TST_HEAD(func)          tst_##func##_loc[ loc ].hd
74 #define TST_INPUT(func)         tst_##func##_loc[ loc ].rec[ rec ].input
75 #define TST_EXPECT(func)        tst_##func##_loc[ loc ].rec[ rec ].expect
76 #define TST_INPUT_SEQ(func) \
77         tst_##func##_loc[ loc ].rec[ rec ].input.seq[ seq_num ]
78 #define TST_EXPECT_SEQ(func) \
79         tst_##func##_loc[ loc ].rec[ rec ].expect.seq[ seq_num ]
80 #define TST_IS_LAST(func) \
81         tst_##func##_loc[ loc ].rec[ rec ].is_last
82
83
84 #define TST_DECL_VARS(_type_)                           \
85         int   loc, rec, err_count = 0;                  \
86         int   warn_count __attribute__ ((unused));      \
87         int   func_id, seq_num = 0;                     \
88         const char *locale;                             \
89         int   err_exp, ret_flg;                         \
90         int errno_save = 0;                             \
91         _type_ ret_exp;                                 \
92         _type_ ret
93
94 #define TST_DO_TEST(o_func) \
95         for (loc = 0; strcmp (TST_HEAD (o_func).locale, TST_LOC_end); ++loc)
96
97
98 #define TST_HEAD_LOCALE(ofunc, s_func) \
99   func_id = TST_HEAD (ofunc).func_id;                                         \
100   locale  = TST_HEAD (ofunc).locale;                                          \
101   if (setlocale (LC_ALL, locale) == NULL)                                     \
102     {                                                                         \
103       fprintf (stderr, "Warning : can't set locale: %s\nskipping ...\n",      \
104                locale);                                                       \
105       result (fp, C_LOCALES, s_func, locale, 0, 0, 0, "can't set locale");    \
106       continue;                                                               \
107     }
108
109 #define TST_DO_REC(ofunc) \
110         for (rec=0; !TST_IS_LAST (ofunc); ++rec)
111
112 #define TST_DO_SEQ(_count_) \
113         for (seq_num=0; seq_num < _count_; seq_num++)
114
115 #define TST_GET_ERRET(_ofunc_)                  \
116         err_exp = TST_EXPECT (_ofunc_).err_val; \
117         ret_flg = TST_EXPECT (_ofunc_).ret_flg; \
118         ret_exp = TST_EXPECT (_ofunc_).ret_val
119
120 #define TST_GET_ERRET_SEQ(_ofunc_)                  \
121         err_exp = TST_EXPECT_SEQ (_ofunc_).err_val; \
122         ret_flg = TST_EXPECT_SEQ (_ofunc_).ret_flg; \
123         ret_exp = TST_EXPECT_SEQ (_ofunc_).ret_val
124
125 #define TST_CLEAR_ERRNO \
126         errno = 0
127
128 #define TST_SAVE_ERRNO \
129         errno_save = errno
130
131 /* Test value of ret and of errno if it should have a value.  */
132 #define TST_IF_RETURN(_s_func_) \
133   if (err_exp != 0)                                                           \
134     {                                                                         \
135       if (errno_save == err_exp)                                              \
136         {                                                                     \
137           result (fp, C_SUCCESS, _s_func_, locale, rec+1, seq_num+1, 1,       \
138                   MS_PASSED);                                                 \
139         }                                                                     \
140       else                                                                    \
141         {                                                                     \
142           err_count++;                                                        \
143           result (fp, C_FAILURE, _s_func_, locale, rec+1, seq_num+1, 1,       \
144                   "the value of errno is different from an expected value");  \
145         }                                                                     \
146     }                                                                         \
147                                                                               \
148   if (ret_flg == 1)                                                           \
149     {                                                                         \
150       if (ret == ret_exp)                                                     \
151         {                                                                     \
152           result (fp, C_SUCCESS, _s_func_, locale, rec+1, seq_num+1, 2,       \
153                   MS_PASSED);                                                 \
154         }                                                                     \
155       else                                                                    \
156         {                                                                     \
157           err_count++;                                                        \
158           result (fp, C_FAILURE, _s_func_, locale, rec+1, seq_num+1, 2,       \
159                   "the return value is different from an expected value");    \
160         }                                                                     \
161     }                                                                         \
162   else
163
164 #define TEX_ERRET_REC(_type_)                   \
165         struct {                                \
166             TMD_ERRET (_type_);                 \
167         }
168
169 #define TEX_ERRET_REC_SEQ(_type_, _count_)      \
170         struct {                                \
171             struct {                            \
172                 TMD_ERRET (_type_);             \
173             } seq[ _count_ ];                   \
174         }
175
176
177
178 /* ------------------ FUNCTION: ISW*() ------------------- */
179
180 #define TST_ISW_STRUCT(_FUNC_, _func_)                  \
181         typedef                                         \
182         struct {                                        \
183             wint_t   wc;                                \
184         } TIN_ISW##_FUNC_##_REC;                        \
185         typedef                                         \
186         TEX_ERRET_REC (int)   TEX_ISW##_FUNC_##_REC;    \
187         TMD_RECHEAD (ISW##_FUNC_)
188
189 #define TST_FUNC_ISW(_FUNC_, _func_) \
190 int                                                                           \
191 tst_isw##_func_ (FILE *fp, int debug_flg)                                     \
192 {                                                                             \
193   TST_DECL_VARS(int);                                                         \
194   wint_t wc;                                                                  \
195   TST_DO_TEST (isw##_func_)                                                   \
196     {                                                                         \
197       TST_HEAD_LOCALE (isw##_func_, S_ISW##_FUNC_);                           \
198       TST_DO_REC(isw##_func_)                                                 \
199         {                                                                     \
200           TST_GET_ERRET (isw##_func_);                                        \
201           wc = TST_INPUT (isw##_func_).wc;                                    \
202           ret = isw##_func_ (wc);                                             \
203           if (debug_flg)                                                      \
204             {                                                                 \
205               fprintf (stdout, "isw*() [ %s : %d ] ret = %d\n", locale,       \
206                        rec+1, ret);                                           \
207             }                                                                 \
208                                                                               \
209           TST_IF_RETURN (S_ISW##_FUNC_)                                       \
210             {                                                                 \
211               if (ret != 0)                                                   \
212                 {                                                             \
213                   result (fp, C_SUCCESS, S_ISW##_FUNC_, locale, rec+1,        \
214                           seq_num+1, 3, MS_PASSED);                           \
215                 }                                                             \
216               else                                                            \
217                 {                                                             \
218                   err_count++;                                                \
219                   result (fp, C_FAILURE, S_ISW##_FUNC_, locale, rec+1,        \
220                           seq_num+1, 3,                                       \
221                           "the function returned 0, but should be non-zero"); \
222                 }                                                             \
223             }                                                                 \
224         }                                                                     \
225     }                                                                         \
226                                                                               \
227   return err_count;                                                           \
228 }
229
230
231
232 /* ------------------ FUNCTION: TOW*() ------------------ */
233
234 #define TST_TOW_STRUCT(_FUNC_, _func_)                  \
235         typedef                                         \
236         struct {                                        \
237             wint_t   wc;                                \
238         } TIN_TOW##_FUNC_##_REC;                        \
239         typedef                                         \
240         TEX_ERRET_REC (wint_t)  TEX_TOW##_FUNC_##_REC;  \
241         TMD_RECHEAD (TOW##_FUNC_)
242
243 #define TST_FUNC_TOW(_FUNC_, _func_)                                    \
244 int                                                                     \
245 tst_tow##_func_ (FILE *fp, int debug_flg)                               \
246 {                                                                       \
247   TST_DECL_VARS (wint_t);                                               \
248   wint_t wc;                                                            \
249   TST_DO_TEST (tow##_func_)                                             \
250     {                                                                   \
251       TST_HEAD_LOCALE (tow##_func_, S_TOW##_FUNC_);                     \
252       TST_DO_REC (tow##_func_)                                          \
253         {                                                               \
254           TST_GET_ERRET (tow##_func_);                                  \
255           wc = TST_INPUT (tow##_func_).wc;                              \
256           ret = tow##_func_ (wc);                                       \
257           if (debug_flg)                                                \
258             {                                                           \
259               fprintf (stdout, "tow*() [ %s : %d ] ret = 0x%x\n",       \
260                        locale, rec+1, ret);                             \
261             }                                                           \
262                                                                         \
263           TST_IF_RETURN (S_TOW##_FUNC_) { };                            \
264         }                                                               \
265     }                                                                   \
266                                                                         \
267   return err_count;                                                     \
268 }
269
270
271 #endif /* TST_FUNCS_H */