Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
7d584ebb269aced5197dac558557d44b2c984619
[simgrid.git] / 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 "gras_config.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     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     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   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     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   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[i]='\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",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           xbt_dynar_foreach(test->logs,it_log,log) {
312             file = (log->file != NULL ? log->file : file);
313             line = (log->line != 0    ? log->line : line);
314             fprintf(stderr, "             %s:%d: %s\n", 
315                     file, line,log->text);
316             
317           }
318         }
319         fprintf(stderr, "    Summary: %d of %d tests failed",unit->test_failed, unit->nb_tests);
320         if (unit->test_ignore) {
321           fprintf(stderr," (%d tests ignored)\n",unit->test_ignore);
322         } else {
323           fprintf(stderr,"\n");
324         }
325         
326       } else if (!unit->enabled) {
327         fprintf(stderr, " disabled\n"); /* no test were run */
328       } else if (unit->nb_tests) {
329         fprintf(stderr, "...... ok\n"); /* successful */
330       } else  {
331         fprintf(stderr, ".... skip\n"); /* no test were run */
332       }
333       
334       /* Accumulate test counts into the suite */
335       suite->nb_tests      += unit->nb_tests;
336       suite->test_failed   += unit->test_failed;
337       suite->test_ignore   += unit->test_ignore;
338       suite->test_expect   += unit->test_expect;
339       
340       _xbt_test_nb_tests      += unit->nb_tests;
341       _xbt_test_test_failed   += unit->test_failed;
342       _xbt_test_test_ignore   += unit->test_ignore;
343       _xbt_test_test_expect   += unit->test_expect;  
344       
345       /* What's the conclusion of this test anyway? */
346       if (unit->nb_tests) {
347         suite->nb_units++;
348         if (unit->test_failed)
349           suite->unit_failed++;
350       } else if (!unit->enabled) {
351         suite->unit_disabled++;
352       } else {
353         suite->unit_ignore++;
354       }
355     }
356   }
357   _xbt_test_nb_units      += suite->nb_units;
358   _xbt_test_unit_failed   += suite->unit_failed;
359   _xbt_test_unit_ignore   += suite->unit_ignore;
360   _xbt_test_unit_disabled += suite->unit_disabled;
361
362   if (suite->nb_units) {
363     _xbt_test_nb_suites++;
364     if (suite->test_failed)
365       _xbt_test_suite_failed++;
366   } else if (!suite->enabled) {
367     _xbt_test_suite_disabled++;
368   } else {
369     _xbt_test_suite_ignore++;
370   }
371
372   
373   /* print test suite summary */
374   if (suite->enabled) {
375
376     fprintf(stderr,
377             " =====================================================================%s\n",
378             (suite->nb_units ? (suite->unit_failed   ? "== FAILED":"====== OK")
379                              : (suite->unit_disabled ? " DISABLED":"==== SKIP")));
380     fprintf(stderr, " Summary: Units: %.0f%% ok (%d units: ", 
381             suite->nb_units?((1-(double)suite->unit_failed/(double)suite->nb_units)*100.0):100.0,
382             suite->nb_units);
383     
384     if (suite->nb_units != suite->unit_failed) {
385       fprintf(stderr, "%s%d ok",(first?"":", "),suite->nb_units - suite->unit_failed);
386       first = 0;
387     }
388     if (suite->unit_failed) {
389       fprintf(stderr, "%s%d failed",(first?"":", "),suite->unit_failed);
390       first = 0;
391     }
392     if (suite->unit_ignore) {
393       fprintf(stderr, "%s%d ignored",(first?"":", "),suite->unit_ignore);
394       first = 0;
395     }
396     if (suite->unit_disabled) {
397       fprintf(stderr, "%s%d disabled",(first?"":", "),suite->unit_disabled);
398       first = 0;
399     }
400     fprintf(stderr,")\n          Tests: %.0f%% ok (%d tests: ",
401             suite->nb_tests?((1-(double)suite->test_failed/(double)suite->nb_tests)*100.0):100.0,
402             suite->nb_tests);
403
404     first=1;
405     if (suite->nb_tests != suite->test_failed) {
406       fprintf(stderr, "%s%d ok",(first?"":", "),suite->nb_tests - suite->test_failed);
407       first = 0;
408     }
409     if (suite->test_failed) {
410       fprintf(stderr, "%s%d failed",(first?"":", "),suite->test_failed);
411       first = 0;
412     }
413     if (suite->test_ignore) {
414       fprintf(stderr, "%s%d ignored",(first?"":"; "),suite->test_ignore);
415       first = 0;
416     }
417     if (suite->test_expect) {
418       fprintf(stderr, "%s%d expected to fail",(first?"":"; "),suite->test_expect);
419       first = 0;
420     }
421     fprintf(stderr,")\n");
422   }
423   return suite->unit_failed;
424 }
425
426 static void apply_selection(char *selection) {
427   /* for the parsing */
428   char *sel=selection;
429   char *p;
430   int done = 0;
431   char dir[1024]; /* the directive */
432   /* iterators */
433   int it_suite;
434   xbt_test_suite_t suite;
435   xbt_test_unit_t unit;
436   int it_unit;
437
438   if (!selection || selection[0] == '\0')
439     return;
440
441   /*printf("Test selection: %s\n", selection);*/
442
443   /* First apply the selection */
444   while (!done) {
445     int enabling = 1;
446
447     p=strchr(sel,',');
448     if (p) {
449       strncpy(dir,sel,p-sel);
450       dir[p-sel]='\0';
451       sel=p+1;
452     } else {
453       strcpy(dir, sel);
454       done=1;
455     }
456     
457     if (dir[0] == '-') {
458       enabling = 0;
459       memmove(dir,dir+1,strlen(dir));
460     }
461
462
463     char suitename[512],unitname[512];
464     p =strchr(dir,':');
465     if (p) {
466       strcpy(unitname,p+1); 
467       strncpy(suitename,dir,p-dir);
468       suitename[p-dir]='\0';
469     } else {
470       strcpy(suitename,dir);
471       unitname[0] = '\0';
472     }
473     /*fprintf(stderr,"Seen %s (%s; suite=%s; unit=%s)\n",
474       dir,enabling?"enabling":"disabling", suitename, unitname);*/
475
476     /* Deal with the specific case of 'all' pseudo serie */
477     if (!strcmp("all",suitename)) {
478       if (unitname[0]!='\0') {
479         fprintf(stderr,"The 'all' pseudo-suite does not accept any unit specification\n");
480         exit(1);
481       }
482
483       xbt_dynar_foreach(_xbt_test_suites,it_suite,suite) {
484         xbt_dynar_foreach(suite->units,it_unit,unit) {
485           unit->enabled = enabling;
486         }
487         suite->enabled = enabling;
488       }
489     } else {
490       int it;
491       for (it=0; it<xbt_dynar_length(_xbt_test_suites); it++) {
492         xbt_test_suite_t thissuite=xbt_dynar_get_as(_xbt_test_suites,it,xbt_test_suite_t);
493         if (!strcmp(suitename,thissuite->name)) {
494           /* Do not disable the whole suite when we just want to disable a child */
495           if (enabling || (unitname[0]=='\0'))
496             thissuite->enabled = enabling;
497
498           if (unitname[0]=='\0') {
499             xbt_dynar_foreach(thissuite->units,it_unit,unit){
500               unit->enabled = enabling;
501             }
502           } else { /* act on one child only */
503             int it2_unit;
504             /* search it, first (we won't reuse it for external loop which gets broken) */
505             for (it2_unit=0; it2_unit<xbt_dynar_length(thissuite->units); it2_unit++) {
506               xbt_test_unit_t thisunit=xbt_dynar_get_as(thissuite->units,it2_unit,xbt_test_unit_t);
507               if (!strcmp(thisunit->name,unitname)) {
508                 thisunit->enabled = enabling;
509                 break;
510               }
511             } /* search relevant unit */
512             if (it2_unit==xbt_dynar_length(thissuite->units)) {
513               fprintf(stderr,"Suite '%s' has no unit of name '%s'. Cannot apply the selection\n",
514                       suitename,unitname);
515               exit(1);
516             }
517           } /* act on childs (either all or one) */
518
519           break;/* found the relevant serie. We are happy */
520         }
521       } /* search relevant series */
522       if (it==xbt_dynar_length(_xbt_test_suites)) {
523         fprintf(stderr,"No suite of name '%s' found. Cannot apply the selection\n",suitename);
524         exit(1);
525       }
526     }
527
528   }
529 }
530
531 void xbt_test_dump(char *selection) {
532   apply_selection(selection);
533
534   if (_xbt_test_suites) {
535     int it_suite;
536     xbt_test_suite_t suite;
537
538     xbt_dynar_foreach(_xbt_test_suites,it_suite,suite) 
539       xbt_test_suite_dump(suite);
540   } else {
541     printf(" No suite defined.");
542   }
543 }
544
545 int xbt_test_run(char *selection) {
546   apply_selection(selection);
547
548   if (_xbt_test_suites) {
549     int it_suite;
550     xbt_test_suite_t suite;
551     int first=1;
552     
553     /* Run all the suites */
554     xbt_dynar_foreach(_xbt_test_suites,it_suite,suite) 
555       xbt_test_suite_run(suite);
556
557     /* Display some more statistics */
558     fprintf(stderr,"\n\n TOTAL: Suites: %.0f%% ok (%d suites: ",
559             _xbt_test_nb_suites
560               ? ((1-(double)_xbt_test_suite_failed/(double)_xbt_test_nb_suites)*100.0)
561               : 100.0,
562             _xbt_test_nb_suites);
563     if (_xbt_test_nb_suites != _xbt_test_suite_failed) {
564       fprintf(stderr, "%d ok",_xbt_test_nb_suites - _xbt_test_suite_failed);
565       first = 0;
566     }
567     if (_xbt_test_suite_failed) {
568       fprintf(stderr, "%s%d failed",(first?"":", "),_xbt_test_suite_failed);
569       first = 0;
570     }
571     
572     if (_xbt_test_suite_ignore) {
573       fprintf(stderr, "%s%d ignored",(first?"":", "),_xbt_test_suite_ignore);
574       first = 0;
575     }
576     fprintf(stderr,")\n        Units:  %.0f%% ok (%d units: ",
577             _xbt_test_nb_units?((1-(double)_xbt_test_unit_failed/(double)_xbt_test_nb_units)*100.0):100.0,
578             _xbt_test_nb_units);
579     first=1;
580     if (_xbt_test_nb_units != _xbt_test_unit_failed) {
581       fprintf(stderr, "%s%d ok",(first?"":", "),_xbt_test_nb_units - _xbt_test_unit_failed);
582       first = 0;
583     }
584     if (_xbt_test_unit_failed) {
585       fprintf(stderr, "%s%d failed",(first?"":", "),_xbt_test_unit_failed);
586       first = 0;
587     }
588     if (_xbt_test_unit_ignore) {
589       fprintf(stderr, "%s%d ignored",(first?"":", "),_xbt_test_unit_ignore);
590       first = 0;
591     }
592     fprintf(stderr,")\n        Tests:  %.0f%% ok (%d tests: ",
593             _xbt_test_nb_tests?((1-(double)_xbt_test_test_failed/(double)_xbt_test_nb_tests)*100.0):100.0,
594             _xbt_test_nb_tests);
595     first=1;
596     if (_xbt_test_nb_tests != _xbt_test_test_failed) {
597       fprintf(stderr, "%s%d ok",(first?"":", "),_xbt_test_nb_tests - _xbt_test_test_failed);
598       first = 0;
599     }
600     if (_xbt_test_test_failed) {
601       fprintf(stderr, "%s%d failed",(first?"":", "),_xbt_test_test_failed);
602       first = 0;
603     }
604     if (_xbt_test_test_ignore) {
605       fprintf(stderr, "%s%d ignored",(first?"":", "),_xbt_test_test_ignore);
606       first = 0;
607     }
608     if (_xbt_test_test_expect) {
609       fprintf(stderr, "%s%d expected to fail",(first?"":", "),_xbt_test_test_expect);
610     }
611     
612     fprintf(stderr,")\n");
613   } else {
614     fprintf(stderr,"No unit to run!\n");
615     _xbt_test_unit_failed++;
616   }
617   return _xbt_test_unit_failed;
618 }
619
620
621 /* annotate test case with test */
622 void _xbt_test_add(const char*file,int line, const char *fmt, ...) {
623   xbt_test_unit_t unit=_xbt_test_current_unit;
624   xbt_test_test_t test;
625   va_list ap;
626   
627   xbt_assert(unit);
628   xbt_assert(fmt);
629
630   test = xbt_new(struct s_xbt_test_test,1);
631   va_start(ap, fmt);
632   vasprintf(&test->title, fmt, ap);
633   va_end(ap);
634   test->failed = 0;
635   test->expected_failure = 0;
636   test->ignored = 0;
637   test->file = file;
638   test->line = line;
639   test->logs = xbt_dynar_new(sizeof(xbt_test_log_t),NULL);
640   xbt_dynar_push(unit->tests,&test);
641   return;
642 }
643
644 /* annotate test case with log message and failure */
645 void _xbt_test_fail(const char*file,int line,const char *fmt, ...) {
646   xbt_test_unit_t unit = _xbt_test_current_unit;
647   xbt_test_test_t test;
648   xbt_test_log_t log;
649   va_list ap;
650   
651   xbt_assert(unit);
652   xbt_assert(fmt);
653
654   xbt_assert1(xbt_dynar_length(_xbt_test_current_unit->tests),
655               "Test failed even before being declared (broken unit: %s)",
656               unit->title);
657
658   log = xbt_new(struct s_xbt_test_log,1);
659   va_start(ap, fmt);
660   vasprintf(&log->text,fmt, ap);
661   va_end(ap);
662   log->file = file;
663   log->line = line;
664
665   test = xbt_dynar_getlast_as(unit->tests, xbt_test_test_t);
666   xbt_dynar_push(test->logs, &log);
667
668   test->failed = 1;
669 }
670
671 void xbt_test_exception(xbt_ex_t e) {
672   _xbt_test_fail(e.file,e.line,"Exception %s raised: %s",xbt_ex_catname(e.category),e.msg);
673 }
674
675 void xbt_test_expect_failure(void) {
676   xbt_test_test_t test;
677   xbt_assert1(xbt_dynar_length(_xbt_test_current_unit->tests),
678               "Cannot expect the failure of a test before declaring it (broken unit: %s)",
679               _xbt_test_current_unit->title);
680   test = xbt_dynar_getlast_as(_xbt_test_current_unit->tests,xbt_test_test_t);
681   test->expected_failure = 1;
682 }
683 void xbt_test_skip(void) {
684   xbt_test_test_t test;
685
686   xbt_assert1(xbt_dynar_length(_xbt_test_current_unit->tests),
687               "Test skiped even before being declared (broken unit: %s)",
688               _xbt_test_current_unit->title);
689
690   test = xbt_dynar_getlast_as(_xbt_test_current_unit->tests,
691                               xbt_test_test_t);
692   test->ignored = 1;
693 }
694
695 /* annotate test case with log message only */
696 void _xbt_test_log(const char*file,int line,const char *fmt, ...) {
697   xbt_test_unit_t unit=_xbt_test_current_unit;
698   xbt_test_test_t test;
699   xbt_test_log_t log;
700   va_list ap;
701
702   xbt_assert(unit);
703   xbt_assert(fmt);
704
705   xbt_assert1(xbt_dynar_length(_xbt_test_current_unit->tests),
706               "Test logged into even before being declared (broken test unit: %s)",unit->title);
707
708   log = xbt_new(struct s_xbt_test_log,1);
709   va_start(ap, fmt);
710   vasprintf(&log->text, fmt, ap);
711   va_end(ap);
712   log->file = file;
713   log->line = line;
714
715   test = xbt_dynar_getlast_as(unit->tests,xbt_test_test_t);
716   xbt_dynar_push(test->logs, &log);
717 }
718
719
720
721
722 #ifdef SIMGRID_TEST
723
724 XBT_TEST_SUITE("cunit","Testsuite mechanism autotest");
725
726 XBT_TEST_UNIT("expect",test_expected_failure,"expected failures") {
727     xbt_test_add0("Skipped test");
728     xbt_test_skip(); 
729
730     xbt_test_add2("%s %s","EXPECTED","FAILURE");
731     xbt_test_expect_failure();
732     xbt_test_log2("%s %s","Test","log");
733     xbt_test_fail0("EXPECTED FAILURE");
734 }
735
736 #endif /* SIMGRID_TEST */