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 730 "xbt/dynar.c"
  12
  13 #define NB_ELEM 5000
  14
  15 XBT_LOG_EXTERNAL_CATEGORY(xbt_dyn);
  16 XBT_LOG_DEFAULT_CATEGORY(xbt_dyn);
  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",
 154                 NB_ELEM);
 155   d = xbt_dynar_new(sizeof(int), NULL);
 156   for (cpt = 0; cpt < NB_ELEM; cpt++)
 157     xbt_dynar_push_as(d, int, cpt);
 158
 159   for (cpt = 2000; cpt < 4000; cpt++) {
 160     xbt_dynar_remove_at(d, 2000, &i);
 161     xbt_test_assert2(i == cpt,
 162                      "Remove a bad value. Got %d, expected %d", i, cpt);
 163     DEBUG2("remove %d, length=%lu", cpt, xbt_dynar_length(d));
 164   }
 165   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
 166   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
 167   /* in your code is naturally the way to go outside a regression test */
 168 }
 169
 170 /*******************************************************************************/
 171 /*******************************************************************************/
 172 /*******************************************************************************/
 173 XBT_TEST_UNIT("double", test_dynar_double, "Dynars of doubles")
 174 {
 175   xbt_dynar_t d;
 176   int cpt;
 177   unsigned int cursor;
 178   double d1, d2;
 179
 180   xbt_test_add0("==== Traverse the empty dynar");
 181   d = xbt_dynar_new(sizeof(int), NULL);
 182   xbt_dynar_foreach(d, cursor, cpt) {
 183     xbt_test_assert0(FALSE,
 184                      "Damnit, there is something in the empty dynar");
 185   }
 186   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
 187   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
 188   /* in your code is naturally the way to go outside a regression test */
 189
 190   xbt_test_add0("==== Push/shift 5000 doubles");
 191   d = xbt_dynar_new(sizeof(double), NULL);
 192   for (cpt = 0; cpt < 5000; cpt++) {
 193     d1 = (double) cpt;
 194     xbt_dynar_push(d, &d1);
 195   }
 196   xbt_dynar_foreach(d, cursor, d2) {
 197     d1 = (double) cursor;
 198     xbt_test_assert2(d1 == d2,
 199                      "The retrieved value is not the same than the injected one (%f!=%f)",
 200                      d1, d2);
 201   }
 202   for (cpt = 0; cpt < 5000; cpt++) {
 203     d1 = (double) cpt;
 204     xbt_dynar_shift(d, &d2);
 205     xbt_test_assert2(d1 == d2,
 206                      "The retrieved value is not the same than the injected one (%f!=%f)",
 207                      d1, d2);
 208   }
 209   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
 210   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
 211   /* in your code is naturally the way to go outside a regression test */
 212
 213   xbt_test_add0("==== Unshift/pop 5000 doubles");
 214   d = xbt_dynar_new(sizeof(double), NULL);
 215   for (cpt = 0; cpt < 5000; cpt++) {
 216     d1 = (double) cpt;
 217     xbt_dynar_unshift(d, &d1);
 218   }
 219   for (cpt = 0; cpt < 5000; cpt++) {
 220     d1 = (double) cpt;
 221     xbt_dynar_pop(d, &d2);
 222     xbt_test_assert2(d1 == d2,
 223                      "The retrieved value is not the same than the injected one (%f!=%f)",
 224                      d1, d2);
 225   }
 226   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
 227   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
 228   /* in your code is naturally the way to go outside a regression test */
 229
 230
 231
 232   xbt_test_add0
 233       ("==== Push 5000 doubles, insert 1000 doubles in the middle, shift everything");
 234   d = xbt_dynar_new(sizeof(double), NULL);
 235   for (cpt = 0; cpt < 5000; cpt++) {
 236     d1 = (double) cpt;
 237     xbt_dynar_push(d, &d1);
 238   }
 239   for (cpt = 0; cpt < 1000; cpt++) {
 240     d1 = (double) cpt;
 241     xbt_dynar_insert_at(d, 2500, &d1);
 242   }
 243
 244   for (cpt = 0; cpt < 2500; cpt++) {
 245     d1 = (double) cpt;
 246     xbt_dynar_shift(d, &d2);
 247     xbt_test_assert2(d1 == d2,
 248                      "The retrieved value is not the same than the injected one at the begining (%f!=%f)",
 249                      d1, d2);
 250     DEBUG2("Pop %d, length=%lu", cpt, xbt_dynar_length(d));
 251   }
 252   for (cpt = 999; cpt >= 0; cpt--) {
 253     d1 = (double) cpt;
 254     xbt_dynar_shift(d, &d2);
 255     xbt_test_assert2(d1 == d2,
 256                      "The retrieved value is not the same than the injected one in the middle (%f!=%f)",
 257                      d1, d2);
 258   }
 259   for (cpt = 2500; cpt < 5000; cpt++) {
 260     d1 = (double) cpt;
 261     xbt_dynar_shift(d, &d2);
 262     xbt_test_assert2(d1 == d2,
 263                      "The retrieved value is not the same than the injected one at the end (%f!=%f)",
 264                      d1, d2);
 265   }
 266   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
 267   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
 268   /* in your code is naturally the way to go outside a regression test */
 269
 270
 271   xbt_test_add0("==== Push 5000 double, remove 2000-4000. free the rest");
 272   d = xbt_dynar_new(sizeof(double), NULL);
 273   for (cpt = 0; cpt < 5000; cpt++) {
 274     d1 = (double) cpt;
 275     xbt_dynar_push(d, &d1);
 276   }
 277   for (cpt = 2000; cpt < 4000; cpt++) {
 278     d1 = (double) cpt;
 279     xbt_dynar_remove_at(d, 2000, &d2);
 280     xbt_test_assert2(d1 == d2,
 281                      "Remove a bad value. Got %f, expected %f", d2, d1);
 282   }
 283   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
 284   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
 285   /* in your code is naturally the way to go outside a regression test */
 286 }
 287
 288
 289 /* doxygen_string_cruft */
 290
 291 /*******************************************************************************/
 292 /*******************************************************************************/
 293 /*******************************************************************************/
 294 XBT_TEST_UNIT("string", test_dynar_string, "Dynars of strings")
 295 {
 296   xbt_dynar_t d;
 297   int cpt;
 298   unsigned int iter;
 299   char buf[1024];
 300   char *s1, *s2;
 301
 302   xbt_test_add0("==== Traverse the empty dynar");
 303   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
 304   xbt_dynar_foreach(d, iter, s1) {
 305     xbt_test_assert0(FALSE,
 306                      "Damnit, there is something in the empty dynar");
 307   }
 308   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
 309   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
 310   /* in your code is naturally the way to go outside a regression test */
 311
 312   xbt_test_add1("==== Push %d strings, set them again 3 times, shift them",
 313                 NB_ELEM);
 314   /* Populate_str [doxygen cruft] */
 315   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
 316   /* 1. Populate the dynar */
 317   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 318     sprintf(buf, "%d", cpt);
 319     s1 = strdup(buf);
 320     xbt_dynar_push(d, &s1);
 321   }
 322   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 323     sprintf(buf, "%d", cpt);
 324     s1 = strdup(buf);
 325     xbt_dynar_replace(d, cpt, &s1);
 326   }
 327   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 328     sprintf(buf, "%d", cpt);
 329     s1 = strdup(buf);
 330     xbt_dynar_replace(d, cpt, &s1);
 331   }
 332   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 333     sprintf(buf, "%d", cpt);
 334     s1 = strdup(buf);
 335     xbt_dynar_replace(d, cpt, &s1);
 336   }
 337   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 338     sprintf(buf, "%d", cpt);
 339     xbt_dynar_shift(d, &s2);
 340     xbt_test_assert2(!strcmp(buf, s2),
 341                      "The retrieved value is not the same than the injected one (%s!=%s)",
 342                      buf, s2);
 343     free(s2);
 344   }
 345   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
 346   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
 347   /* in your code is naturally the way to go outside a regression test */
 348
 349   xbt_test_add1("==== Unshift, traverse and pop %d strings", NB_ELEM);
 350   d = xbt_dynar_new(sizeof(char **), &xbt_free_ref);
 351   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 352     sprintf(buf, "%d", cpt);
 353     s1 = strdup(buf);
 354     xbt_dynar_unshift(d, &s1);
 355   }
 356   /* 2. Traverse the dynar with the macro */
 357   xbt_dynar_foreach(d, iter, s1) {
 358     sprintf(buf, "%d", NB_ELEM - iter - 1);
 359     xbt_test_assert2(!strcmp(buf, s1),
 360                      "The retrieved value is not the same than the injected one (%s!=%s)",
 361                      buf, s1);
 362   }
 363   /* 3. Traverse the dynar with the macro */
 364   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 365     sprintf(buf, "%d", cpt);
 366     xbt_dynar_pop(d, &s2);
 367     xbt_test_assert2(!strcmp(buf, s2),
 368                      "The retrieved value is not the same than the injected one (%s!=%s)",
 369                      buf, s2);
 370     free(s2);
 371   }
 372   /* 4. Free the resources */
 373   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
 374   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
 375   /* in your code is naturally the way to go outside a regression test */
 376
 377
 378   xbt_test_add2
 379       ("==== Push %d strings, insert %d strings in the middle, shift everything",
 380        NB_ELEM, NB_ELEM / 5);
 381   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
 382   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 383     sprintf(buf, "%d", cpt);
 384     s1 = strdup(buf);
 385     xbt_dynar_push(d, &s1);
 386   }
 387   for (cpt = 0; cpt < NB_ELEM / 5; cpt++) {
 388     sprintf(buf, "%d", cpt);
 389     s1 = strdup(buf);
 390     xbt_dynar_insert_at(d, NB_ELEM / 2, &s1);
 391   }
 392
 393   for (cpt = 0; cpt < NB_ELEM / 2; cpt++) {
 394     sprintf(buf, "%d", cpt);
 395     xbt_dynar_shift(d, &s2);
 396     xbt_test_assert2(!strcmp(buf, s2),
 397                      "The retrieved value is not the same than the injected one at the begining (%s!=%s)",
 398                      buf, s2);
 399     free(s2);
 400   }
 401   for (cpt = (NB_ELEM / 5) - 1; cpt >= 0; cpt--) {
 402     sprintf(buf, "%d", cpt);
 403     xbt_dynar_shift(d, &s2);
 404     xbt_test_assert2(!strcmp(buf, s2),
 405                      "The retrieved value is not the same than the injected one in the middle (%s!=%s)",
 406                      buf, s2);
 407     free(s2);
 408   }
 409   for (cpt = NB_ELEM / 2; cpt < NB_ELEM; cpt++) {
 410     sprintf(buf, "%d", cpt);
 411     xbt_dynar_shift(d, &s2);
 412     xbt_test_assert2(!strcmp(buf, s2),
 413                      "The retrieved value is not the same than the injected one at the end (%s!=%s)",
 414                      buf, s2);
 415     free(s2);
 416   }
 417   xbt_dynar_free(&d);           /* This code is used both as example and as regression test, so we try to */
 418   xbt_dynar_free(&d);           /* free the struct twice here to check that it's ok, but freeing  it only once */
 419   /* in your code is naturally the way to go outside a regression test */
 420
 421
 422   xbt_test_add3("==== Push %d strings, remove %d-%d. free the rest",
 423                 NB_ELEM, 2 * (NB_ELEM / 5), 4 * (NB_ELEM / 5));
 424   d = xbt_dynar_new(sizeof(char *), &xbt_free_ref);
 425   for (cpt = 0; cpt < NB_ELEM; cpt++) {
 426     sprintf(buf, "%d", cpt);
 427     s1 = strdup(buf);
 428     xbt_dynar_push(d, &s1);
 429   }
 430   for (cpt = 2 * (NB_ELEM / 5); cpt < 4 * (NB_ELEM / 5); cpt++) {
 431     sprintf(buf, "%d", cpt);
 432     xbt_dynar_remove_at(d, 2 * (NB_ELEM / 5), &s2);
 433     xbt_test_assert2(!strcmp(buf, s2),
 434                      "Remove a bad value. Got %s, expected %s", s2, buf);
 435     free(s2);
 436   }
 437   xbt_dynar_free(&d);           /* end_of_doxygen */
 438 }
 439
 440
 441 /*******************************************************************************/
 442 /*******************************************************************************/
 443 /*******************************************************************************/
 444 #include "xbt/synchro.h"
 445 static void pusher_f(void *a)
 446 {
 447   xbt_dynar_t d = (xbt_dynar_t) a;
 448   int i;
 449   for (i = 0; i < 500; i++) {
 450     xbt_dynar_push(d, &i);
 451   }
 452 }
 453
 454 static void poper_f(void *a)
 455 {
 456   xbt_dynar_t d = (xbt_dynar_t) a;
 457   int i;
 458   int data;
 459   xbt_ex_t e;
 460
 461   for (i = 0; i < 500; i++) {
 462     TRY {
 463       xbt_dynar_pop(d, &data);
 464     }
 465     CATCH(e) {
 466       if (e.category == bound_error) {
 467         xbt_ex_free(e);
 468         i--;
 469       } else {
 470         RETHROW;
 471       }
 472     }
 473   }
 474 }
 475
 476
 477 XBT_TEST_UNIT("synchronized int", test_dynar_sync_int, "Synchronized dynars of integers")
 478 {
 479   /* Vars_decl [doxygen cruft] */
 480   xbt_dynar_t d;
 481   xbt_thread_t pusher, poper;
 482
 483   xbt_test_add0("==== Have a pusher and a popper on the dynar");
 484   d = xbt_dynar_new_sync(sizeof(int), NULL);
 485   pusher = xbt_thread_create("pusher", pusher_f, d, 0 /*not joinable */ );
 486   poper = xbt_thread_create("poper", poper_f, d, 0 /*not joinable */ );
 487   xbt_thread_join(pusher);
 488   xbt_thread_join(poper);
 489   xbt_dynar_free(&d);
 490 }
 491
 492 /*******************************/
 493 /* GENERATED FILE, DO NOT EDIT */
 494 /*******************************/
 495