src/dynar_unit.c

   1 /*******************************/
   2 /* GENERATED FILE, DO NOT EDIT */
   3 /*******************************/
   4
   5 #include <stdio.h>
   6 #include "xbt.h"
   7 /*******************************/
   8 /* GENERATED FILE, DO NOT EDIT */
   9 /*******************************/
  10
  11 #line 716 "xbt/dynar.c"
  12
  13 #define NB_ELEM 5000
  14
  15 XBT_LOG_EXTERNAL_CATEGORY(xbt_dyn);
  16 XBT_LOG_NEW_DEFAULT_SUBCATEGORY(xbt_dyn, xbt, "Dynamic arrays");
  17
  18 XBT_TEST_UNIT("int", test_dynar_int, "Dynars of integers")
  19 {
  20   /* Vars_decl [doxygen cruft] */
  21   xbt_dynar_t d;
  22   int i, cpt;
  23   unsigned int cursor;
  24   int *iptr;
  25
  26   xbt_test_add0("==== Traverse the empty dynar");
  27   d = xbt_dynar_new(sizeof(int), NULL);
  28   xbt_dynar_foreach(d, cursor, i) {
  29     xbt_assert0(0, "Damnit, there is something in the empty dynar");
  30   }
  31   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
  32   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
  33                                  /* in your code is naturally the way to go outside a regression test */
  34
  35   xbt_test_add1
  36     ("==== Push %d int, set them again 3 times, traverse them, shift them",
  37      NB_ELEM);
  38   /* Populate_ints [doxygen cruft] */
  39   /* 1. Populate the dynar */
  40   d = xbt_dynar_new(sizeof(int), NULL);
  41   for (cpt = 0; cpt < NB_ELEM; cpt++) {
  42     xbt_dynar_push_as(d, int, cpt);     /* This is faster (and possible only with scalars) */
  43     /* xbt_dynar_push(d,&cpt);       This would also work */
  44     xbt_test_log2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
  45   }
  46
  47   /* 2. Traverse manually the dynar */
  48   for (cursor = 0; cursor < NB_ELEM; cursor++) {
  49     iptr = xbt_dynar_get_ptr(d, cursor);
  50     xbt_test_assert2(cursor == *iptr,
  51                      "The retrieved value is not the same than the injected one (%d!=%d)",
  52                      cursor, cpt);
  53   }
  54
  55   /* 3. Traverse the dynar using the neat macro to that extend */
  56   xbt_dynar_foreach(d, cursor, cpt) {
  57     xbt_test_assert2(cursor == cpt,
  58                      "The retrieved value is not the same than the injected one (%d!=%d)",
  59                      cursor, cpt);
  60   }
  61   /* end_of_traversal */
  62
  63   for (cpt = 0; cpt < NB_ELEM; cpt++)
  64     *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
  65
  66   for (cpt = 0; cpt < NB_ELEM; cpt++)
  67     *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
  68   /*     xbt_dynar_set(d,cpt,&cpt); */
  69
  70   for (cpt = 0; cpt < NB_ELEM; cpt++)
  71     *(int *) xbt_dynar_get_ptr(d, cpt) = cpt;
  72
  73   cpt = 0;
  74   xbt_dynar_foreach(d, cursor, i) {
  75     xbt_test_assert2(i == cpt,
  76                      "The retrieved value is not the same than the injected one (%d!=%d)",
  77                      i, cpt);
  78     cpt++;
  79   }
  80   xbt_test_assert2(cpt == NB_ELEM,
  81                    "Cannot retrieve my %d values. Last got one is %d",
  82                    NB_ELEM, cpt);
  83
  84   /* shifting [doxygen cruft] */
  85   /* 4. Shift all the values */
  86   for (cpt = 0; cpt < NB_ELEM; cpt++) {
  87     xbt_dynar_shift(d, &i);
  88     xbt_test_assert2(i == cpt,
  89                      "The retrieved value is not the same than the injected one (%d!=%d)",
  90                      i, cpt);
  91     xbt_test_log2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
  92   }
  93
  94   /* 5. Free the resources */
  95   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
  96   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
  97                                  /* in your code is naturally the way to go outside a regression test */
  98
  99   xbt_test_add1("==== Unshift/pop %d int", NB_ELEM);
 100   d = xbt_dynar_new(sizeof(int), NULL);
 101   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 102     xbt_dynar_unshift(d, &cpt);
 103     DEBUG2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
 104   }
 105   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 106     i = xbt_dynar_pop_as(d, int);
 107     xbt_test_assert2(i == cpt,
 108                      "The retrieved value is not the same than the injected one (%d!=%d)",
 109                      i, cpt);
 110     xbt_test_log2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
 111   }
 112   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
 113   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
 114                                  /* in your code is naturally the way to go outside a regression test */
 115
 116
 117   xbt_test_add1
 118     ("==== Push %d int, insert 1000 int in the middle, shift everything",
 119      NB_ELEM);
 120   d = xbt_dynar_new(sizeof(int), NULL);
 121   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 122     xbt_dynar_push_as(d, int, cpt);
 123     DEBUG2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
 124   }
 125   for (cpt = 0; cpt < 1000; cpt++) {
 126     xbt_dynar_insert_at_as(d, 2500, int, cpt);
 127     DEBUG2("Push %d, length=%lu", cpt, xbt_dynar_length(d));
 128   }
 129
 130   for (cpt = 0; cpt < 2500; cpt++) {
 131     xbt_dynar_shift(d, &i);
 132     xbt_test_assert2(i == cpt,
 133                      "The retrieved value is not the same than the injected one at the begining (%d!=%d)",
 134                      i, cpt);
 135     DEBUG2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
 136   }
 137   for (cpt = 999; cpt >= 0; cpt--) {
 138     xbt_dynar_shift(d, &i);
 139     xbt_test_assert2(i == cpt,
 140                      "The retrieved value is not the same than the injected one in the middle (%d!=%d)",
 141                      i, cpt);
 142   }
 143   for (cpt = 2500; cpt < NB_ELEM; cpt++) {
 144     xbt_dynar_shift(d, &i);
 145     xbt_test_assert2(i == cpt,
 146                      "The retrieved value is not the same than the injected one at the end (%d!=%d)",
 147                      i, cpt);
 148   }
 149   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
 150   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
 151                                  /* in your code is naturally the way to go outside a regression test */
 152
 153   xbt_test_add1("==== Push %d int, remove 2000-4000. free the rest", NB_ELEM);
 154   d = xbt_dynar_new(sizeof(int), NULL);
 155   for (cpt = 0; cpt < NB_ELEM; cpt++)
 156     xbt_dynar_push_as(d, int, cpt);
 157
 158   for (cpt = 2000; cpt < 4000; cpt++) {
 159     xbt_dynar_remove_at(d, 2000, &i);
 160     xbt_test_assert2(i == cpt,
 161                      "Remove a bad value. Got %d, expected %d", i, cpt);
 162     DEBUG2("remove %d, length=%lu", cpt, xbt_dynar_length(d));
 163   }
 164   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
 165   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
 166                                  /* in your code is naturally the way to go outside a regression test */
 167 }
 168
 169 /*******************************************************************************/
 170 /*******************************************************************************/
 171 /*******************************************************************************/
 172 XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
 173 {
 174   xbt_dynar_t d;
 175   int cpt;
 176   unsigned int cursor;
 177   double d1, d2;
 178
 179   xbt_test_add0("==== Traverse the empty dynar");
 180   d = xbt_dynar_new(sizeof(int), NULL);
 181   xbt_dynar_foreach(d, cursor, cpt) {
 182     xbt_test_assert0(FALSE, "Damnit, there is something in the empty dynar");
 183   }
 184   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
 185   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
 186                                  /* in your code is naturally the way to go outside a regression test */
 187
 188   xbt_test_add0("==== Push/shift 5000 doubles");
 189   d = xbt_dynar_new(sizeof(double), NULL);
 190   for (cpt = 0; cpt < 5000; cpt++) {
 191     d1 = (double) cpt;
 192     xbt_dynar_push(d, &d1);
 193   }
 194   xbt_dynar_foreach(d, cursor, d2) {
 195     d1 = (double) cursor;
 196     xbt_test_assert2(d1 == d2,
 197                      "The retrieved value is not the same than the injected one (%f!=%f)",
 198                      d1, d2);
 199   }
 200   for (cpt = 0; cpt < 5000; cpt++) {
 201     d1 = (double) cpt;
 202     xbt_dynar_shift(d, &d2);
 203     xbt_test_assert2(d1 == d2,
 204                      "The retrieved value is not the same than the injected one (%f!=%f)",
 205                      d1, d2);
 206   }
 207   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
 208   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
 209                                  /* in your code is naturally the way to go outside a regression test */
 210
 211   xbt_test_add0("==== Unshift/pop 5000 doubles");
 212   d = xbt_dynar_new(sizeof(double), NULL);
 213   for (cpt = 0; cpt < 5000; cpt++) {
 214     d1 = (double) cpt;
 215     xbt_dynar_unshift(d, &d1);
 216   }
 217   for (cpt = 0; cpt < 5000; cpt++) {
 218     d1 = (double) cpt;
 219     xbt_dynar_pop(d, &d2);
 220     xbt_test_assert2(d1 == d2,
 221                      "The retrieved value is not the same than the injected one (%f!=%f)",
 222                      d1, d2);
 223   }
 224   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
 225   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
 226                                  /* in your code is naturally the way to go outside a regression test */
 227
 228
 229
 230   xbt_test_add0
 231     ("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything");
 232   d = xbt_dynar_new(sizeof(double), NULL);
 233   for (cpt = 0; cpt < 5000; cpt++) {
 234     d1 = (double) cpt;
 235     xbt_dynar_push(d, &d1);
 236   }
 237   for (cpt = 0; cpt < 1000; cpt++) {
 238     d1 = (double) cpt;
 239     xbt_dynar_insert_at(d, 2500, &d1);
 240   }
 241
 242   for (cpt = 0; cpt < 2500; cpt++) {
 243     d1 = (double) cpt;
 244     xbt_dynar_shift(d, &d2);
 245     xbt_test_assert2(d1 == d2,
 246                      "The retrieved value is not the same than the injected one at the begining (%f!=%f)",
 247                      d1, d2);
 248     DEBUG2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
 249   }
 250   for (cpt = 999; cpt >= 0; cpt--) {
 251     d1 = (double) cpt;
 252     xbt_dynar_shift(d, &d2);
 253     xbt_test_assert2(d1 == d2,
 254                      "The retrieved value is not the same than the injected one in the middle (%f!=%f)",
 255                      d1, d2);
 256   }
 257   for (cpt = 2500; cpt < 5000; cpt++) {
 258     d1 = (double) cpt;
 259     xbt_dynar_shift(d, &d2);
 260     xbt_test_assert2(d1 == d2,
 261                      "The retrieved value is not the same than the injected one at the end (%f!=%f)",
 262                      d1, d2);
 263   }
 264   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
 265   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
 266                                  /* in your code is naturally the way to go outside a regression test */
 267
 268
 269   xbt_test_add0("==== Push 5000 double, remove 2000-4000. free the rest");
 270   d = xbt_dynar_new(sizeof(double), NULL);
 271   for (cpt = 0; cpt < 5000; cpt++) {
 272     d1 = (double) cpt;
 273     xbt_dynar_push(d, &d1);
 274   }
 275   for (cpt = 2000; cpt < 4000; cpt++) {
 276     d1 = (double) cpt;
 277     xbt_dynar_remove_at(d, 2000, &d2);
 278     xbt_test_assert2(d1 == d2,
 279                      "Remove a bad value. Got %f, expected %f", d2, d1);
 280   }
 281   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
 282   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
 283                                  /* in your code is naturally the way to go outside a regression test */
 284 }
 285
 286
 287 /* doxygen_string_cruft */
 288
 289 /*******************************************************************************/
 290 /*******************************************************************************/
 291 /*******************************************************************************/
 292 XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
 293 {
 294   xbt_dynar_t d;
 295   int cpt;
 296   unsigned int iter;
 297   char buf[1024];
 298   char *s1, *s2;
 299
 300   xbt_test_add0("==== Traverse the empty dynar");
 301   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
 302   xbt_dynar_foreach(d, iter, s1) {
 303     xbt_test_assert0(FALSE, "Damnit, there is something in the empty dynar");
 304   }
 305   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
 306   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
 307                                  /* in your code is naturally the way to go outside a regression test */
 308
 309   xbt_test_add1("==== Push %d strings, set them again 3 times, shift them",
 310                 NB_ELEM);
 311   /* Populate_str [doxygen cruft] */
 312   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
 313   /* 1. Populate the dynar */
 314   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 315     sprintf(buf, "%d", cpt);
 316     s1 = strdup(buf);
 317     xbt_dynar_push(d, &s1);
 318   }
 319   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 320     sprintf(buf, "%d", cpt);
 321     s1 = strdup(buf);
 322     xbt_dynar_replace(d, cpt, &s1);
 323   }
 324   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 325     sprintf(buf, "%d", cpt);
 326     s1 = strdup(buf);
 327     xbt_dynar_replace(d, cpt, &s1);
 328   }
 329   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 330     sprintf(buf, "%d", cpt);
 331     s1 = strdup(buf);
 332     xbt_dynar_replace(d, cpt, &s1);
 333   }
 334   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 335     sprintf(buf, "%d", cpt);
 336     xbt_dynar_shift(d, &s2);
 337     xbt_test_assert2(!strcmp(buf, s2),
 338                      "The retrieved value is not the same than the injected one (%s!=%s)",
 339                      buf, s2);
 340     free(s2);
 341   }
 342   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
 343   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
 344                                  /* in your code is naturally the way to go outside a regression test */
 345
 346   xbt_test_add1("==== Unshift, traverse and pop %d strings", NB_ELEM);
 347   d = xbt_dynar_new(sizeof(char **), &xbt_free_ref);
 348   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 349     sprintf(buf, "%d", cpt);
 350     s1 = strdup(buf);
 351     xbt_dynar_unshift(d, &s1);
 352   }
 353   /* 2. Traverse the dynar with the macro */
 354   xbt_dynar_foreach(d, iter, s1) {
 355     sprintf(buf, "%d", NB_ELEM - iter - 1);
 356     xbt_test_assert2(!strcmp(buf, s1),
 357                      "The retrieved value is not the same than the injected one (%s!=%s)",
 358                      buf, s1);
 359   }
 360   /* 3. Traverse the dynar with the macro */
 361   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 362     sprintf(buf, "%d", cpt);
 363     xbt_dynar_pop(d, &s2);
 364     xbt_test_assert2(!strcmp(buf, s2),
 365                      "The retrieved value is not the same than the injected one (%s!=%s)",
 366                      buf, s2);
 367     free(s2);
 368   }
 369   /* 4. Free the resources */
 370   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
 371   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
 372                                  /* in your code is naturally the way to go outside a regression test */
 373
 374
 375   xbt_test_add2
 376     ("==== Push %d strings, insert %d strings in the middle, shift everything",
 377      NB_ELEM, NB_ELEM / 5);
 378   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
 379   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 380     sprintf(buf, "%d", cpt);
 381     s1 = strdup(buf);
 382     xbt_dynar_push(d, &s1);
 383   }
 384   for (cpt = 0; cpt < NB_ELEM / 5; cpt++) {
 385     sprintf(buf, "%d", cpt);
 386     s1 = strdup(buf);
 387     xbt_dynar_insert_at(d, NB_ELEM / 2, &s1);
 388   }
 389
 390   for (cpt = 0; cpt < NB_ELEM / 2; cpt++) {
 391     sprintf(buf, "%d", cpt);
 392     xbt_dynar_shift(d, &s2);
 393     xbt_test_assert2(!strcmp(buf, s2),
 394                      "The retrieved value is not the same than the injected one at the begining (%s!=%s)",
 395                      buf, s2);
 396     free(s2);
 397   }
 398   for (cpt = (NB_ELEM / 5) - 1; cpt >= 0; cpt--) {
 399     sprintf(buf, "%d", cpt);
 400     xbt_dynar_shift(d, &s2);
 401     xbt_test_assert2(!strcmp(buf, s2),
 402                      "The retrieved value is not the same than the injected one in the middle (%s!=%s)",
 403                      buf, s2);
 404     free(s2);
 405   }
 406   for (cpt = NB_ELEM / 2; cpt < NB_ELEM; cpt++) {
 407     sprintf(buf, "%d", cpt);
 408     xbt_dynar_shift(d, &s2);
 409     xbt_test_assert2(!strcmp(buf, s2),
 410                      "The retrieved value is not the same than the injected one at the end (%s!=%s)",
 411                      buf, s2);
 412     free(s2);
 413   }
 414   xbt_dynar_free(&d); /* This code is used both as example and as regression test, so we try to */
 415   xbt_dynar_free(&d); /* free the struct twice here to check that it's ok, but freeing  it only once */
 416                                  /* in your code is naturally the way to go outside a regression test */
 417
 418
 419   xbt_test_add3("==== Push %d strings, remove %d-%d. free the rest", NB_ELEM,
 420                 2 * (NB_ELEM / 5), 4 * (NB_ELEM / 5));
 421   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
 422   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 423     sprintf(buf, "%d", cpt);
 424     s1 = strdup(buf);
 425     xbt_dynar_push(d, &s1);
 426   }
 427   for (cpt = 2 * (NB_ELEM / 5); cpt < 4 * (NB_ELEM / 5); cpt++) {
 428     sprintf(buf, "%d", cpt);
 429     xbt_dynar_remove_at(d, 2 * (NB_ELEM / 5), &s2);
 430     xbt_test_assert2(!strcmp(buf, s2),
 431                      "Remove a bad value. Got %s, expected %s", s2, buf);
 432     free(s2);
 433   }
 434   xbt_dynar_free(&d);           /* end_of_doxygen */
 435 }
 436
 437
 438 /*******************************************************************************/
 439 /*******************************************************************************/
 440 /*******************************************************************************/
 441 #include "xbt/synchro.h"
 442 static void pusher_f(void *a)
 443 {
 444   xbt_dynar_t d = (xbt_dynar_t) a;
 445   int i;
 446   for (i = 0; i < 500; i++) {
 447     xbt_dynar_push(d, &i);
 448   }
 449 }
 450
 451 static void poper_f(void *a)
 452 {
 453   xbt_dynar_t d = (xbt_dynar_t) a;
 454   int i;
 455   int data;
 456   xbt_ex_t e;
 457
 458   for (i = 0; i < 500; i++) {
 459     TRY {
 460       xbt_dynar_pop(d, &data);
 461     }
 462     CATCH(e) {
 463       if (e.category == bound_error) {
 464         xbt_ex_free(e);
 465         i--;
 466       } else {
 467         RETHROW;
 468       }
 469     }
 470   }
 471 }
 472
 473
 474 XBT_TEST_UNIT("synchronized int", test_dynar_sync_int,"Synchronized dynars of integers")
 475 {
 476   /* Vars_decl [doxygen cruft] */
 477   xbt_dynar_t d;
 478   xbt_thread_t pusher, poper;
 479
 480   xbt_test_add0("==== Have a pusher and a popper on the dynar");
 481   d = xbt_dynar_new_sync(sizeof(int), NULL);
 482   pusher = xbt_thread_create("pusher", pusher_f, d,0/*not joinable*/);
 483   poper = xbt_thread_create("poper", poper_f, d,0/*not joinable*/);
 484   xbt_thread_join(pusher);
 485   xbt_thread_join(poper);
 486   xbt_dynar_free(&d);
 487 }
 488
 489 /*******************************/
 490 /* GENERATED FILE, DO NOT EDIT */
 491 /*******************************/
 492