src/ex_unit.c

   1 /*******************************/
   2 /* GENERATED FILE, DO NOT EDIT */
   3 /*******************************/
   4
   5 #include "xbt.h"
   6 /*******************************/
   7 /* GENERATED FILE, DO NOT EDIT */
   8 /*******************************/
   9
  10 # 317 "xbt/ex.c"
  11 #include "xbt/ex.h"
  12
  13
  14 XBT_TEST_UNIT("controlflow",test_controlflow, "basic nested control flow") {
  15     xbt_ex_t ex;
  16     volatile int n=1;
  17
  18     xbt_test_add0("basic nested control flow");
  19
  20     TRY {
  21         if (n != 1)
  22             xbt_test_fail1("M1: n=%d (!= 1)", n);
  23         n++;
  24         TRY {
  25             if (n != 2)
  26                 xbt_test_fail1("M2: n=%d (!= 2)", n);
  27             n++;
  28             THROW0(unknown_error,0,"something");
  29         } CATCH (ex) {
  30             if (n != 3)
  31                 xbt_test_fail1("M3: n=%d (!= 3)", n);
  32             n++;
  33             xbt_ex_free(ex);
  34         }
  35         n++;
  36         TRY {
  37             if (n != 5)
  38                 xbt_test_fail1("M2: n=%d (!= 5)", n);
  39             n++;
  40             THROW0(unknown_error,0,"something");
  41         } CATCH (ex) {
  42             if (n != 6)
  43                 xbt_test_fail1("M3: n=%d (!= 6)", n);
  44             n++;
  45             RETHROW;
  46             n++;
  47         }
  48         xbt_test_fail1("MX: n=%d (shouldn't reach this point)", n);
  49     }
  50     CATCH(ex) {
  51         if (n != 7)
  52             xbt_test_fail1("M4: n=%d (!= 7)", n);
  53         n++;
  54         xbt_ex_free(ex);
  55     }
  56     if (n != 8)
  57         xbt_test_fail1("M5: n=%d (!= 8)", n);
  58 }
  59
  60 XBT_TEST_UNIT("value",test_value,"exception value passing") {
  61     xbt_ex_t ex;
  62
  63     TRY {
  64         THROW0(unknown_error, 2, "toto");
  65     } CATCH(ex) {
  66         xbt_test_add0("exception value passing");
  67         if (ex.category != unknown_error)
  68             xbt_test_fail1("category=%d (!= 1)", ex.category);
  69         if (ex.value != 2)
  70             xbt_test_fail1("value=%d (!= 2)", ex.value);
  71         if (strcmp(ex.msg,"toto"))
  72             xbt_test_fail1("message=%s (!= toto)", ex.msg);
  73         xbt_ex_free(ex);
  74     }
  75 }
  76
  77 XBT_TEST_UNIT("variables",test_variables,"variable value preservation") {
  78     xbt_ex_t ex;
  79     int r1, r2;
  80     volatile int v1, v2;
  81
  82     r1 = r2 = v1 = v2 = 1234;
  83     TRY {
  84         r2 = 5678;
  85         v2 = 5678;
  86         THROW0(unknown_error, 0, "toto");
  87     } CATCH(ex) {
  88         xbt_test_add0("variable preservation");
  89         if (r1 != 1234)
  90             xbt_test_fail1("r1=%d (!= 1234)", r1);
  91         if (v1 != 1234)
  92             xbt_test_fail1("v1=%d (!= 1234)", v1);
  93         /* r2 is allowed to be destroyed because not volatile */
  94         if (v2 != 5678)
  95             xbt_test_fail1("v2=%d (!= 5678)", v2);
  96         xbt_ex_free(ex);
  97     }
  98 }
  99
 100 XBT_TEST_UNIT("cleanup",test_cleanup,"cleanup handling") {
 101     xbt_ex_t ex;
 102     volatile int v1;
 103     int c;
 104
 105     xbt_test_add0("cleanup handling");
 106
 107     v1 = 1234;
 108     c = 0;
 109     TRY {
 110         v1 = 5678;
 111         THROW0(1, 2, "blah");
 112     } CLEANUP {
 113         if (v1 != 5678)
 114             xbt_test_fail1("v1 = %d (!= 5678)", v1);
 115         c = 1;
 116     } CATCH(ex) {
 117         if (v1 != 5678)
 118             xbt_test_fail1("v1 = %d (!= 5678)", v1);
 119         if (!(ex.category == 1 && ex.value == 2 && !strcmp(ex.msg,"blah")))
 120             xbt_test_fail0("unexpected exception contents");
 121         xbt_ex_free(ex);
 122     }
 123     if (!c)
 124         xbt_test_fail0("xbt_ex_free not executed");
 125 }
 126
 127
 128 /*
 129  * The following is the example included in the documentation. It's a good
 130  * idea to check its syntax even if we don't try to run it.
 131  * And actually, it allows to put comments in the code despite doxygen.
 132  */
 133 static char *mallocex(int size) {
 134   return NULL;
 135 }
 136 #define SMALLAMOUNT 10
 137 #define TOOBIG 100000000
 138
 139 #if 0 /* this contains syntax errors, actually */
 140 static void bad_example(void) {
 141   struct {char*first;} *globalcontext;
 142   ex_t ex;
 143
 144   /* BAD_EXAMPLE */
 145   TRY {
 146     char *cp1, *cp2, *cp3;
 147
 148     cp1 = mallocex(SMALLAMOUNT);
 149     globalcontext->first = cp1;
 150     cp2 = mallocex(TOOBIG);
 151     cp3 = mallocex(SMALLAMOUNT);
 152     strcpy(cp1, "foo");
 153     strcpy(cp2, "bar");
 154   } CLEANUP {
 155     if (cp3 != NULL) free(cp3);
 156     if (cp2 != NULL) free(cp2);
 157     if (cp1 != NULL) free(cp1);
 158   } CATCH(ex) {
 159     printf("cp3=%s", cp3);
 160     RETHROW;
 161   }
 162   /* end_of_bad_example */
 163 }
 164 #endif
 165 typedef struct {char *first;} global_context_t;
 166
 167 static void good_example(void) {
 168   global_context_t *global_context=malloc(sizeof(global_context_t));
 169   xbt_ex_t ex;
 170
 171   /* GOOD_EXAMPLE */
 172   { /*01*/
 173     char * volatile /*03*/ cp1 = NULL /*02*/;
 174     char * volatile /*03*/ cp2 = NULL /*02*/;
 175     char * volatile /*03*/ cp3 = NULL /*02*/;
 176     TRY {
 177       cp1 = mallocex(SMALLAMOUNT);
 178       global_context->first = cp1;
 179       cp1 = NULL /*05 give away*/;
 180       cp2 = mallocex(TOOBIG);
 181       cp3 = mallocex(SMALLAMOUNT);
 182       strcpy(cp1, "foo");
 183       strcpy(cp2, "bar");
 184     } CLEANUP { /*04*/
 185       printf("cp3=%s", cp3 == NULL /*02*/ ? "" : cp3);
 186       if (cp3 != NULL)
 187         free(cp3);
 188       if (cp2 != NULL)
 189         free(cp2);
 190       /*05 cp1 was given away */
 191     } CATCH(ex) {
 192       /*05 global context untouched */
 193       RETHROW;
 194     }
 195   }
 196   /* end_of_good_example */
 197 }
 198 /*******************************/
 199 /* GENERATED FILE, DO NOT EDIT */
 200 /*******************************/
 201