Logo AND Algorithmique Numérique Distribuée

Public GIT Repository
This change allow to avoid the Visual C++ compiler Warning that occur when you try...
[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 "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     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[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",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   char suitename[512];
439   char unitname[512];
440
441   if (!selection || selection[0] == '\0')
442     return;
443
444   /*printf("Test selection: %s\n", selection);*/
445
446   /* First apply the selection */
447   while (!done) {
448     int enabling = 1;
449
450     p=strchr(sel,',');
451     if (p) {
452       strncpy(dir,sel,p-sel);
453       dir[p-sel]='\0';
454       sel=p+1;
455     } else {
456       strcpy(dir, sel);
457       done=1;
458     }
459     
460     if (dir[0] == '-') {
461       enabling = 0;
462       memmove(dir,dir+1,strlen(dir));
463     }
464     if (dir[0] == '+') {
465       enabling = 1;
466       memmove(dir,dir+1,strlen(dir));
467     }
468
469     p =strchr(dir,':');
470     if (p) {
471       strcpy(unitname,p+1); 
472       strncpy(suitename,dir,p-dir);
473       suitename[p-dir]='\0';
474     } else {
475       strcpy(suitename,dir);
476       unitname[0] = '\0';
477     }
478     /*fprintf(stderr,"Seen %s (%s; suite=%s; unit=%s)\n",
479       dir,enabling?"enabling":"disabling", suitename, unitname);*/
480
481     /* Deal with the specific case of 'all' pseudo serie */
482     if (!strcmp("all",suitename)) {
483       if (unitname[0]!='\0') {
484         fprintf(stderr,"The 'all' pseudo-suite does not accept any unit specification\n");
485         exit(1);
486       }
487
488       xbt_dynar_foreach(_xbt_test_suites,it_suite,suite) {
489         xbt_dynar_foreach(suite->units,it_unit,unit) {
490           unit->enabled = enabling;
491         }
492         suite->enabled = enabling;
493       }
494     } else {
495       int it;
496       for (it=0; it< (int)xbt_dynar_length(_xbt_test_suites); it++) {
497         xbt_test_suite_t thissuite=xbt_dynar_get_as(_xbt_test_suites,it,xbt_test_suite_t);
498         if (!strcmp(suitename,thissuite->name)) {
499           /* Do not disable the whole suite when we just want to disable a child */
500           if (enabling || (unitname[0]=='\0'))
501             thissuite->enabled = enabling;
502
503           if (unitname[0]=='\0') {
504             xbt_dynar_foreach(thissuite->units,it_unit,unit){
505               unit->enabled = enabling;
506             }
507           } else { /* act on one child only */
508             int it2_unit;
509             /* search it, first (we won't reuse it for external loop which gets broken) */
510             for (it2_unit=0; it2_unit< (int)xbt_dynar_length(thissuite->units); it2_unit++) {
511               xbt_test_unit_t thisunit=xbt_dynar_get_as(thissuite->units,it2_unit,xbt_test_unit_t);
512               if (!strcmp(thisunit->name,unitname)) {
513                 thisunit->enabled = enabling;
514                 break;
515               }
516             } /* search relevant unit */
517             if (it2_unit==xbt_dynar_length(thissuite->units)) {
518               fprintf(stderr,"Suite '%s' has no unit of name '%s'. Cannot apply the selection\n",
519                       suitename,unitname);
520               exit(1);
521             }
522           } /* act on childs (either all or one) */
523
524           break;/* found the relevant serie. We are happy */
525         }
526       } /* search relevant series */
527       if (it==xbt_dynar_length(_xbt_test_suites)) {
528         fprintf(stderr,"No suite of name '%s' found. Cannot apply the selection\n",suitename);
529         exit(1);
530       }
531     }
532
533   }
534 }
535
536 void xbt_test_dump(char *selection) {
537   apply_selection(selection);
538
539   if (_xbt_test_suites) {
540     int it_suite;
541     xbt_test_suite_t suite;
542
543     xbt_dynar_foreach(_xbt_test_suites,it_suite,suite) 
544       xbt_test_suite_dump(suite);
545   } else {
546     printf(" No suite defined.");
547   }
548 }
549
550 int xbt_test_run(char *selection) {
551   apply_selection(selection);
552
553   if (_xbt_test_suites) {
554     int it_suite;
555     xbt_test_suite_t suite;
556     int first=1;
557     
558     /* Run all the suites */
559     xbt_dynar_foreach(_xbt_test_suites,it_suite,suite) 
560       xbt_test_suite_run(suite);
561
562     /* Display some more statistics */
563     fprintf(stderr,"\n\n TOTAL: Suites: %.0f%% ok (%d suites: ",
564             _xbt_test_nb_suites
565               ? ((1-(double)_xbt_test_suite_failed/(double)_xbt_test_nb_suites)*100.0)
566               : 100.0,
567             _xbt_test_nb_suites);
568     if (_xbt_test_nb_suites != _xbt_test_suite_failed) {
569       fprintf(stderr, "%d ok",_xbt_test_nb_suites - _xbt_test_suite_failed);
570       first = 0;
571     }
572     if (_xbt_test_suite_failed) {
573       fprintf(stderr, "%s%d failed",(first?"":", "),_xbt_test_suite_failed);
574       first = 0;
575     }
576     
577     if (_xbt_test_suite_ignore) {
578       fprintf(stderr, "%s%d ignored",(first?"":", "),_xbt_test_suite_ignore);
579       first = 0;
580     }
581     fprintf(stderr,")\n        Units:  %.0f%% ok (%d units: ",
582             _xbt_test_nb_units?((1-(double)_xbt_test_unit_failed/(double)_xbt_test_nb_units)*100.0):100.0,
583             _xbt_test_nb_units);
584     first=1;
585     if (_xbt_test_nb_units != _xbt_test_unit_failed) {
586       fprintf(stderr, "%s%d ok",(first?"":", "),_xbt_test_nb_units - _xbt_test_unit_failed);
587       first = 0;
588     }
589     if (_xbt_test_unit_failed) {
590       fprintf(stderr, "%s%d failed",(first?"":", "),_xbt_test_unit_failed);
591       first = 0;
592     }
593     if (_xbt_test_unit_ignore) {
594       fprintf(stderr, "%s%d ignored",(first?"":", "),_xbt_test_unit_ignore);
595       first = 0;
596     }
597     fprintf(stderr,")\n        Tests:  %.0f%% ok (%d tests: ",
598             _xbt_test_nb_tests?((1-(double)_xbt_test_test_failed/(double)_xbt_test_nb_tests)*100.0):100.0,
599             _xbt_test_nb_tests);
600     first=1;
601     if (_xbt_test_nb_tests != _xbt_test_test_failed) {
602       fprintf(stderr, "%s%d ok",(first?"":", "),_xbt_test_nb_tests - _xbt_test_test_failed);
603       first = 0;
604     }
605     if (_xbt_test_test_failed) {
606       fprintf(stderr, "%s%d failed",(first?"":", "),_xbt_test_test_failed);
607       first = 0;
608     }
609     if (_xbt_test_test_ignore) {
610       fprintf(stderr, "%s%d ignored",(first?"":", "),_xbt_test_test_ignore);
611       first = 0;
612     }
613     if (_xbt_test_test_expect) {
614       fprintf(stderr, "%s%d expected to fail",(first?"":", "),_xbt_test_test_expect);
615     }
616     
617     fprintf(stderr,")\n");
618   } else {
619     fprintf(stderr,"No unit to run!\n");
620     _xbt_test_unit_failed++;
621   }
622   return _xbt_test_unit_failed;
623 }
624
625
626 /* annotate test case with test */
627 void _xbt_test_add(const char*file,int line, const char *fmt, ...) {
628   xbt_test_unit_t unit=_xbt_test_current_unit;
629   xbt_test_test_t test;
630   va_list ap;
631   
632   xbt_assert(unit);
633   xbt_assert(fmt);
634
635   test = xbt_new(struct s_xbt_test_test,1);
636   va_start(ap, fmt);
637   vasprintf(&test->title, fmt, ap);
638   va_end(ap);
639   test->failed = 0;
640   test->expected_failure = 0;
641   test->ignored = 0;
642   test->file = file;
643   test->line = line;
644   test->logs = xbt_dynar_new(sizeof(xbt_test_log_t),NULL);
645   xbt_dynar_push(unit->tests,&test);
646   return;
647 }
648
649 /* annotate test case with log message and failure */
650 void _xbt_test_fail(const char*file,int line,const char *fmt, ...) {
651   xbt_test_unit_t unit = _xbt_test_current_unit;
652   xbt_test_test_t test;
653   xbt_test_log_t log;
654   va_list ap;
655   
656   xbt_assert(unit);
657   xbt_assert(fmt);
658
659   xbt_assert1(xbt_dynar_length(_xbt_test_current_unit->tests),
660               "Test failed even before being declared (broken unit: %s)",
661               unit->title);
662
663   log = xbt_new(struct s_xbt_test_log,1);
664   va_start(ap, fmt);
665   vasprintf(&log->text,fmt, ap);
666   va_end(ap);
667   log->file = file;
668   log->line = line;
669
670   test = xbt_dynar_getlast_as(unit->tests, xbt_test_test_t);
671   xbt_dynar_push(test->logs, &log);
672
673   test->failed = 1;
674 }
675
676 void xbt_test_exception(xbt_ex_t e) {
677   _xbt_test_fail(e.file,e.line,"Exception %s raised: %s",xbt_ex_catname(e.category),e.msg);
678 }
679
680 void xbt_test_expect_failure(void) {
681   xbt_test_test_t test;
682   xbt_assert1(xbt_dynar_length(_xbt_test_current_unit->tests),
683               "Cannot expect the failure of a test before declaring it (broken unit: %s)",
684               _xbt_test_current_unit->title);
685   test = xbt_dynar_getlast_as(_xbt_test_current_unit->tests,xbt_test_test_t);
686   test->expected_failure = 1;
687 }
688 void xbt_test_skip(void) {
689   xbt_test_test_t test;
690
691   xbt_assert1(xbt_dynar_length(_xbt_test_current_unit->tests),
692               "Test skiped even before being declared (broken unit: %s)",
693               _xbt_test_current_unit->title);
694
695   test = xbt_dynar_getlast_as(_xbt_test_current_unit->tests,
696                               xbt_test_test_t);
697   test->ignored = 1;
698 }
699
700 /* annotate test case with log message only */
701 void _xbt_test_log(const char*file,int line,const char *fmt, ...) {
702   xbt_test_unit_t unit=_xbt_test_current_unit;
703   xbt_test_test_t test;
704   xbt_test_log_t log;
705   va_list ap;
706
707   xbt_assert(unit);
708   xbt_assert(fmt);
709
710   xbt_assert1(xbt_dynar_length(_xbt_test_current_unit->tests),
711               "Test logged into even before being declared (broken test unit: %s)",unit->title);
712
713   log = xbt_new(struct s_xbt_test_log,1);
714   va_start(ap, fmt);
715   vasprintf(&log->text, fmt, ap);
716   va_end(ap);
717   log->file = file;
718   log->line = line;
719
720   test = xbt_dynar_getlast_as(unit->tests,xbt_test_test_t);
721   xbt_dynar_push(test->logs, &log);
722 }
723
724
725
726
727 #ifdef SIMGRID_TEST
728
729 XBT_TEST_SUITE("cunit","Testsuite mechanism autotest");
730
731 XBT_TEST_UNIT("expect",test_expected_failure,"expected failures") {
732     xbt_test_add0("Skipped test");
733     xbt_test_skip(); 
734
735     xbt_test_add2("%s %s","EXPECTED","FAILURE");
736     xbt_test_expect_failure();
737     xbt_test_log2("%s %s","Test","log");
738     xbt_test_fail0("EXPECTED FAILURE");
739 }
740
741 #endif /* SIMGRID_TEST */