tests/test-avltree_list.c

   1 /* Test of sequential list data type implementation.
   2    Copyright (C) 2006 Free Software Foundation, Inc.
   3    Written by Bruno Haible <bruno@clisp.org>, 2006.
   4
   5    This program is free software; you can redistribute it and/or modify
   6    it under the terms of the GNU General Public License as published by
   7    the Free Software Foundation; either version 2, or (at your option)
   8    any later version.
   9
  10    This program is distributed in the hope that it will be useful,
  11    but WITHOUT ANY WARRANTY; without even the implied warranty of
  12    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13    GNU General Public License for more details.
  14
  15    You should have received a copy of the GNU General Public License
  16    along with this program; if not, write to the Free Software Foundation,
  17    Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.  */
  18
  19 #ifdef HAVE_CONFIG_H
  20 # include <config.h>
  21 #endif
  22
  23 #include <stdlib.h>
  24
  25 #include "gl_array_list.h"
  26 #include "gl_avltree_list.h"
  27
  28 extern void gl_avltree_list_check_invariants (gl_list_t list);
  29
  30 static const char *objects[15] =
  31   {
  32     "a", "b", "c", "d", "e", "f", "g", "h", "i", "j", "k", "l", "m", "n", "o"
  33   };
  34
  35 #define SIZEOF(array) (sizeof (array) / sizeof (array[0]))
  36 #define ASSERT(condition) if (!(condition)) abort ()
  37 #define RANDOM(n) (rand () % (n))
  38 #define RANDOM_OBJECT() objects[RANDOM (SIZEOF (objects))]
  39
  40 static void
  41 check_equals (gl_list_t list1, gl_list_t list2)
  42 {
  43   size_t n, i;
  44
  45   n = gl_list_size (list1);
  46   ASSERT (n == gl_list_size (list2));
  47   for (i = 0; i < n; i++)
  48     {
  49       ASSERT (gl_list_get_at (list1, i) == gl_list_get_at (list2, i));
  50     }
  51 }
  52
  53 static void
  54 check_all (gl_list_t list1, gl_list_t list2, gl_list_t list3)
  55 {
  56   gl_avltree_list_check_invariants (list2);
  57   gl_avltree_list_check_invariants (list3);
  58   check_equals (list1, list2);
  59   check_equals (list1, list3);
  60 }
  61
  62 int
  63 main (int argc, char *argv[])
  64 {
  65   gl_list_t list1, list2, list3;
  66
  67   /* Allow the user to provide a non-default random seed on the command line.  */
  68   if (argc > 1)
  69     srand (atoi (argv[1]));
  70
  71   {
  72     size_t initial_size = RANDOM (50);
  73     const void **contents =
  74       (const void **) malloc (initial_size * sizeof (const void *));
  75     size_t i;
  76     unsigned int repeat;
  77
  78     for (i = 0; i < initial_size; i++)
  79       contents[i] = RANDOM_OBJECT ();
  80
  81     /* Create list1.  */
  82     list1 = gl_list_create (GL_ARRAY_LIST, NULL, NULL, true,
  83                             initial_size, contents);
  84     /* Create list2.  */
  85     list2 = gl_list_create_empty (GL_AVLTREE_LIST, NULL, NULL, true);
  86     for (i = 0; i < initial_size; i++)
  87       gl_list_add_last (list2, contents[i]);
  88
  89     /* Create list3.  */
  90     list3 = gl_list_create (GL_AVLTREE_LIST, NULL, NULL, true,
  91                             initial_size, contents);
  92
  93     check_all (list1, list2, list3);
  94
  95     for (repeat = 0; repeat < 10000; repeat++)
  96       {
  97         unsigned int operation = RANDOM (16);
  98         switch (operation)
  99           {
 100           case 0:
 101             if (gl_list_size (list1) > 0)
 102               {
 103                 size_t index = RANDOM (gl_list_size (list1));
 104                 const char *obj = RANDOM_OBJECT ();
 105                 gl_list_node_t node1, node2, node3;
 106
 107                 node1 = gl_list_set_at (list1, index, obj);
 108                 ASSERT (gl_list_get_at (list1, index) == obj);
 109                 ASSERT (gl_list_node_value (list1, node1) == obj);
 110
 111                 node2 = gl_list_set_at (list2, index, obj);
 112                 ASSERT (gl_list_get_at (list2, index) == obj);
 113                 ASSERT (gl_list_node_value (list2, node2) == obj);
 114
 115                 node3 = gl_list_set_at (list3, index, obj);
 116                 ASSERT (gl_list_get_at (list3, index) == obj);
 117                 ASSERT (gl_list_node_value (list3, node3) == obj);
 118
 119                 if (index > 0)
 120                   {
 121                     ASSERT (gl_list_node_value (list1, gl_list_previous_node (list1, node1))
 122                             == gl_list_get_at (list1, index - 1));
 123                     ASSERT (gl_list_node_value (list2, gl_list_previous_node (list3, node3))
 124                             == gl_list_get_at (list2, index - 1));
 125                     ASSERT (gl_list_node_value (list3, gl_list_previous_node (list3, node3))
 126                             == gl_list_get_at (list2, index - 1));
 127                   }
 128                 if (index + 1 < gl_list_size (list1))
 129                   {
 130                     ASSERT (gl_list_node_value (list1, gl_list_next_node (list1, node1))
 131                             == gl_list_get_at (list1, index + 1));
 132                     ASSERT (gl_list_node_value (list2, gl_list_next_node (list3, node3))
 133                             == gl_list_get_at (list2, index + 1));
 134                     ASSERT (gl_list_node_value (list3, gl_list_next_node (list3, node3))
 135                             == gl_list_get_at (list2, index + 1));
 136                   }
 137               }
 138             break;
 139           case 1:
 140             {
 141               const char *obj = RANDOM_OBJECT ();
 142               gl_list_node_t node1, node2, node3;
 143               node1 = gl_list_search (list1, obj);
 144               node2 = gl_list_search (list2, obj);
 145               node3 = gl_list_search (list3, obj);
 146               if (node1 == NULL)
 147                 {
 148                   ASSERT (node2 == NULL);
 149                   ASSERT (node3 == NULL);
 150                 }
 151               else
 152                 {
 153                   ASSERT (node2 != NULL);
 154                   ASSERT (node3 != NULL);
 155                   ASSERT (gl_list_node_value (list1, node1) == obj);
 156                   ASSERT (gl_list_node_value (list2, node2) == obj);
 157                   ASSERT (gl_list_node_value (list3, node3) == obj);
 158                 }
 159             }
 160             break;
 161           case 2:
 162             {
 163               const char *obj = RANDOM_OBJECT ();
 164               size_t index1, index2, index3;
 165               index1 = gl_list_indexof (list1, obj);
 166               index2 = gl_list_indexof (list2, obj);
 167               index3 = gl_list_indexof (list3, obj);
 168               if (index1 == (size_t)(-1))
 169                 {
 170                   ASSERT (index2 == (size_t)(-1));
 171                   ASSERT (index3 == (size_t)(-1));
 172                 }
 173               else
 174                 {
 175                   ASSERT (index2 != (size_t)(-1));
 176                   ASSERT (index3 != (size_t)(-1));
 177                   ASSERT (gl_list_get_at (list1, index1) == obj);
 178                   ASSERT (gl_list_get_at (list2, index2) == obj);
 179                   ASSERT (gl_list_get_at (list3, index3) == obj);
 180                   ASSERT (index2 == index1);
 181                   ASSERT (index3 == index1);
 182                 }
 183             }
 184             break;
 185           case 3: /* add 1 element */
 186             {
 187               const char *obj = RANDOM_OBJECT ();
 188               gl_list_node_t node1, node2, node3;
 189               node1 = gl_list_add_first (list1, obj);
 190               node2 = gl_list_add_first (list2, obj);
 191               node3 = gl_list_add_first (list3, obj);
 192               ASSERT (gl_list_node_value (list1, node1) == obj);
 193               ASSERT (gl_list_node_value (list2, node2) == obj);
 194               ASSERT (gl_list_node_value (list3, node3) == obj);
 195               ASSERT (gl_list_get_at (list1, 0) == obj);
 196               ASSERT (gl_list_get_at (list2, 0) == obj);
 197               ASSERT (gl_list_get_at (list3, 0) == obj);
 198             }
 199             break;
 200           case 4: /* add 1 element */
 201             {
 202               const char *obj = RANDOM_OBJECT ();
 203               gl_list_node_t node1, node2, node3;
 204               node1 = gl_list_add_last (list1, obj);
 205               node2 = gl_list_add_last (list2, obj);
 206               node3 = gl_list_add_last (list3, obj);
 207               ASSERT (gl_list_node_value (list1, node1) == obj);
 208               ASSERT (gl_list_node_value (list2, node2) == obj);
 209               ASSERT (gl_list_node_value (list3, node3) == obj);
 210               ASSERT (gl_list_get_at (list1, gl_list_size (list1) - 1) == obj);
 211               ASSERT (gl_list_get_at (list2, gl_list_size (list2) - 1) == obj);
 212               ASSERT (gl_list_get_at (list3, gl_list_size (list3) - 1) == obj);
 213             }
 214             break;
 215           case 5: /* add 3 elements */
 216             {
 217               const char *obj0 = RANDOM_OBJECT ();
 218               const char *obj1 = RANDOM_OBJECT ();
 219               const char *obj2 = RANDOM_OBJECT ();
 220               gl_list_node_t node1, node2, node3;
 221               node1 = gl_list_add_first (list1, obj2);
 222               node1 = gl_list_add_before (list1, node1, obj0);
 223               node1 = gl_list_add_after (list1, node1, obj1);
 224               node2 = gl_list_add_first (list2, obj2);
 225               node2 = gl_list_add_before (list2, node2, obj0);
 226               node2 = gl_list_add_after (list2, node2, obj1);
 227               node3 = gl_list_add_first (list3, obj2);
 228               node3 = gl_list_add_before (list3, node3, obj0);
 229               node3 = gl_list_add_after (list3, node3, obj1);
 230               ASSERT (gl_list_node_value (list1, node1) == obj1);
 231               ASSERT (gl_list_node_value (list2, node2) == obj1);
 232               ASSERT (gl_list_node_value (list3, node3) == obj1);
 233               ASSERT (gl_list_get_at (list1, 0) == obj0);
 234               ASSERT (gl_list_get_at (list1, 1) == obj1);
 235               ASSERT (gl_list_get_at (list1, 2) == obj2);
 236               ASSERT (gl_list_get_at (list2, 0) == obj0);
 237               ASSERT (gl_list_get_at (list2, 1) == obj1);
 238               ASSERT (gl_list_get_at (list2, 2) == obj2);
 239               ASSERT (gl_list_get_at (list3, 0) == obj0);
 240               ASSERT (gl_list_get_at (list3, 1) == obj1);
 241               ASSERT (gl_list_get_at (list3, 2) == obj2);
 242             }
 243             break;
 244           case 6: /* add 1 element */
 245             {
 246               size_t index = RANDOM (gl_list_size (list1) + 1);
 247               const char *obj = RANDOM_OBJECT ();
 248               gl_list_node_t node1, node2, node3;
 249               node1 = gl_list_add_at (list1, index, obj);
 250               node2 = gl_list_add_at (list2, index, obj);
 251               node3 = gl_list_add_at (list3, index, obj);
 252               ASSERT (gl_list_get_at (list1, index) == obj);
 253               ASSERT (gl_list_node_value (list1, node1) == obj);
 254               ASSERT (gl_list_get_at (list2, index) == obj);
 255               ASSERT (gl_list_node_value (list2, node2) == obj);
 256               ASSERT (gl_list_get_at (list3, index) == obj);
 257               ASSERT (gl_list_node_value (list3, node3) == obj);
 258               if (index > 0)
 259                 {
 260                   ASSERT (gl_list_node_value (list1, gl_list_previous_node (list1, node1))
 261                           == gl_list_get_at (list1, index - 1));
 262                   ASSERT (gl_list_node_value (list2, gl_list_previous_node (list3, node3))
 263                           == gl_list_get_at (list2, index - 1));
 264                   ASSERT (gl_list_node_value (list3, gl_list_previous_node (list3, node3))
 265                           == gl_list_get_at (list2, index - 1));
 266                 }
 267               if (index + 1 < gl_list_size (list1))
 268                 {
 269                   ASSERT (gl_list_node_value (list1, gl_list_next_node (list1, node1))
 270                           == gl_list_get_at (list1, index + 1));
 271                   ASSERT (gl_list_node_value (list2, gl_list_next_node (list3, node3))
 272                           == gl_list_get_at (list2, index + 1));
 273                   ASSERT (gl_list_node_value (list3, gl_list_next_node (list3, node3))
 274                           == gl_list_get_at (list2, index + 1));
 275                 }
 276             }
 277             break;
 278           case 7: case 8: /* remove 1 element */
 279             if (gl_list_size (list1) > 0)
 280               {
 281                 size_t n = gl_list_size (list1);
 282                 const char *obj = gl_list_get_at (list1, RANDOM (n));
 283                 gl_list_node_t node1, node2, node3;
 284                 node1 = gl_list_search (list1, obj);
 285                 node2 = gl_list_search (list2, obj);
 286                 node3 = gl_list_search (list3, obj);
 287                 ASSERT (node1 != NULL);
 288                 ASSERT (node2 != NULL);
 289                 ASSERT (node3 != NULL);
 290                 ASSERT (gl_list_remove_node (list1, node1));
 291                 ASSERT (gl_list_remove_node (list2, node2));
 292                 ASSERT (gl_list_remove_node (list3, node3));
 293                 ASSERT (gl_list_size (list1) == n - 1);
 294               }
 295             break;
 296           case 9: case 10: /* remove 1 element */
 297             if (gl_list_size (list1) > 0)
 298               {
 299                 size_t n = gl_list_size (list1);
 300                 size_t index = RANDOM (n);
 301                 ASSERT (gl_list_remove_at (list1, index));
 302                 ASSERT (gl_list_remove_at (list2, index));
 303                 ASSERT (gl_list_remove_at (list3, index));
 304                 ASSERT (gl_list_size (list1) == n - 1);
 305               }
 306             break;
 307           case 11: case 12: /* remove 1 element */
 308             if (gl_list_size (list1) > 0)
 309               {
 310                 size_t n = gl_list_size (list1);
 311                 const char *obj = gl_list_get_at (list1, RANDOM (n));
 312                 ASSERT (gl_list_remove (list1, obj));
 313                 ASSERT (gl_list_remove (list2, obj));
 314                 ASSERT (gl_list_remove (list3, obj));
 315                 ASSERT (gl_list_size (list1) == n - 1);
 316               }
 317             break;
 318           case 13:
 319             if (gl_list_size (list1) > 0)
 320               {
 321                 size_t n = gl_list_size (list1);
 322                 const char *obj = "xyzzy";
 323                 ASSERT (!gl_list_remove (list1, obj));
 324                 ASSERT (!gl_list_remove (list2, obj));
 325                 ASSERT (!gl_list_remove (list3, obj));
 326                 ASSERT (gl_list_size (list1) == n);
 327               }
 328             break;
 329           case 14:
 330             {
 331               size_t n = gl_list_size (list1);
 332               gl_list_iterator_t iter1, iter2, iter3;
 333               const void *elt;
 334               iter1 = gl_list_iterator (list1);
 335               iter2 = gl_list_iterator (list2);
 336               iter3 = gl_list_iterator (list3);
 337               for (i = 0; i < n; i++)
 338                 {
 339                   ASSERT (gl_list_iterator_next (&iter1, &elt, NULL));
 340                   ASSERT (gl_list_get_at (list1, i) == elt);
 341                   ASSERT (gl_list_iterator_next (&iter2, &elt, NULL));
 342                   ASSERT (gl_list_get_at (list2, i) == elt);
 343                   ASSERT (gl_list_iterator_next (&iter3, &elt, NULL));
 344                   ASSERT (gl_list_get_at (list3, i) == elt);
 345                 }
 346               ASSERT (!gl_list_iterator_next (&iter1, &elt, NULL));
 347               ASSERT (!gl_list_iterator_next (&iter2, &elt, NULL));
 348               ASSERT (!gl_list_iterator_next (&iter3, &elt, NULL));
 349               gl_list_iterator_free (&iter1);
 350               gl_list_iterator_free (&iter2);
 351               gl_list_iterator_free (&iter3);
 352             }
 353             break;
 354           case 15:
 355             {
 356               size_t end = RANDOM (gl_list_size (list1) + 1);
 357               size_t start = RANDOM (end + 1);
 358               gl_list_iterator_t iter1, iter2, iter3;
 359               const void *elt;
 360               iter1 = gl_list_iterator_from_to (list1, start, end);
 361               iter2 = gl_list_iterator_from_to (list2, start, end);
 362               iter3 = gl_list_iterator_from_to (list3, start, end);
 363               for (i = start; i < end; i++)
 364                 {
 365                   ASSERT (gl_list_iterator_next (&iter1, &elt, NULL));
 366                   ASSERT (gl_list_get_at (list1, i) == elt);
 367                   ASSERT (gl_list_iterator_next (&iter2, &elt, NULL));
 368                   ASSERT (gl_list_get_at (list2, i) == elt);
 369                   ASSERT (gl_list_iterator_next (&iter3, &elt, NULL));
 370                   ASSERT (gl_list_get_at (list3, i) == elt);
 371                 }
 372               ASSERT (!gl_list_iterator_next (&iter1, &elt, NULL));
 373               ASSERT (!gl_list_iterator_next (&iter2, &elt, NULL));
 374               ASSERT (!gl_list_iterator_next (&iter3, &elt, NULL));
 375               gl_list_iterator_free (&iter1);
 376               gl_list_iterator_free (&iter2);
 377               gl_list_iterator_free (&iter3);
 378             }
 379             break;
 380           }
 381         check_all (list1, list2, list3);
 382       }
 383
 384     gl_list_free (list1);
 385     gl_list_free (list2);
 386     gl_list_free (list3);
 387     free (contents);
 388   }
 389
 390   return 0;
 391 }