CCUnit project page CCUnit home page

Main Page | Modules | Data Structures | File List | Data Fields | Globals | Related Pages

CCUnitAssert.h

Go to the documentation of this file.
00001 /* -*- mode: C; -*- */
00002 /* Copyright (C) 2003 TSUTSUMI Kikuo.
00003    This file is part of the CCUnit Library.
00004 
00005    The CCUnit Library is free software; you can redistribute it and/or
00006    modify it under the terms of the GNU Lesser General Public License
00007    as published by the Free Software Foundation; either version 2.1 of
00008    the License, or (at your option) any later version.
00009 
00010    The CCUnit Library is distributed in the hope that it will be
00011    useful, but WITHOUT ANY WARRANTY; without even the implied warranty
00012    of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00013    GNU Lesser General Public License for more details.
00014 
00015    You should have received a copy of the GNU Lesser General Public
00016    License along with the CCUnit Library; see the file COPYING.LESSER.
00017    If not, write to the Free Software Foundation, Inc., 59 Temple
00018    Place - Suite 330, Boston, MA 02111-1307, USA.  
00019 */
00020 
00021 /*
00022  * $Id: CCUnitAssert.h,v 1.12 2003/10/05 09:56:41 tsutsumi Exp $
00023  */
00027 #ifndef CCUNITASSERT_H
00028 #define CCUNITASSERT_H
00029 
00030 #include <ccunit/CCUnitConfig.h>
00031 #if CCUNIT_HAVE_SYS_TYPES_H
00032 #  include <sys/types.h>
00033 #endif
00034 
00057 extern void ccunit_assert (const char* file, unsigned int line,
00058                            bool condition, const char* condstr);
00059 
00060 #ifndef CCUNIT_HAVE_U_CHAR
00061 #define CCUNIT_HAVE_U_CHAR
00062 typedef unsigned char u_char;                   
00063 #endif
00064 #ifndef CCUNIT_HAVE_U_INT
00065 #define CCUNIT_HAVE_U_INT
00066 typedef unsigned int u_int;                     
00067 #endif
00068 #ifndef CCUNIT_HAVE_U_SHORT
00069 #define CCUNIT_HAVE_U_SHORT
00070 typedef unsigned short u_short;                 
00071 #endif
00072 #ifndef CCUNIT_HAVE_U_LONG
00073 #define CCUNIT_HAVE_U_LONG
00074 typedef unsigned long u_long;                   
00075 #endif
00076 #ifndef CCUNIT_HAVE_QUAD_T
00077 #ifdef CCUNIT_HAVE_INT64_T
00078 #define CCUNIT_HAVE_QUAD_T 1
00079 typedef int64_t quad_t;                         
00080 #else  /* !CCUNIT_HAVE_INT64_T */
00081 #if CCUNIT_HAVE_LONG_LONG
00082 #define CCUNIT_HAVE_QUAD_T 1
00083 typedef long long quad_t;                       
00084 #endif  /* CCUNIT_HAVE_LONG_LONG */
00085 #endif  /* CCUNIT_HAVE_INT64_T */
00086 #endif  /* !CCUNIT_HAVE_QUAD_T */
00087 
00088 #ifndef CCUNIT_HAVE_U_QUAD_T
00089 #ifdef CCUNIT_HAVE_U_INT64_T
00090 #define CCUNIT_HAVE_U_QUAD_T 1
00091 typedef u_int64_t u_quad_t;
00092 #else  /* !CCUNIT_HAVE_U_INT64_T */
00093 #ifdef CCUNIT_HAVE_LONG_LONG
00094 #define CCUNIT_HAVE_U_QUAD_T 1
00095 typedef unsigned long long u_quad_t;
00096 #endif  /* CCUNIT_HAVE_LONG_LONG */
00097 #endif  /* CCUNIT_HAVE_U_INT64_T */
00098 #endif  /* !CCUNIT_HAVE_U_QUAD_T */
00099 
00100 typedef const char* _ccunit_str_t;              
00101 typedef const void* _ccunit_ptr_t;              
00102 typedef const void* _ccunit_obj_t;              
00114 #define DCL_CCUNIT_ASSERT_TEST_TYPE(TYP)                                \
00115   extern void ccunit_assert_test_ ## TYP (const char* file, unsigned int line, \
00116                                           bool cond, const char* condstr, \
00117                                           TYP expect, TYP acutal)
00118 
00119 DCL_CCUNIT_ASSERT_TEST_TYPE(char);
00120 DCL_CCUNIT_ASSERT_TEST_TYPE(u_char);
00121 DCL_CCUNIT_ASSERT_TEST_TYPE(int);
00122 DCL_CCUNIT_ASSERT_TEST_TYPE(u_int);
00123 DCL_CCUNIT_ASSERT_TEST_TYPE(short);
00124 DCL_CCUNIT_ASSERT_TEST_TYPE(u_short);
00125 DCL_CCUNIT_ASSERT_TEST_TYPE(long);
00126 DCL_CCUNIT_ASSERT_TEST_TYPE(u_long);
00127 DCL_CCUNIT_ASSERT_TEST_TYPE(float);
00128 DCL_CCUNIT_ASSERT_TEST_TYPE(double);
00129 DCL_CCUNIT_ASSERT_TEST_TYPE(_ccunit_str_t);
00130 DCL_CCUNIT_ASSERT_TEST_TYPE(_ccunit_ptr_t);
00131 #if CCUNIT_HAVE_QUAD_T
00132 DCL_CCUNIT_ASSERT_TEST_TYPE(quad_t);
00133 #endif
00134 #if CCUNIT_HAVE_U_QUAD_T
00135 DCL_CCUNIT_ASSERT_TEST_TYPE(u_quad_t);
00136 #endif
00137 
00138 typedef char* (*ccunit_toString_t)(_ccunit_obj_t);
00139 
00140 extern void ccunit_assert_test__ccunit_obj_t (const char* file, unsigned int line,
00141                                               bool cond, const char* condstr,
00142                                               _ccunit_obj_t expect,
00143                                               _ccunit_obj_t acutal,
00144                                               ccunit_toString_t);
00145 
00156 #define CCUNIT_ASSERT(COND) ccunit_assert (__FILE__, __LINE__, COND, #COND)
00157 
00173 #define CCUNIT_ASSERT_TEST(TYP, EXPECT, OP, ACTUAL)                     \
00174   do {                                                                  \
00175     const TYP ex = (EXPECT);                                            \
00176     const TYP ac = (ACTUAL);                                            \
00177     ccunit_assert_test_ ## TYP (__FILE__, __LINE__, (ex OP ac),         \
00178                                 (#EXPECT " " #OP " " #ACTUAL),          \
00179                                 ex, ac);                                \
00180   } while (0)
00181 
00182 #define CCUNIT_ASSERT_TEST_INT(EXPECT, OP, ACTUAL)              \
00183   CCUNIT_ASSERT_TEST (int, EXPECT, OP, ACTUAL)
00184 #define CCUNIT_ASSERT_TEST_UINT(EXPECT, OP, ACTUAL)             \
00185   CCUNIT_ASSERT_TEST (u_int, EXPECT, OP, ACTUAL)
00186 #define CCUNIT_ASSERT_TEST_LONG(EXPECT, OP, ACTUAL)             \
00187   CCUNIT_ASSERT_TEST (long, EXPECT, OP, ACTUAL)
00188 #define CCUNIT_ASSERT_TEST_ULONG(EXPECT, OP, ACTUAL)            \
00189   CCUNIT_ASSERT_TEST (u_long, EXPECT, OP, ACTUAL)
00190 #define CCUNIT_ASSERT_TEST_SHORT(EXPECT, OP, ACTUAL)            \
00191   CCUNIT_ASSERT_TEST (short, EXPECT, OP, ACTUAL)
00192 #define CCUNIT_ASSERT_TEST_USHORT(EXPECT, OP, ACTUAL)           \
00193   CCUNIT_ASSERT_TEST (u_short, EXPECT, OP, ACTUAL)
00194 #define CCUNIT_ASSERT_TEST_DOUBLE(EXPECT, OP, ACTUAL)           \
00195   CCUNIT_ASSERT_TEST (double, EXPECT, OP, ACTUAL)
00196 #define CCUNIT_ASSERT_TEST_FLOAT(EXPECT, OP, ACTUAL)            \
00197   CCUNIT_ASSERT_TEST (float, EXPECT, OP, ACTUAL)
00198 #if CCUNIT_HAVE_QUAD_T
00199 #define CCUNIT_ASSERT_TEST_QUAD(EXPECT, OP, ACTUAL)             \
00200   CCUNIT_ASSERT_TEST (quad_t, EXPECT, OP, ACTUAL)
00201 #endif
00202 #if CCUNIT_HAVE_U_QUAD_T
00203 #define CCUNIT_ASSERT_TEST_UQUAD(EXPECT, OP, ACTUAL)            \
00204   CCUNIT_ASSERT_TEST (u_quad_t, EXPECT, OP, ACTUAL)
00205 #endif
00206 #define CCUNIT_ASSERT_TEST_PTR(EXPECT, OP, ACTUAL)              \
00207   CCUNIT_ASSERT_TEST (_ccunit_ptr_t, EXPECT, OP, ACTUAL)
00208 
00209 #define CCUNIT_ASSERT_TEST_STR(EXPECT, OP, ACTUAL)                      \
00210   do {                                                                  \
00211     const _ccunit_str_t ex = (EXPECT);                                  \
00212     const _ccunit_str_t ac = (ACTUAL);                                  \
00213     const char* condstr = "strcmp (" #EXPECT ", " #ACTUAL ") " #OP " 0"; \
00214     ccunit_assert_test__ccunit_str_t (__FILE__, __LINE__,               \
00215                                       strcmp(ex, ac) OP 0, condstr, ex, ac); \
00216   } while (0)
00217 
00218 #define CCUNIT_ASSERT_TEST_NSTR(EXPECT, OP, ACTUAL, N)                  \
00219   do {                                                                  \
00220     const _ccunit_str_t ex = (EXPECT);                                  \
00221     const _ccunit_str_t ac = (ACTUAL);                                  \
00222     const size_t n = (N);                                               \
00223     ccunit_assert_test__ccunit_str_t (__FILE__, __LINE__,               \
00224                                       strncmp(ex, ac, n) OP 0,          \
00225                                       "strncmp (" #EXPECT ", " #ACTUAL  \
00226                                       ", " #N ") " #OP " 0",            \
00227                                       ex, ac);                          \
00228   } while (0)
00229 
00230 #define CCUNIT_ASSERT_TEST_CASE_STR(EXPECT, OP, ACTUAL)                 \
00231   do {                                                                  \
00232     const _ccunit_str_t ex = (EXPECT);                                  \
00233     const _ccunit_str_t ac = (ACTUAL);                                  \
00234     const size_t n = (N);                                               \
00235     ccunit_assert_test__ccunit_str_t (__FILE__, __LINE__,               \
00236                                       strcasecmp(ex, ac) OP 0,          \
00237                                       "strcasecmp (" #EXPECT ", " #ACTUAL \
00238                                       ") " #OP " 0",                    \
00239                                       ex, ac);                          \
00240   } while (0)
00241 
00242 #define CCUNIT_ASSERT_TEST_CASE_NSTR(EXPECT, OP, ACTUAL, N)             \
00243   do {                                                                  \
00244     const _ccunit_str_t ex = (EXPECT);                                  \
00245     const _ccunit_str_t ac = (ACTUAL);                                  \
00246     const size_t n = (N);                                               \
00247     ccunit_assert_test__ccunit_str_t (__FILE__, __LINE__,               \
00248                                       strncasecmp(ex, ac, n) OP 0,      \
00249                                       "strncasecmp (" #EXPECT ", " #ACTUAL \
00250                                       ", " #N ") " #OP " 0",            \
00251                                       ex, ac);                          \
00252   } while (0)
00253 
00254 #define CCUNIT_ASSERT_TEST_OBJ(EXPECT, OP, ACTUAL, TOSTR)               \
00255   do {                                                                  \
00256     const _ccunit_obj_t ex = (EXPECT);                                  \
00257     const _ccunit_obj_t ac = (ACTUAL);                                  \
00258     const char* condstr = #OP " (" #EXPECT ", " #ACTUAL ")";            \
00259     ccunit_assert_test__ccunit_obj_t (__FILE__, __LINE__,               \
00260                                       OP(ex, ac), condstr, ex, ac,      \
00261                                       (ccunit_toString_t)TOSTR);        \
00262   } while (0)
00263 
00279 #define CCUNIT_ASSERT_COND(TYP, CONDITION, EXPECT, ACTUAL)              \
00280   do {                                                                  \
00281     const TYP ex = (EXPECT);                                            \
00282     const TYP ac = (ACTUAL);                                            \
00283     ccunit_assert_test_ ## TYP (__FILE__, __LINE__, (CONDITION),        \
00284                                 (#CONDITION), ex, ac);                  \
00285   } while (0)
00286 
00292 #define CCUNIT_ASSERT_NULL(ACTUAL)              \
00293   CCUNIT_ASSERT_TEST_PTR(NULL, ==, ACTUAL)
00294 #define CCUNIT_ASSERT_NOT_NULL(ACTUAL)          \
00295   CCUNIT_ASSERT_TEST_PTR(NULL, !=, ACTUAL)
00296 
00297 #define CCUNIT_ASSERT_EQ_INT(EXPECT, ACTUAL)    \
00298   CCUNIT_ASSERT_TEST_INT (EXPECT, ==, ACTUAL)
00299 #define CCUNIT_ASSERT_NE_INT(EXPECT, ACTUAL)    \
00300   CCUNIT_ASSERT_TEST_INT (EXPECT, !=, ACTUAL)
00301 #define CCUNIT_ASSERT_LT_INT(EXPECT, ACTUAL)    \
00302   CCUNIT_ASSERT_TEST_INT (EXPECT, <, ACTUAL)
00303 #define CCUNIT_ASSERT_LE_INT(EXPECT, ACTUAL)    \
00304   CCUNIT_ASSERT_TEST_INT (EXPECT, <=, ACTUAL)
00305 #define CCUNIT_ASSERT_GT_INT(EXPECT, ACTUAL)    \
00306   CCUNIT_ASSERT_TEST_INT (EXPECT, >, ACTUAL)
00307 #define CCUNIT_ASSERT_GE_INT(EXPECT, ACTUAL)    \
00308   CCUNIT_ASSERT_TEST_INT (EXPECT, >=, ACTUAL)
00309 
00310 #define CCUNIT_ASSERT_EQ_UINT(EXPECT, ACTUAL)   \
00311   CCUNIT_ASSERT_TEST_UINT (EXPECT, ==, ACTUAL)
00312 #define CCUNIT_ASSERT_NE_UINT(EXPECT, ACTUAL)   \
00313   CCUNIT_ASSERT_TEST_UINT (EXPECT, !=, ACTUAL)
00314 #define CCUNIT_ASSERT_LT_UINT(EXPECT, ACTUAL)   \
00315   CCUNIT_ASSERT_TEST_UINT (EXPECT, <, ACTUAL)
00316 #define CCUNIT_ASSERT_LE_UINT(EXPECT, ACTUAL)   \
00317   CCUNIT_ASSERT_TEST_UINT (EXPECT, <=, ACTUAL)
00318 #define CCUNIT_ASSERT_GT_UINT(EXPECT, ACTUAL)   \
00319   CCUNIT_ASSERT_TEST_UINT (EXPECT, >, ACTUAL)
00320 #define CCUNIT_ASSERT_GE_UINT(EXPECT, ACTUAL)   \
00321   CCUNIT_ASSERT_TEST_UINT (EXPECT, >=, ACTUAL)
00322 
00323 #if CCUNIT_HAVE_QUAD_T
00324 #define CCUNIT_ASSERT_EQ_QUAD(EXPECT, ACTUAL)   \
00325   CCUNIT_ASSERT_TEST_QUAD (EXPECT, ==, ACTUAL)
00326 #define CCUNIT_ASSERT_NE_QUAD(EXPECT, ACTUAL)   \
00327   CCUNIT_ASSERT_TEST_QUAD (EXPECT, !=, ACTUAL)
00328 #define CCUNIT_ASSERT_LT_QUAD(EXPECT, ACTUAL)   \
00329   CCUNIT_ASSERT_TEST_QUAD (EXPECT, <, ACTUAL)
00330 #define CCUNIT_ASSERT_LE_QUAD(EXPECT, ACTUAL)   \
00331   CCUNIT_ASSERT_TEST_QUAD (EXPECT, <=, ACTUAL)
00332 #define CCUNIT_ASSERT_GT_QUAD(EXPECT, ACTUAL)   \
00333   CCUNIT_ASSERT_TEST_QUAD (EXPECT, >, ACTUAL)
00334 #define CCUNIT_ASSERT_GE_QUAD(EXPECT, ACTUAL)   \
00335   CCUNIT_ASSERT_TEST_QUAD (EXPECT, >=, ACTUAL)
00336 #endif
00337 
00338 #if CCUNIT_HAVE_U_QUAD_T
00339 #define CCUNIT_ASSERT_EQ_UQUAD(EXPECT, ACTUAL)  \
00340   CCUNIT_ASSERT_TEST_UQUAD (EXPECT, ==, ACTUAL)
00341 #define CCUNIT_ASSERT_NE_UQUAD(EXPECT, ACTUAL)  \
00342   CCUNIT_ASSERT_TEST_UQUAD (EXPECT, !=, ACTUAL)
00343 #define CCUNIT_ASSERT_LT_UQUAD(EXPECT, ACTUAL)  \
00344   CCUNIT_ASSERT_TEST_UQUAD (EXPECT, <, ACTUAL)
00345 #define CCUNIT_ASSERT_LE_UQUAD(EXPECT, ACTUAL)  \
00346   CCUNIT_ASSERT_TEST_UQUAD (EXPECT, <=, ACTUAL)
00347 #define CCUNIT_ASSERT_GT_UQUAD(EXPECT, ACTUAL)  \
00348   CCUNIT_ASSERT_TEST_UQUAD (EXPECT, >, ACTUAL)
00349 #define CCUNIT_ASSERT_GE_UQUAD(EXPECT, ACTUAL)  \
00350   CCUNIT_ASSERT_TEST_UQUAD (EXPECT, >=, ACTUAL)
00351 #endif
00352 
00353 #define CCUNIT_ASSERT_EQ_STR(EXPECT, ACTUAL)    \
00354   CCUNIT_ASSERT_TEST_STR (EXPECT, ==, ACTUAL)
00355 #define CCUNIT_ASSERT_NE_STR(EXPECT, ACTUAL)    \
00356   CCUNIT_ASSERT_TEST_STR (EXPECT, !=, ACTUAL)
00357 #define CCUNIT_ASSERT_LT_STR(EXPECT, ACTUAL)    \
00358   CCUNIT_ASSERT_TEST_STR (EXPECT, <, ACTUAL)
00359 #define CCUNIT_ASSERT_LE_STR(EXPECT, ACTUAL)    \
00360   CCUNIT_ASSERT_TEST_STR (EXPECT, <=, ACTUAL)
00361 #define CCUNIT_ASSERT_GT_STR(EXPECT, ACTUAL)    \
00362   CCUNIT_ASSERT_TEST_STR (EXPECT, >, ACTUAL)
00363 #define CCUNIT_ASSERT_GE_STR(EXPECT, ACTUAL)    \
00364   CCUNIT_ASSERT_TEST_STR (EXPECT, >=, ACTUAL)
00365 
00366 #define CCUNIT_ASSERT_EQ_PTR(EXPECT, ACTUAL)    \
00367   CCUNIT_ASSERT_TEST_PTR (EXPECT, ==, ACTUAL)
00368 #define CCUNIT_ASSERT_NE_PTR(EXPECT, ACTUAL)    \
00369   CCUNIT_ASSERT_TEST_PTR (EXPECT, !=, ACTUAL)
00370 #define CCUNIT_ASSERT_LT_PTR(EXPECT, ACTUAL)    \
00371   CCUNIT_ASSERT_TEST_PTR (EXPECT, <, ACTUAL)
00372 #define CCUNIT_ASSERT_LE_PTR(EXPECT, ACTUAL)    \
00373   CCUNIT_ASSERT_TEST_PTR (EXPECT, <=, ACTUAL)
00374 #define CCUNIT_ASSERT_GT_PTR(EXPECT, ACTUAL)    \
00375   CCUNIT_ASSERT_TEST_PTR (EXPECT, >, ACTUAL)
00376 #define CCUNIT_ASSERT_GE_PTR(EXPECT, ACTUAL)    \
00377   CCUNIT_ASSERT_TEST_PTR (EXPECT, >=, ACTUAL)
00378 
00383 #endif

SourceForge.jp hosts this site. Send comments to:
CCUnit Developer