src/xbt/cunit.c

   1 /* $Id$ */
   2
   3 /* cunit - A little C Unit facility                                         */
   4
   5 /* Copyright (c) 2005 Martin Quinson. All rights reserved.                  */
   6
   7 /* This program is free software; you can redistribute it and/or modify it
   8  * under the terms of the license (GNU LGPL) which comes with this package. */
   9
  10 /* This is partially inspirated from the OSSP ts (Test Suite Library)       */
  11
  12 #include "portable.h"
  13
  14 #include "xbt/sysdep.h"    /* vasprintf */
  15 #include "xbt/cunit.h"
  16 #include "xbt/dynar.h"
  17
  18 /* collection of all suites */
  19 static xbt_dynar_t _xbt_test_suites = NULL;
  20 /* global statistics */
  21 static int _xbt_test_nb_tests = 0;
  22 static int _xbt_test_test_failed = 0;
  23 static int _xbt_test_test_ignore = 0;
  24 static int _xbt_test_test_expect = 0;
  25
  26 static int _xbt_test_nb_units    = 0;
  27 static int _xbt_test_unit_failed = 0;
  28 static int _xbt_test_unit_ignore = 0;
  29 static int _xbt_test_unit_disabled = 0;
  30
  31 static int _xbt_test_nb_suites    = 0;
  32 static int _xbt_test_suite_failed = 0;
  33 static int _xbt_test_suite_ignore = 0;
  34 static int _xbt_test_suite_disabled = 0;
  35
  36 /* Context */
  37 xbt_test_unit_t _xbt_test_current_unit = NULL;
  38
  39
  40 /* test suite test log */
  41 typedef struct s_xbt_test_log {
  42   char              *text;
  43   const char        *file;
  44   int                line;
  45 } *xbt_test_log_t;
  46
  47 static void xbt_test_log_dump(xbt_test_log_t log) {
  48   if (log)
  49     fprintf(stderr,"      log %p(%s:%d)=%s\n",log,log->file,log->line,log->text);
  50   else
  51     fprintf(stderr,"      log=NULL\n");
  52 }
  53 static void xbt_test_log_free(xbt_test_log_t log) {
  54   if (!log)
  55     return;
  56   if (log->text)
  57     free(log->text);
  58   free(log);
  59 }
  60
  61 /* test suite test check */
  62 typedef struct s_xbt_test_test {
  63   char        *title;
  64   int          failed;
  65   int          expected_failure;
  66   int          ignored;
  67   const char  *file;
  68   int          line;
  69   xbt_dynar_t  logs;
  70 } *xbt_test_test_t;
  71
  72 static void xbt_test_test_dump(xbt_test_test_t test){
  73   if (test) {
  74     xbt_test_log_t log;
  75     unsigned int it_log;
  76     fprintf(stderr,"    test %p(%s:%d)=%s (%s)\n",
  77             test,test->file,test->line,test->title,
  78             test->failed?"failed":"not failed");
  79     xbt_dynar_foreach(test->logs,it_log,log)
  80       xbt_test_log_dump(log);
  81   }
  82   else
  83     fprintf(stderr,"    test=NULL\n");
  84 }
  85
  86 /* test suite test unit */
  87 struct s_xbt_test_unit {
  88   int          enabled;
  89   char        *name;
  90   char        *title;
  91   ts_test_cb_t func;
  92   const char  *file;
  93   int          line;
  94   xbt_dynar_t  tests; /* of xbt_test_test_t*/
  95
  96   int nb_tests;
  97   int test_failed,test_ignore,test_expect;
  98 };
  99
 100 static void xbt_test_unit_dump(xbt_test_unit_t unit) {
 101   if (unit) {
 102     xbt_test_test_t test;
 103     unsigned int it_test;
 104     fprintf(stderr,"  UNIT %s: %s (%s)\n",
 105             unit->name,unit->title,
 106             (unit->enabled?"enabled":"disabled"));
 107     if (unit->enabled)
 108       xbt_dynar_foreach(unit->tests,it_test,test)
 109         xbt_test_test_dump(test);
 110   } else {
 111     fprintf(stderr,"  unit=NULL\n");
 112   }
 113 }
 114
 115 /* test suite */
 116 struct s_xbt_test_suite {
 117   int         enabled;
 118   const char *name;
 119   char       *title;
 120   xbt_dynar_t units; /* of xbt_test_unit_t */
 121
 122   int nb_tests,nb_units;
 123   int test_failed,test_ignore,test_expect;
 124   int unit_failed,unit_ignore,unit_disabled;
 125 };
 126
 127 /* destroy test suite */
 128 static void xbt_test_suite_free(void *s) {
 129   xbt_test_suite_t suite = *(xbt_test_suite_t*) s;
 130
 131   if (suite == NULL)
 132     return;
 133   xbt_dynar_free(&suite->units);
 134   free(suite->title);
 135   free(suite);
 136 }
 137
 138 /** @brief create test suite */
 139 xbt_test_suite_t xbt_test_suite_new(const char *name, const char *fmt, ...) {
 140   xbt_test_suite_t suite = xbt_new0(struct s_xbt_test_suite,1);
 141   va_list ap;
 142
 143   if (!_xbt_test_suites)
 144     _xbt_test_suites = xbt_dynar_new(sizeof(xbt_test_suite_t),xbt_test_suite_free);
 145
 146   va_start(ap, fmt);
 147   vasprintf(&suite->title,fmt, ap);
 148   suite->units = xbt_dynar_new(sizeof(xbt_test_unit_t), NULL);
 149   va_end(ap);
 150   suite->name = name;
 151   suite->enabled = 1;
 152
 153   xbt_dynar_push(_xbt_test_suites,&suite);
 154
 155   return suite;
 156 }
 157
 158 /** @brief retrieve a testsuite from name, or create a new one */
 159 xbt_test_suite_t xbt_test_suite_by_name(const char *name,const char *fmt, ...) {
 160   xbt_test_suite_t suite;
 161   unsigned int it_suite;
 162
 163   char *bufname;
 164   va_list ap;
 165
 166   if (_xbt_test_suites)
 167     xbt_dynar_foreach(_xbt_test_suites, it_suite, suite)
 168       if (!strcmp(suite->name,name))
 169         return suite;
 170
 171   va_start(ap, fmt);
 172   vasprintf(&bufname,fmt, ap);
 173   va_end(ap);
 174   suite = xbt_test_suite_new(name,bufname,NULL);
 175   free(bufname);
 176
 177   return suite;
 178 }
 179
 180 void xbt_test_suite_dump(xbt_test_suite_t suite) {
 181   if (suite) {
 182     xbt_test_unit_t unit;
 183     unsigned int it_unit;
 184     fprintf(stderr,"TESTSUITE %s: %s (%s)\n",
 185             suite->name, suite->title,
 186             suite->enabled?"enabled":"disabled");
 187     if (suite->enabled)
 188       xbt_dynar_foreach(suite->units,it_unit,unit)
 189         xbt_test_unit_dump(unit);
 190   } else {
 191     fprintf(stderr,"TESTSUITE IS NULL!\n");
 192   }
 193 }
 194
 195 /* add test case to test suite */
 196 void xbt_test_suite_push(xbt_test_suite_t suite, const char *name, ts_test_cb_t func, const char *fmt, ...) {
 197   xbt_test_unit_t unit;
 198   va_list ap;
 199
 200   xbt_assert(suite);
 201   xbt_assert(func);
 202   xbt_assert(fmt);
 203
 204   unit = xbt_new0(struct s_xbt_test_unit,1);
 205   va_start(ap, fmt);
 206   vasprintf(&unit->title, fmt, ap);
 207   va_end(ap);
 208   unit->name = (char*)name;
 209   unit->func = func;
 210   unit->file = NULL;
 211   unit->line = 0;
 212   unit->enabled = 1;
 213   unit->tests = xbt_dynar_new(sizeof(xbt_test_test_t), NULL);
 214
 215   xbt_dynar_push(suite->units, &unit);
 216   return;
 217 }
 218
 219 /* run test one suite */
 220 static int xbt_test_suite_run(xbt_test_suite_t suite) {
 221   xbt_test_unit_t unit;
 222   xbt_test_test_t test;
 223   xbt_test_log_t log;
 224
 225   const char *file;
 226   int line;
 227   char *cp;
 228   unsigned int it_unit,it_test,it_log;
 229
 230   int first=1; /* for result pretty printing */
 231
 232   if (suite == NULL)
 233     return 0;
 234
 235   /* suite title pretty-printing */
 236   {
 237     char suite_title[80];
 238     int suite_len=strlen(suite->title);
 239     int i;
 240
 241     xbt_assert2(suite_len<68,"suite title \"%s\" too long (%d should be less than 68",
 242                 suite->title,suite_len);
 243
 244     suite_title[0]=' ';
 245     for (i=1;i<79;i++)
 246       suite_title[i]='=';
 247     suite_title[i++]='\n';
 248     suite_title[79]='\0';
 249
 250     sprintf(suite_title + 40 - (suite_len+4)/2, "[ %s ]", suite->title);
 251     suite_title[40 + (suite_len+5)/2] = '=';
 252     if (!suite->enabled)
 253       sprintf(suite_title+ 70," DISABLED ");
 254     fprintf(stderr, "\n%s\n",suite_title);
 255   }
 256
 257   if (suite->enabled) {
 258     /* iterate through all tests */
 259     xbt_dynar_foreach(suite->units, it_unit, unit) {
 260       /* init unit case counters */
 261       unit->nb_tests = 0;
 262       unit->test_ignore = 0;
 263       unit->test_failed = 0;
 264       unit->test_expect = 0;
 265
 266       /* display unit title */
 267       asprintf(&cp," Unit: %s ......................................"
 268                "......................................", unit->title);
 269       cp[70] = '\0';
 270       fprintf(stderr, "%s", cp);
 271       free(cp);
 272
 273       /* run the test case function */
 274       _xbt_test_current_unit = unit;
 275       if (unit->enabled)
 276         unit->func();
 277
 278       /* iterate through all performed tests to determine status */
 279       xbt_dynar_foreach(unit->tests,it_test, test) {
 280         if (test->ignored) {
 281           unit->test_ignore++;
 282         } else {
 283           unit->nb_tests++;
 284
 285           if ( test->failed && !test->expected_failure) unit->test_failed++;
 286           if (!test->failed &&  test->expected_failure) unit->test_failed++;
 287           if (test->expected_failure)
 288             unit->test_expect++;
 289         }
 290       }
 291
 292
 293       /* Display whether this unit went well */
 294       if (unit->test_failed > 0 || unit->test_expect) {
 295         /* some tests failed (or were supposed to), so do detailed reporting of test case */
 296         if (unit->test_failed > 0) {
 297           fprintf(stderr, ".. failed\n");
 298         } else if (unit->nb_tests) {
 299           fprintf(stderr, "...... ok\n"); /* successful, but show about expected */
 300         } else {
 301           fprintf(stderr, ".... skip\n"); /* shouldn't happen, but I'm a bit lost with this logic */
 302         }
 303         xbt_dynar_foreach(unit->tests,it_test, test) {
 304           file = (test->file != NULL ? test->file : unit->file);
 305           line = (test->line != 0    ? test->line : unit->line);
 306           fprintf(stderr, "      %s: %s [%s:%d]\n",
 307                   (test->ignored?" SKIP":(test->expected_failure?(test->failed?"EFAIL":"EPASS"):
 308                                           (test->failed?" FAIL":" PASS"))),
 309                   test->title, file, line);
 310
 311           if  ( (test->expected_failure && !test->failed) || (!test->expected_failure && test->failed) ) {
 312              xbt_dynar_foreach(test->logs,it_log,log) {
 313                 file = (log->file != NULL ? log->file : file);
 314                 line = (log->line != 0    ? log->line : line);
 315                 fprintf(stderr, "             %s:%d: %s\n",
 316                         file, line,log->text);
 317
 318              }
 319           }
 320         }
 321         fprintf(stderr, "    Summary: %d of %d tests failed",unit->test_failed, unit->nb_tests);
 322         if (unit->test_ignore) {
 323           fprintf(stderr," (%d tests ignored)\n",unit->test_ignore);
 324         } else {
 325           fprintf(stderr,"\n");
 326         }
 327
 328       } else if (!unit->enabled) {
 329         fprintf(stderr, " disabled\n"); /* no test were run */
 330       } else if (unit->nb_tests) {
 331         fprintf(stderr, "...... ok\n"); /* successful */
 332       } else  {
 333         fprintf(stderr, ".... skip\n"); /* no test were run */
 334       }
 335
 336       /* Accumulate test counts into the suite */
 337       suite->nb_tests      += unit->nb_tests;
 338       suite->test_failed   += unit->test_failed;
 339       suite->test_ignore   += unit->test_ignore;
 340       suite->test_expect   += unit->test_expect;
 341
 342       _xbt_test_nb_tests      += unit->nb_tests;
 343       _xbt_test_test_failed   += unit->test_failed;
 344       _xbt_test_test_ignore   += unit->test_ignore;
 345       _xbt_test_test_expect   += unit->test_expect;
 346
 347       /* What's the conclusion of this test anyway? */
 348       if (unit->nb_tests) {
 349         suite->nb_units++;
 350         if (unit->test_failed)
 351           suite->unit_failed++;
 352       } else if (!unit->enabled) {
 353         suite->unit_disabled++;
 354       } else {
 355         suite->unit_ignore++;
 356       }
 357     }
 358   }
 359   _xbt_test_nb_units      += suite->nb_units;
 360   _xbt_test_unit_failed   += suite->unit_failed;
 361   _xbt_test_unit_ignore   += suite->unit_ignore;
 362   _xbt_test_unit_disabled += suite->unit_disabled;
 363
 364   if (suite->nb_units) {
 365     _xbt_test_nb_suites++;
 366     if (suite->test_failed)
 367       _xbt_test_suite_failed++;
 368   } else if (!suite->enabled) {
 369     _xbt_test_suite_disabled++;
 370   } else {
 371     _xbt_test_suite_ignore++;
 372   }
 373
 374
 375   /* print test suite summary */
 376   if (suite->enabled) {
 377
 378     fprintf(stderr,
 379             " =====================================================================%s\n",
 380             (suite->nb_units ? (suite->unit_failed   ? "== FAILED":"====== OK")
 381                              : (suite->unit_disabled ? " DISABLED":"==== SKIP")));
 382     fprintf(stderr, " Summary: Units: %.0f%% ok (%d units: ",
 383             suite->nb_units?((1-(double)suite->unit_failed/(double)suite->nb_units)*100.0):100.0,
 384             suite->nb_units);
 385
 386     if (suite->nb_units != suite->unit_failed) {
 387       fprintf(stderr, "%s%d ok",(first?"":", "),suite->nb_units - suite->unit_failed);
 388       first = 0;
 389     }
 390     if (suite->unit_failed) {
 391       fprintf(stderr, "%s%d failed",(first?"":", "),suite->unit_failed);
 392       first = 0;
 393     }
 394     if (suite->unit_ignore) {
 395       fprintf(stderr, "%s%d ignored",(first?"":", "),suite->unit_ignore);
 396       first = 0;
 397     }
 398     if (suite->unit_disabled) {
 399       fprintf(stderr, "%s%d disabled",(first?"":", "),suite->unit_disabled);
 400       first = 0;
 401     }
 402     fprintf(stderr,")\n          Tests: %.0f%% ok (%d tests: ",
 403             suite->nb_tests?((1-(double)suite->test_failed/(double)suite->nb_tests)*100.0):100.0,
 404             suite->nb_tests);
 405
 406     first=1;
 407     if (suite->nb_tests != suite->test_failed) {
 408       fprintf(stderr, "%s%d ok",(first?"":", "),suite->nb_tests - suite->test_failed);
 409       first = 0;
 410     }
 411     if (suite->test_failed) {
 412       fprintf(stderr, "%s%d failed",(first?"":", "),suite->test_failed);
 413       first = 0;
 414     }
 415     if (suite->test_ignore) {
 416       fprintf(stderr, "%s%d ignored",(first?"":"; "),suite->test_ignore);
 417       first = 0;
 418     }
 419     if (suite->test_expect) {
 420       fprintf(stderr, "%s%d expected to fail",(first?"":"; "),suite->test_expect);
 421       first = 0;
 422     }
 423     fprintf(stderr,")\n");
 424   }
 425   return suite->unit_failed;
 426 }
 427
 428 static void apply_selection(char *selection) {
 429   /* for the parsing */
 430   char *sel=selection;
 431   char *p;
 432   int done = 0;
 433   char dir[1024]; /* the directive */
 434   /* iterators */
 435   unsigned int it_suite;
 436   xbt_test_suite_t suite;
 437   xbt_test_unit_t unit;
 438   unsigned int it_unit;
 439
 440   char suitename[512];
 441   char unitname[512];
 442
 443   if (!selection || selection[0] == '\0')
 444     return;
 445
 446   /*printf("Test selection: %s\n", selection);*/
 447
 448   /* First apply the selection */
 449   while (!done) {
 450     int enabling = 1;
 451
 452     p=strchr(sel,',');
 453     if (p) {
 454       strncpy(dir,sel,p-sel);
 455       dir[p-sel]='\0';
 456       sel=p+1;
 457     } else {
 458       strcpy(dir, sel);
 459       done=1;
 460     }
 461
 462     if (dir[0] == '-') {
 463       enabling = 0;
 464       memmove(dir,dir+1,strlen(dir));
 465     }
 466     if (dir[0] == '+') {
 467       enabling = 1;
 468       memmove(dir,dir+1,strlen(dir));
 469     }
 470
 471     p =strchr(dir,':');
 472     if (p) {
 473       strcpy(unitname,p+1);
 474       strncpy(suitename,dir,p-dir);
 475       suitename[p-dir]='\0';
 476     } else {
 477       strcpy(suitename,dir);
 478       unitname[0] = '\0';
 479     }
 480     /*fprintf(stderr,"Seen %s (%s; suite=%s; unit=%s)\n",
 481       dir,enabling?"enabling":"disabling", suitename, unitname);*/
 482
 483     /* Deal with the specific case of 'all' pseudo serie */
 484     if (!strcmp("all",suitename)) {
 485       if (unitname[0]!='\0') {
 486         fprintf(stderr,"The 'all' pseudo-suite does not accept any unit specification\n");
 487         exit(1);
 488       }
 489
 490       xbt_dynar_foreach(_xbt_test_suites,it_suite,suite) {
 491         xbt_dynar_foreach(suite->units,it_unit,unit) {
 492           unit->enabled = enabling;
 493         }
 494         suite->enabled = enabling;
 495       }
 496     } else {
 497       unsigned int it;
 498       for (it=0; it< xbt_dynar_length(_xbt_test_suites); it++) {
 499         xbt_test_suite_t thissuite=xbt_dynar_get_as(_xbt_test_suites,it,xbt_test_suite_t);
 500         if (!strcmp(suitename,thissuite->name)) {
 501           /* Do not disable the whole suite when we just want to disable a child */
 502           if (enabling || (unitname[0]=='\0'))
 503             thissuite->enabled = enabling;
 504
 505           if (unitname[0]=='\0') {
 506             xbt_dynar_foreach(thissuite->units,it_unit,unit){
 507               unit->enabled = enabling;
 508             }
 509           } else { /* act on one child only */
 510             unsigned int it2_unit;
 511             /* search it, first (we won't reuse it for external loop which gets broken) */
 512             for (it2_unit=0; it2_unit< xbt_dynar_length(thissuite->units); it2_unit++) {
 513               xbt_test_unit_t thisunit=xbt_dynar_get_as(thissuite->units,it2_unit,xbt_test_unit_t);
 514               if (!strcmp(thisunit->name,unitname)) {
 515                 thisunit->enabled = enabling;
 516                 break;
 517               }
 518             } /* search relevant unit */
 519             if (it2_unit==xbt_dynar_length(thissuite->units)) {
 520               fprintf(stderr,"Suite '%s' has no unit of name '%s'. Cannot apply the selection\n",
 521                       suitename,unitname);
 522               exit(1);
 523             }
 524           } /* act on childs (either all or one) */
 525
 526           break;/* found the relevant serie. We are happy */
 527         }
 528       } /* search relevant series */
 529       if (it==xbt_dynar_length(_xbt_test_suites)) {
 530         fprintf(stderr,"No suite of name '%s' found. Cannot apply the selection\n",suitename);
 531         exit(1);
 532       }
 533     }
 534
 535   }
 536 }
 537
 538 void xbt_test_dump(char *selection) {
 539   apply_selection(selection);
 540
 541   if (_xbt_test_suites) {
 542     unsigned int it_suite;
 543     xbt_test_suite_t suite;
 544
 545     xbt_dynar_foreach(_xbt_test_suites,it_suite,suite)
 546       xbt_test_suite_dump(suite);
 547   } else {
 548     printf(" No suite defined.");
 549   }
 550 }
 551
 552 int xbt_test_run(char *selection) {
 553   apply_selection(selection);
 554
 555   if (_xbt_test_suites) {
 556     unsigned int it_suite;
 557     xbt_test_suite_t suite;
 558     int first=1;
 559
 560     /* Run all the suites */
 561     xbt_dynar_foreach(_xbt_test_suites,it_suite,suite)
 562       xbt_test_suite_run(suite);
 563
 564     /* Display some more statistics */
 565     fprintf(stderr,"\n\n TOTAL: Suites: %.0f%% ok (%d suites: ",
 566             _xbt_test_nb_suites
 567               ? ((1-(double)_xbt_test_suite_failed/(double)_xbt_test_nb_suites)*100.0)
 568               : 100.0,
 569             _xbt_test_nb_suites);
 570     if (_xbt_test_nb_suites != _xbt_test_suite_failed) {
 571       fprintf(stderr, "%d ok",_xbt_test_nb_suites - _xbt_test_suite_failed);
 572       first = 0;
 573     }
 574     if (_xbt_test_suite_failed) {
 575       fprintf(stderr, "%s%d failed",(first?"":", "),_xbt_test_suite_failed);
 576       first = 0;
 577     }
 578
 579     if (_xbt_test_suite_ignore) {
 580       fprintf(stderr, "%s%d ignored",(first?"":", "),_xbt_test_suite_ignore);
 581       first = 0;
 582     }
 583     fprintf(stderr,")\n        Units:  %.0f%% ok (%d units: ",
 584             _xbt_test_nb_units?((1-(double)_xbt_test_unit_failed/(double)_xbt_test_nb_units)*100.0):100.0,
 585             _xbt_test_nb_units);
 586     first=1;
 587     if (_xbt_test_nb_units != _xbt_test_unit_failed) {
 588       fprintf(stderr, "%s%d ok",(first?"":", "),_xbt_test_nb_units - _xbt_test_unit_failed);
 589       first = 0;
 590     }
 591     if (_xbt_test_unit_failed) {
 592       fprintf(stderr, "%s%d failed",(first?"":", "),_xbt_test_unit_failed);
 593       first = 0;
 594     }
 595     if (_xbt_test_unit_ignore) {
 596       fprintf(stderr, "%s%d ignored",(first?"":", "),_xbt_test_unit_ignore);
 597       first = 0;
 598     }
 599     fprintf(stderr,")\n        Tests:  %.0f%% ok (%d tests: ",
 600             _xbt_test_nb_tests?((1-(double)_xbt_test_test_failed/(double)_xbt_test_nb_tests)*100.0):100.0,
 601             _xbt_test_nb_tests);
 602     first=1;
 603     if (_xbt_test_nb_tests != _xbt_test_test_failed) {
 604       fprintf(stderr, "%s%d ok",(first?"":", "),_xbt_test_nb_tests - _xbt_test_test_failed);
 605       first = 0;
 606     }
 607     if (_xbt_test_test_failed) {
 608       fprintf(stderr, "%s%d failed",(first?"":", "),_xbt_test_test_failed);
 609       first = 0;
 610     }
 611     if (_xbt_test_test_ignore) {
 612       fprintf(stderr, "%s%d ignored",(first?"":", "),_xbt_test_test_ignore);
 613       first = 0;
 614     }
 615     if (_xbt_test_test_expect) {
 616       fprintf(stderr, "%s%d expected to fail",(first?"":", "),_xbt_test_test_expect);
 617     }
 618
 619     fprintf(stderr,")\n");
 620   } else {
 621     fprintf(stderr,"No unit to run!\n");
 622     _xbt_test_unit_failed++;
 623   }
 624   return _xbt_test_unit_failed;
 625 }
 626
 627
 628 /* annotate test case with test */
 629 void _xbt_test_add(const char*file,int line, const char *fmt, ...) {
 630   xbt_test_unit_t unit=_xbt_test_current_unit;
 631   xbt_test_test_t test;
 632   va_list ap;
 633
 634   xbt_assert(unit);
 635   xbt_assert(fmt);
 636
 637   test = xbt_new(struct s_xbt_test_test,1);
 638   va_start(ap, fmt);
 639   vasprintf(&test->title, fmt, ap);
 640   va_end(ap);
 641   test->failed = 0;
 642   test->expected_failure = 0;
 643   test->ignored = 0;
 644   test->file = file;
 645   test->line = line;
 646   test->logs = xbt_dynar_new(sizeof(xbt_test_log_t),NULL);
 647   xbt_dynar_push(unit->tests,&test);
 648   return;
 649 }
 650
 651 /* annotate test case with log message and failure */
 652 void _xbt_test_fail(const char*file,int line,const char *fmt, ...) {
 653   xbt_test_unit_t unit = _xbt_test_current_unit;
 654   xbt_test_test_t test;
 655   xbt_test_log_t log;
 656   va_list ap;
 657
 658   xbt_assert(unit);
 659   xbt_assert(fmt);
 660
 661   xbt_assert1(xbt_dynar_length(_xbt_test_current_unit->tests),
 662               "Test failed even before being declared (broken unit: %s)",
 663               unit->title);
 664
 665   log = xbt_new(struct s_xbt_test_log,1);
 666   va_start(ap, fmt);
 667   vasprintf(&log->text,fmt, ap);
 668   va_end(ap);
 669   log->file = file;
 670   log->line = line;
 671
 672   test = xbt_dynar_getlast_as(unit->tests, xbt_test_test_t);
 673   xbt_dynar_push(test->logs, &log);
 674
 675   test->failed = 1;
 676 }
 677
 678 void xbt_test_exception(xbt_ex_t e) {
 679   _xbt_test_fail(e.file,e.line,"Exception %s raised: %s",xbt_ex_catname(e.category),e.msg);
 680 }
 681
 682 void xbt_test_expect_failure(void) {
 683   xbt_test_test_t test;
 684   xbt_assert1(xbt_dynar_length(_xbt_test_current_unit->tests),
 685               "Cannot expect the failure of a test before declaring it (broken unit: %s)",
 686               _xbt_test_current_unit->title);
 687   test = xbt_dynar_getlast_as(_xbt_test_current_unit->tests,xbt_test_test_t);
 688   test->expected_failure = 1;
 689 }
 690 void xbt_test_skip(void) {
 691   xbt_test_test_t test;
 692
 693   xbt_assert1(xbt_dynar_length(_xbt_test_current_unit->tests),
 694               "Test skiped even before being declared (broken unit: %s)",
 695               _xbt_test_current_unit->title);
 696
 697   test = xbt_dynar_getlast_as(_xbt_test_current_unit->tests,
 698                               xbt_test_test_t);
 699   test->ignored = 1;
 700 }
 701
 702 /* annotate test case with log message only */
 703 void _xbt_test_log(const char*file,int line,const char *fmt, ...) {
 704   xbt_test_unit_t unit=_xbt_test_current_unit;
 705   xbt_test_test_t test;
 706   xbt_test_log_t log;
 707   va_list ap;
 708
 709   xbt_assert(unit);
 710   xbt_assert(fmt);
 711
 712   xbt_assert1(xbt_dynar_length(_xbt_test_current_unit->tests),
 713               "Test logged into even before being declared (broken test unit: %s)",unit->title);
 714
 715   log = xbt_new(struct s_xbt_test_log,1);
 716   va_start(ap, fmt);
 717   vasprintf(&log->text, fmt, ap);
 718   va_end(ap);
 719   log->file = file;
 720   log->line = line;
 721
 722   test = xbt_dynar_getlast_as(unit->tests,xbt_test_test_t);
 723   xbt_dynar_push(test->logs, &log);
 724 }
 725
 726
 727
 728
 729 #ifdef SIMGRID_TEST
 730
 731 XBT_TEST_SUITE("cunit","Testsuite mechanism autotest");
 732
 733 XBT_TEST_UNIT("expect",test_expected_failure,"expected failures") {
 734     xbt_test_add0("Skipped test");
 735     xbt_test_skip();
 736
 737     xbt_test_add2("%s %s","EXPECTED","FAILURE");
 738     xbt_test_expect_failure();
 739     xbt_test_log2("%s %s","Test","log");
 740     xbt_test_fail0("EXPECTED FAILURE");
 741 }
 742
 743 #endif /* SIMGRID_TEST */