00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00017
00018
00019
00020
00021
00022
00023
00024
00025 #ifndef TEST_CASE_H_
00026 #define TEST_CASE_H_
00027
00028 #include <LampUnit/Test.h>
00029
00030
00031
00032
00033
00034 #define TestFail(message) \
00035 { addFailure((message), __FILE__, __LINE__); }
00036
00037
00038
00039
00040
00041 #define TestAssert(condition) \
00042 if(!(condition)){ TestFail((#condition)); }
00043
00044
00045
00046
00047
00048
00049 #define TestAssertMessage(condition, message) \
00050 if(!(condition)){ TestFail((message)); }
00051
00052
00053
00054
00055
00056
00057 #define TestEquals(expected, actual) \
00058 { assertEquals((expected), (actual), __FILE__, __LINE__); }
00059
00060
00061
00062
00063
00064
00065 #define TestNotEquals(notExpected, actual) \
00066 { assertNotEquals((notExpected), (actual), __FILE__, __LINE__); }
00067
00068
00069
00070
00071
00072
00073
00074 #define TestEpsilonEquals(expected, actual, epsilon) \
00075 { assertEquals((expected), (actual), __FILE__, __LINE__, (epsilon)); }
00076
00077
00078
00079
00080
00081
00082
00083 #define TestNotEpsilonEquals(notExpected, actual, epsilon) \
00084 { assertNotEquals((notExpected), (actual), __FILE__, __LINE__, (epsilon)); }
00085
00086 namespace LampUnit{
00087
00088
00089
00090
00091
00092 class TestCase : public Test{
00093 public:
00094
00095
00096
00097
00098 explicit TestCase(Lamp::String name);
00099
00100
00101
00102
00103 virtual ~TestCase(){}
00104
00105
00106
00107
00108 virtual void run(TestResult* result);
00109
00110
00111
00112
00113
00114 virtual int getCountTestCases() const{ return 1; }
00115
00116
00117
00118
00119
00120 virtual const Lamp::String& getName() const{ return name_; }
00121
00122
00123
00124
00125
00126 virtual const Lamp::String& toString() const{ return name_; }
00127
00128
00129
00130
00131 virtual void setUp(){}
00132
00133
00134
00135
00136 virtual void tearDown(){}
00137
00138
00139
00140
00141
00142
00143
00144
00145 static Test* suite(){ return NULL; }
00146
00147
00148 protected:
00149
00150
00151
00152
00153
00154 TestCase();
00155
00156
00157
00158
00159 virtual void runTest() = 0;
00160
00161
00162
00163
00164
00165
00166
00167 virtual void addFailure(
00168 const Lamp::String& message, const char* file, int line);
00169
00170
00171
00172
00173
00174
00175
00176
00177
00178
00179
00180
00181 bool assertEquals(int expected, int actual, const char* file, int line){
00182 if(expected == actual){ return true; }
00183 addFailure(notEqualMessage(expected, actual), file, line);
00184 return false;
00185 }
00186
00187
00188
00189
00190
00191
00192
00193
00194
00195 bool assertEquals(u_int expected, u_int actual,
00196 const char* file, int line){
00197 if(expected == actual){ return true; }
00198 addFailure(notEqualMessage(expected, actual), file, line);
00199 return false;
00200 }
00201
00202
00203
00204
00205
00206
00207
00208
00209
00210
00211 bool assertEquals(float expected, float actual,
00212 const char* file, int line, float epsilon = 0.f){
00213 Assert(epsilon >= 0.f);
00214 if(equals(expected, actual, epsilon)){ return true; }
00215 addFailure(notEqualMessage(expected, actual, epsilon), file, line);
00216 return false;
00217 }
00218
00219
00220
00221
00222
00223
00224
00225
00226
00227
00228 bool assertEquals(double expected, double actual,
00229 const char* file, int line, double epsilon = 0.f){
00230 Assert(epsilon >= 0.f);
00231 if(equals(expected, actual, epsilon)){ return true; }
00232 addFailure(notEqualMessage(expected, actual, epsilon), file, line);
00233 return false;
00234 }
00235
00236
00237
00238
00239
00240
00241
00242
00243
00244 bool assertEquals(
00245 const char* expected, const char* actual, const char* file, int line){
00246 if(equals(expected, actual)){ return true; }
00247 addFailure(notEqualMessage(expected, actual), file, line);
00248 return false;
00249 }
00250
00251
00252
00253
00254
00255
00256
00257
00258
00259 bool assertEquals(const Lamp::String& expected, const Lamp::String& actual,
00260 const char* file, int line){
00261 return assertEquals(
00262 expected.getBytes(), actual.getBytes(), file, line);
00263 }
00264
00265
00266
00267
00268
00269
00270
00271
00272
00273
00274
00275
00276 bool assertNotEquals(
00277 int notExpected, int actual, const char* file, int line){
00278 if(notExpected != actual){ return true; }
00279 addFailure(equalMessage(notExpected, actual), file, line);
00280 return false;
00281 }
00282
00283
00284
00285
00286
00287
00288
00289
00290
00291 bool assertNotEquals(u_int notExpected, u_int actual,
00292 const char* file, int line){
00293 if(notExpected != actual){ return true; }
00294 addFailure(equalMessage(notExpected, actual), file, line);
00295 return false;
00296 }
00297
00298
00299
00300
00301
00302
00303
00304
00305
00306
00307 bool assertNotEquals(float notExpected, float actual,
00308 const char* file, int line, float epsilon = 0.f){
00309 Assert(epsilon >= 0.f);
00310 if(!equals(notExpected, actual, epsilon)){ return true; }
00311 addFailure(equalMessage(notExpected, actual, epsilon), file, line);
00312 return false;
00313 }
00314
00315
00316
00317
00318
00319
00320
00321
00322
00323
00324 bool assertNotEquals(double notExpected, double actual,
00325 const char* file, int line, double epsilon = 0.f){
00326 Assert(epsilon >= 0.f);
00327 if(!equals(notExpected, actual, epsilon)){ return true; }
00328 addFailure(equalMessage(notExpected, actual, epsilon), file, line);
00329 return false;
00330 }
00331
00332
00333
00334
00335
00336
00337
00338
00339
00340 bool assertNotEquals(const char* notExpected, const char* actual,
00341 const char* file, int line){
00342 if(!equals(notExpected, actual)){ return true; }
00343 addFailure(equalMessage(notExpected, actual), file, line);
00344 return false;
00345 }
00346
00347
00348
00349
00350
00351
00352
00353
00354
00355 bool assertNotEquals(
00356 const Lamp::String& notExpected, const Lamp::String& actual,
00357 const char* file, int line){
00358 return assertNotEquals(
00359 notExpected.getBytes(), actual.getBytes(), file, line);
00360 }
00361
00362
00363
00364
00365
00366
00367
00368
00369
00370
00371
00372 static inline bool equals(
00373 float leftValue, float rightValue, float epsilon = 0.f){
00374 if(leftValue == rightValue){ return true; }
00375 float difference = leftValue - rightValue;
00376 if(difference < 0.f){ difference = -difference; }
00377 return (difference <= epsilon);
00378 }
00379
00380
00381
00382
00383
00384
00385
00386
00387 static inline bool equals(
00388 double leftValue, double rightValue, double epsilon = 0.f){
00389 if(leftValue == rightValue){ return true; }
00390 double difference = leftValue - rightValue;
00391 if(difference < 0.f){ difference = -difference; }
00392 return (difference <= epsilon);
00393 }
00394
00395
00396
00397
00398
00399
00400
00401 static bool equals(const char* leftValue, const char* rightValue);
00402
00403
00404
00405
00406
00407
00408
00409
00410
00411
00412 static Lamp::String notEqualMessage(int expected, int actual);
00413
00414
00415
00416
00417
00418
00419
00420 static Lamp::String notEqualMessage(
00421 u_int expected, u_int actual);
00422
00423
00424
00425
00426
00427
00428
00429
00430 static Lamp::String notEqualMessage(
00431 float expected, float actual, float epsilon);
00432
00433
00434
00435
00436
00437
00438
00439
00440 static Lamp::String notEqualMessage(
00441 double expected, double actual, double epsilon);
00442
00443
00444
00445
00446
00447
00448
00449 static Lamp::String notEqualMessage(
00450 const char* expected, const char* actual);
00451
00452
00453
00454
00455
00456
00457
00458
00459
00460
00461 static Lamp::String equalMessage(int notExpected, int actual);
00462
00463
00464
00465
00466
00467
00468
00469 static Lamp::String equalMessage(
00470 u_int notExpected, u_int actual);
00471
00472
00473
00474
00475
00476
00477
00478
00479 static Lamp::String equalMessage(
00480 float notExpected, float actual, float epsilon);
00481
00482
00483
00484
00485
00486
00487
00488
00489 static Lamp::String equalMessage(
00490 double notExpected, double actual, double epsilon);
00491
00492
00493
00494
00495
00496
00497
00498 static Lamp::String equalMessage(
00499 const char* notExpected, const char* actual);
00500
00501
00502 private:
00503
00504 TestCase(const TestCase& copy);
00505
00506
00507 void operator =(const TestCase& copy);
00508
00509
00510 const Lamp::String name_;
00511
00512 TestResult* result_;
00513 };
00514
00515
00516 }
00517 #endif // End of TEST_CASE_H_
00518