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   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   locale = TST_HEAD (ofunc).locale;                                           \
 100   if (setlocale (LC_ALL, locale) == NULL)                                     \
 101     {                                                                         \
 102       fprintf (stderr, "Warning : can't set locale: %s\nskipping ...\n",      \
 103                locale);                                                       \
 104       result (fp, C_LOCALES, s_func, locale, 0, 0, 0, "can't set locale");    \
 105       ++err_count;                                                            \
 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 */