glib/tests/array-test.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   4  * This library is free software; you can redistribute it and/or
   5  * modify it under the terms of the GNU Lesser General Public
   6  * License as published by the Free Software Foundation; either
   7  * version 2.1 of the License, or (at your option) any later version.
   8  *
   9  * This library is distributed in the hope that it will be useful,
  10  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  11  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12  * Lesser General Public License for more details.
  13  *
  14  * You should have received a copy of the GNU Lesser General Public
  15  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  16  */
  17
  18 /*
  19  * Modified by the GLib Team and others 1997-2000.  See the AUTHORS
  20  * file for a list of people on the GLib Team.  See the ChangeLog
  21  * files for a list of changes.  These files are distributed with
  22  * GLib at ftp://ftp.gtk.org/pub/gtk/.
  23  */
  24
  25 #undef G_DISABLE_ASSERT
  26 #undef G_LOG_DOMAIN
  27
  28 #include <stdio.h>
  29 #include <stdlib.h>
  30 #include <string.h>
  31 #include "glib.h"
  32
  33 static void
  34 sum_up (gpointer data,
  35         gpointer user_data)
  36 {
  37   gint *sum = (gint *)user_data;
  38
  39   *sum += GPOINTER_TO_INT (data);
  40 }
  41
  42 /* Check that expanding an array with g_array_set_size() clears the new elements
  43  * if @clear_ was specified during construction. */
  44 static void
  45 array_new_cleared (void)
  46 {
  47   GArray *garray;
  48   gsize i;
  49
  50   garray = g_array_new (FALSE, TRUE, sizeof (gint));
  51   g_assert_cmpuint (garray->len, ==, 0);
  52
  53   g_array_set_size (garray, 5);
  54   g_assert_cmpuint (garray->len, ==, 5);
  55
  56   for (i = 0; i < 5; i++)
  57     g_assert_cmpint (g_array_index (garray, gint, i), ==, 0);
  58
  59   g_array_unref (garray);
  60 }
  61
  62 /* As with array_new_cleared(), but with a sized array. */
  63 static void
  64 array_new_sized_cleared (void)
  65 {
  66   GArray *garray;
  67   gsize i;
  68
  69   garray = g_array_sized_new (FALSE, TRUE, sizeof (gint), 10);
  70   g_assert_cmpuint (garray->len, ==, 0);
  71
  72   g_array_set_size (garray, 5);
  73   g_assert_cmpuint (garray->len, ==, 5);
  74
  75   for (i = 0; i < 5; i++)
  76     g_assert_cmpint (g_array_index (garray, gint, i), ==, 0);
  77
  78   g_array_unref (garray);
  79 }
  80
  81 /* Check that a zero-terminated array does actually have a zero terminator. */
  82 static void
  83 array_new_zero_terminated (void)
  84 {
  85   GArray *garray;
  86   gchar *out_str = NULL;
  87
  88   garray = g_array_new (TRUE, FALSE, sizeof (gchar));
  89   g_assert_cmpuint (garray->len, ==, 0);
  90
  91   g_array_append_vals (garray, "hello", strlen ("hello"));
  92   g_assert_cmpuint (garray->len, ==, 5);
  93   g_assert_cmpstr (garray->data, ==, "hello");
  94
  95   out_str = g_array_free (garray, FALSE);
  96   g_assert_cmpstr (out_str, ==, "hello");
  97   g_free (out_str);
  98 }
  99
 100 static void
 101 array_append (void)
 102 {
 103   GArray *garray;
 104   gint i;
 105   gint *segment;
 106
 107   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 108   for (i = 0; i < 10000; i++)
 109     g_array_append_val (garray, i);
 110
 111   for (i = 0; i < 10000; i++)
 112     g_assert_cmpint (g_array_index (garray, gint, i), ==, i);
 113
 114   segment = (gint*)g_array_free (garray, FALSE);
 115   for (i = 0; i < 10000; i++)
 116     g_assert_cmpint (segment[i], ==, i);
 117   g_free (segment);
 118 }
 119
 120 static void
 121 array_prepend (void)
 122 {
 123   GArray *garray;
 124   gint i;
 125
 126   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 127   for (i = 0; i < 100; i++)
 128     g_array_prepend_val (garray, i);
 129
 130   for (i = 0; i < 100; i++)
 131     g_assert_cmpint (g_array_index (garray, gint, i), ==, (100 - i - 1));
 132
 133   g_array_free (garray, TRUE);
 134 }
 135
 136 static void
 137 array_remove (void)
 138 {
 139   GArray *garray;
 140   gint i;
 141   gint prev, cur;
 142
 143   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 144   for (i = 0; i < 100; i++)
 145     g_array_append_val (garray, i);
 146
 147   g_assert_cmpint (garray->len, ==, 100);
 148
 149   g_array_remove_index (garray, 1);
 150   g_array_remove_index (garray, 3);
 151   g_array_remove_index (garray, 21);
 152   g_array_remove_index (garray, 57);
 153
 154   g_assert_cmpint (garray->len, ==, 96);
 155
 156   prev = -1;
 157   for (i = 0; i < garray->len; i++)
 158     {
 159       cur = g_array_index (garray, gint, i);
 160       g_assert (cur != 1 &&  cur != 4 && cur != 23 && cur != 60);
 161       g_assert_cmpint (prev, <, cur);
 162       prev = cur;
 163     }
 164
 165   g_array_free (garray, TRUE);
 166 }
 167
 168 static void
 169 array_remove_fast (void)
 170 {
 171   GArray *garray;
 172   gint i;
 173   gint prev, cur;
 174
 175   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 176   for (i = 0; i < 100; i++)
 177     g_array_append_val (garray, i);
 178
 179   g_assert_cmpint (garray->len, ==, 100);
 180
 181   g_array_remove_index_fast (garray, 1);
 182   g_array_remove_index_fast (garray, 3);
 183   g_array_remove_index_fast (garray, 21);
 184   g_array_remove_index_fast (garray, 57);
 185
 186   g_assert_cmpint (garray->len, ==, 96);
 187
 188   prev = -1;
 189   for (i = 0; i < garray->len; i++)
 190     {
 191       cur = g_array_index (garray, gint, i);
 192       g_assert (cur != 1 &&  cur != 3 && cur != 21 && cur != 57);
 193       if (cur < 96)
 194         {
 195           g_assert_cmpint (prev, <, cur);
 196           prev = cur;
 197         }
 198     }
 199
 200   g_array_free (garray, TRUE);
 201 }
 202
 203 static void
 204 array_remove_range (void)
 205 {
 206   GArray *garray;
 207   gint i;
 208   gint prev, cur;
 209
 210   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 211   for (i = 0; i < 100; i++)
 212     g_array_append_val (garray, i);
 213
 214   g_assert_cmpint (garray->len, ==, 100);
 215
 216   g_array_remove_range (garray, 31, 4);
 217
 218   g_assert_cmpint (garray->len, ==, 96);
 219
 220   prev = -1;
 221   for (i = 0; i < garray->len; i++)
 222     {
 223       cur = g_array_index (garray, gint, i);
 224       g_assert (cur < 31 || cur > 34);
 225       g_assert_cmpint (prev, <, cur);
 226       prev = cur;
 227     }
 228
 229   /* Ensure the entire array can be cleared, even when empty. */
 230   g_array_remove_range (garray, 0, garray->len);
 231   g_array_remove_range (garray, 0, garray->len);
 232
 233   g_array_free (garray, TRUE);
 234 }
 235
 236 static void
 237 array_ref_count (void)
 238 {
 239   GArray *garray;
 240   GArray *garray2;
 241   gint i;
 242
 243   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 244   g_assert_cmpint (g_array_get_element_size (garray), ==, sizeof (gint));
 245   for (i = 0; i < 100; i++)
 246     g_array_prepend_val (garray, i);
 247
 248   /* check we can ref, unref and still access the array */
 249   garray2 = g_array_ref (garray);
 250   g_assert (garray == garray2);
 251   g_array_unref (garray2);
 252   for (i = 0; i < 100; i++)
 253     g_assert_cmpint (g_array_index (garray, gint, i), ==, (100 - i - 1));
 254
 255   /* garray2 should be an empty valid GArray wrapper */
 256   garray2 = g_array_ref (garray);
 257   g_array_free (garray, TRUE);
 258
 259   g_assert_cmpint (garray2->len, ==, 0);
 260   g_array_unref (garray2);
 261 }
 262
 263 static int
 264 int_compare (gconstpointer p1, gconstpointer p2)
 265 {
 266   const gint *i1 = p1;
 267   const gint *i2 = p2;
 268
 269   return *i1 - *i2;
 270 }
 271
 272 static int
 273 int_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
 274 {
 275   const gint *i1 = p1;
 276   const gint *i2 = p2;
 277
 278   return *i1 - *i2;
 279 }
 280 static void
 281 array_sort (void)
 282 {
 283   GArray *garray;
 284   gint i;
 285   gint prev, cur;
 286
 287   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 288   for (i = 0; i < 10000; i++)
 289     {
 290       cur = g_random_int_range (0, 10000);
 291       g_array_append_val (garray, cur);
 292     }
 293   g_array_sort (garray,  int_compare);
 294
 295   prev = -1;
 296   for (i = 0; i < garray->len; i++)
 297     {
 298       cur = g_array_index (garray, gint, i);
 299       g_assert_cmpint (prev, <=, cur);
 300       prev = cur;
 301     }
 302
 303   g_array_free (garray, TRUE);
 304 }
 305
 306 static void
 307 array_sort_with_data (void)
 308 {
 309   GArray *garray;
 310   gint i;
 311   gint prev, cur;
 312
 313   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 314   for (i = 0; i < 10000; i++)
 315     {
 316       cur = g_random_int_range (0, 10000);
 317       g_array_append_val (garray, cur);
 318     }
 319   g_array_sort_with_data (garray, int_compare_data, NULL);
 320
 321   prev = -1;
 322   for (i = 0; i < garray->len; i++)
 323     {
 324       cur = g_array_index (garray, gint, i);
 325       g_assert_cmpint (prev, <=, cur);
 326       prev = cur;
 327     }
 328
 329   g_array_free (garray, TRUE);
 330 }
 331
 332 static gint num_clear_func_invocations = 0;
 333
 334 static void
 335 my_clear_func (gpointer data)
 336 {
 337   num_clear_func_invocations += 1;
 338 }
 339
 340 static void
 341 array_clear_func (void)
 342 {
 343   GArray *garray;
 344   gint i;
 345   gint cur;
 346
 347   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 348   g_array_set_clear_func (garray, my_clear_func);
 349
 350   for (i = 0; i < 10; i++)
 351     {
 352       cur = g_random_int_range (0, 100);
 353       g_array_append_val (garray, cur);
 354     }
 355
 356   g_array_remove_index (garray, 9);
 357   g_assert_cmpint (num_clear_func_invocations, ==, 1);
 358
 359   g_array_remove_range (garray, 5, 3);
 360   g_assert_cmpint (num_clear_func_invocations, ==, 4);
 361
 362   g_array_remove_index_fast (garray, 4);
 363   g_assert_cmpint (num_clear_func_invocations, ==, 5);
 364
 365   g_array_free (garray, TRUE);
 366   g_assert_cmpint (num_clear_func_invocations, ==, 10);
 367 }
 368
 369 static void
 370 pointer_array_add (void)
 371 {
 372   GPtrArray *gparray;
 373   gint i;
 374   gint sum = 0;
 375   gpointer *segment;
 376
 377   gparray = g_ptr_array_sized_new (1000);
 378
 379   for (i = 0; i < 10000; i++)
 380     g_ptr_array_add (gparray, GINT_TO_POINTER (i));
 381
 382   for (i = 0; i < 10000; i++)
 383     g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
 384
 385   g_ptr_array_foreach (gparray, sum_up, &sum);
 386   g_assert (sum == 49995000);
 387
 388   segment = g_ptr_array_free (gparray, FALSE);
 389   for (i = 0; i < 10000; i++)
 390     g_assert (segment[i] == GINT_TO_POINTER (i));
 391   g_free (segment);
 392 }
 393
 394 static void
 395 pointer_array_insert (void)
 396 {
 397   GPtrArray *gparray;
 398   gint i;
 399   gint sum = 0;
 400   gint index;
 401
 402   gparray = g_ptr_array_sized_new (1000);
 403
 404   for (i = 0; i < 10000; i++)
 405     {
 406       index = g_random_int_range (-1, i + 1);
 407       g_ptr_array_insert (gparray, index, GINT_TO_POINTER (i));
 408     }
 409
 410   g_ptr_array_foreach (gparray, sum_up, &sum);
 411   g_assert (sum == 49995000);
 412
 413   g_ptr_array_free (gparray, TRUE);
 414 }
 415
 416 static void
 417 pointer_array_ref_count (void)
 418 {
 419   GPtrArray *gparray;
 420   GPtrArray *gparray2;
 421   gint i;
 422   gint sum = 0;
 423
 424   gparray = g_ptr_array_new ();
 425   for (i = 0; i < 10000; i++)
 426     g_ptr_array_add (gparray, GINT_TO_POINTER (i));
 427
 428   /* check we can ref, unref and still access the array */
 429   gparray2 = g_ptr_array_ref (gparray);
 430   g_assert (gparray == gparray2);
 431   g_ptr_array_unref (gparray2);
 432   for (i = 0; i < 10000; i++)
 433     g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
 434
 435   g_ptr_array_foreach (gparray, sum_up, &sum);
 436   g_assert (sum == 49995000);
 437
 438   /* gparray2 should be an empty valid GPtrArray wrapper */
 439   gparray2 = g_ptr_array_ref (gparray);
 440   g_ptr_array_free (gparray, TRUE);
 441
 442   g_assert_cmpint (gparray2->len, ==, 0);
 443   g_ptr_array_unref (gparray2);
 444 }
 445
 446 static gint num_free_func_invocations = 0;
 447
 448 static void
 449 my_free_func (gpointer data)
 450 {
 451   num_free_func_invocations++;
 452   g_free (data);
 453 }
 454
 455 static void
 456 pointer_array_free_func (void)
 457 {
 458   GPtrArray *gparray;
 459   GPtrArray *gparray2;
 460   gchar **strv;
 461   gchar *s;
 462
 463   num_free_func_invocations = 0;
 464   gparray = g_ptr_array_new_with_free_func (my_free_func);
 465   g_ptr_array_unref (gparray);
 466   g_assert_cmpint (num_free_func_invocations, ==, 0);
 467
 468   gparray = g_ptr_array_new_with_free_func (my_free_func);
 469   g_ptr_array_free (gparray, TRUE);
 470   g_assert_cmpint (num_free_func_invocations, ==, 0);
 471
 472   num_free_func_invocations = 0;
 473   gparray = g_ptr_array_new_with_free_func (my_free_func);
 474   g_ptr_array_add (gparray, g_strdup ("foo"));
 475   g_ptr_array_add (gparray, g_strdup ("bar"));
 476   g_ptr_array_add (gparray, g_strdup ("baz"));
 477   g_ptr_array_remove_index (gparray, 0);
 478   g_assert_cmpint (num_free_func_invocations, ==, 1);
 479   g_ptr_array_remove_index_fast (gparray, 1);
 480   g_assert_cmpint (num_free_func_invocations, ==, 2);
 481   s = g_strdup ("frob");
 482   g_ptr_array_add (gparray, s);
 483   g_assert (g_ptr_array_remove (gparray, s));
 484   g_assert (!g_ptr_array_remove (gparray, "nuun"));
 485   g_assert (!g_ptr_array_remove_fast (gparray, "mlo"));
 486   g_assert_cmpint (num_free_func_invocations, ==, 3);
 487   s = g_strdup ("frob");
 488   g_ptr_array_add (gparray, s);
 489   g_ptr_array_set_size (gparray, 1);
 490   g_assert_cmpint (num_free_func_invocations, ==, 4);
 491   g_ptr_array_ref (gparray);
 492   g_ptr_array_unref (gparray);
 493   g_assert_cmpint (num_free_func_invocations, ==, 4);
 494   g_ptr_array_unref (gparray);
 495   g_assert_cmpint (num_free_func_invocations, ==, 5);
 496
 497   num_free_func_invocations = 0;
 498   gparray = g_ptr_array_new_full (10, my_free_func);
 499   g_ptr_array_add (gparray, g_strdup ("foo"));
 500   g_ptr_array_add (gparray, g_strdup ("bar"));
 501   g_ptr_array_add (gparray, g_strdup ("baz"));
 502   g_ptr_array_set_size (gparray, 20);
 503   g_ptr_array_add (gparray, NULL);
 504   gparray2 = g_ptr_array_ref (gparray);
 505   strv = (gchar **) g_ptr_array_free (gparray, FALSE);
 506   g_assert_cmpint (num_free_func_invocations, ==, 0);
 507   g_strfreev (strv);
 508   g_ptr_array_unref (gparray2);
 509   g_assert_cmpint (num_free_func_invocations, ==, 0);
 510
 511   num_free_func_invocations = 0;
 512   gparray = g_ptr_array_new_with_free_func (my_free_func);
 513   g_ptr_array_add (gparray, g_strdup ("foo"));
 514   g_ptr_array_add (gparray, g_strdup ("bar"));
 515   g_ptr_array_add (gparray, g_strdup ("baz"));
 516   g_ptr_array_remove_range (gparray, 1, 1);
 517   g_ptr_array_unref (gparray);
 518   g_assert_cmpint (num_free_func_invocations, ==, 3);
 519
 520   num_free_func_invocations = 0;
 521   gparray = g_ptr_array_new_with_free_func (my_free_func);
 522   g_ptr_array_add (gparray, g_strdup ("foo"));
 523   g_ptr_array_add (gparray, g_strdup ("bar"));
 524   g_ptr_array_add (gparray, g_strdup ("baz"));
 525   g_ptr_array_free (gparray, TRUE);
 526   g_assert_cmpint (num_free_func_invocations, ==, 3);
 527
 528   num_free_func_invocations = 0;
 529   gparray = g_ptr_array_new_with_free_func (my_free_func);
 530   g_ptr_array_add (gparray, "foo");
 531   g_ptr_array_add (gparray, "bar");
 532   g_ptr_array_add (gparray, "baz");
 533   g_ptr_array_set_free_func (gparray, NULL);
 534   g_ptr_array_free (gparray, TRUE);
 535   g_assert_cmpint (num_free_func_invocations, ==, 0);
 536 }
 537
 538 static gint
 539 ptr_compare (gconstpointer p1, gconstpointer p2)
 540 {
 541   gpointer i1 = *(gpointer*)p1;
 542   gpointer i2 = *(gpointer*)p2;
 543
 544   return GPOINTER_TO_INT (i1) - GPOINTER_TO_INT (i2);
 545 }
 546
 547 static gint
 548 ptr_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
 549 {
 550   gpointer i1 = *(gpointer*)p1;
 551   gpointer i2 = *(gpointer*)p2;
 552
 553   return GPOINTER_TO_INT (i1) - GPOINTER_TO_INT (i2);
 554 }
 555
 556 static void
 557 pointer_array_sort (void)
 558 {
 559   GPtrArray *gparray;
 560   gint i;
 561   gint val;
 562   gint prev, cur;
 563
 564   gparray = g_ptr_array_new ();
 565   for (i = 0; i < 10000; i++)
 566     {
 567       val = g_random_int_range (0, 10000);
 568       g_ptr_array_add (gparray, GINT_TO_POINTER (val));
 569     }
 570
 571   g_ptr_array_sort (gparray, ptr_compare);
 572
 573   prev = -1;
 574   for (i = 0; i < 10000; i++)
 575     {
 576       cur = GPOINTER_TO_INT (g_ptr_array_index (gparray, i));
 577       g_assert_cmpint (prev, <=, cur);
 578       prev = cur;
 579     }
 580
 581   g_ptr_array_free (gparray, TRUE);
 582 }
 583
 584 static void
 585 pointer_array_sort_with_data (void)
 586 {
 587   GPtrArray *gparray;
 588   gint i;
 589   gint prev, cur;
 590
 591   gparray = g_ptr_array_new ();
 592   for (i = 0; i < 10000; i++)
 593     g_ptr_array_add (gparray, GINT_TO_POINTER (g_random_int_range (0, 10000)));
 594
 595   g_ptr_array_sort_with_data (gparray, ptr_compare_data, NULL);
 596
 597   prev = -1;
 598   for (i = 0; i < 10000; i++)
 599     {
 600       cur = GPOINTER_TO_INT (g_ptr_array_index (gparray, i));
 601       g_assert_cmpint (prev, <=, cur);
 602       prev = cur;
 603     }
 604
 605   g_ptr_array_free (gparray, TRUE);
 606 }
 607
 608 static void
 609 pointer_array_find_empty (void)
 610 {
 611   GPtrArray *array;
 612   guint idx;
 613
 614   array = g_ptr_array_new ();
 615
 616   g_assert_false (g_ptr_array_find (array, "some-value", NULL));  /* NULL index */
 617   g_assert_false (g_ptr_array_find (array, "some-value", &idx));  /* non-NULL index */
 618   g_assert_false (g_ptr_array_find_with_equal_func (array, "some-value", g_str_equal, NULL));  /* NULL index */
 619   g_assert_false (g_ptr_array_find_with_equal_func (array, "some-value", g_str_equal, &idx));  /* non-NULL index */
 620
 621   g_ptr_array_free (array, TRUE);
 622 }
 623
 624 static void
 625 pointer_array_find_non_empty (void)
 626 {
 627   GPtrArray *array;
 628   guint idx;
 629   const gchar *str_pointer = "static-string";
 630
 631   array = g_ptr_array_new ();
 632
 633   g_ptr_array_add (array, "some");
 634   g_ptr_array_add (array, "random");
 635   g_ptr_array_add (array, "values");
 636   g_ptr_array_add (array, "some");
 637   g_ptr_array_add (array, "duplicated");
 638   g_ptr_array_add (array, (gpointer) str_pointer);
 639
 640   g_assert_true (g_ptr_array_find_with_equal_func (array, "random", g_str_equal, NULL));  /* NULL index */
 641   g_assert_true (g_ptr_array_find_with_equal_func (array, "random", g_str_equal, &idx));  /* non-NULL index */
 642   g_assert_cmpuint (idx, ==, 1);
 643
 644   g_assert_true (g_ptr_array_find_with_equal_func (array, "some", g_str_equal, &idx));  /* duplicate element */
 645   g_assert_cmpuint (idx, ==, 0);
 646
 647   g_assert_false (g_ptr_array_find_with_equal_func (array, "nope", g_str_equal, NULL));
 648
 649   g_assert_true (g_ptr_array_find_with_equal_func (array, str_pointer, g_str_equal, &idx));
 650   g_assert_cmpuint (idx, ==, 5);
 651   idx = G_MAXUINT;
 652   g_assert_true (g_ptr_array_find_with_equal_func (array, str_pointer, NULL, &idx));  /* NULL equal func */
 653   g_assert_cmpuint (idx, ==, 5);
 654   idx = G_MAXUINT;
 655   g_assert_true (g_ptr_array_find (array, str_pointer, &idx));  /* NULL equal func */
 656   g_assert_cmpuint (idx, ==, 5);
 657
 658   g_ptr_array_free (array, TRUE);
 659 }
 660
 661 static void
 662 byte_array_append (void)
 663 {
 664   GByteArray *gbarray;
 665   gint i;
 666   guint8 *segment;
 667
 668   gbarray = g_byte_array_sized_new (1000);
 669   for (i = 0; i < 10000; i++)
 670     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 671
 672   for (i = 0; i < 10000; i++)
 673     {
 674       g_assert (gbarray->data[4*i] == 'a');
 675       g_assert (gbarray->data[4*i+1] == 'b');
 676       g_assert (gbarray->data[4*i+2] == 'c');
 677       g_assert (gbarray->data[4*i+3] == 'd');
 678     }
 679
 680   segment = g_byte_array_free (gbarray, FALSE);
 681
 682   for (i = 0; i < 10000; i++)
 683     {
 684       g_assert (segment[4*i] == 'a');
 685       g_assert (segment[4*i+1] == 'b');
 686       g_assert (segment[4*i+2] == 'c');
 687       g_assert (segment[4*i+3] == 'd');
 688     }
 689
 690   g_free (segment);
 691 }
 692
 693 static void
 694 byte_array_prepend (void)
 695 {
 696   GByteArray *gbarray;
 697   gint i;
 698
 699   gbarray = g_byte_array_new ();
 700   g_byte_array_set_size (gbarray, 1000);
 701
 702   for (i = 0; i < 10000; i++)
 703     g_byte_array_prepend (gbarray, (guint8*) "abcd", 4);
 704
 705   for (i = 0; i < 10000; i++)
 706     {
 707       g_assert (gbarray->data[4*i] == 'a');
 708       g_assert (gbarray->data[4*i+1] == 'b');
 709       g_assert (gbarray->data[4*i+2] == 'c');
 710       g_assert (gbarray->data[4*i+3] == 'd');
 711     }
 712
 713   g_byte_array_free (gbarray, TRUE);
 714 }
 715
 716 static void
 717 byte_array_ref_count (void)
 718 {
 719   GByteArray *gbarray;
 720   GByteArray *gbarray2;
 721   gint i;
 722
 723   gbarray = g_byte_array_new ();
 724   for (i = 0; i < 10000; i++)
 725     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 726
 727   gbarray2 = g_byte_array_ref (gbarray);
 728   g_assert (gbarray2 == gbarray);
 729   g_byte_array_unref (gbarray2);
 730   for (i = 0; i < 10000; i++)
 731     {
 732       g_assert (gbarray->data[4*i] == 'a');
 733       g_assert (gbarray->data[4*i+1] == 'b');
 734       g_assert (gbarray->data[4*i+2] == 'c');
 735       g_assert (gbarray->data[4*i+3] == 'd');
 736     }
 737
 738   gbarray2 = g_byte_array_ref (gbarray);
 739   g_assert (gbarray2 == gbarray);
 740   g_byte_array_free (gbarray, TRUE);
 741   g_assert_cmpint (gbarray2->len, ==, 0);
 742   g_byte_array_unref (gbarray2);
 743 }
 744
 745 static void
 746 byte_array_remove (void)
 747 {
 748   GByteArray *gbarray;
 749   gint i;
 750
 751   gbarray = g_byte_array_new ();
 752   for (i = 0; i < 100; i++)
 753     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 754
 755   g_assert_cmpint (gbarray->len, ==, 400);
 756
 757   g_byte_array_remove_index (gbarray, 4);
 758   g_byte_array_remove_index (gbarray, 4);
 759   g_byte_array_remove_index (gbarray, 4);
 760   g_byte_array_remove_index (gbarray, 4);
 761
 762   g_assert_cmpint (gbarray->len, ==, 396);
 763
 764   for (i = 0; i < 99; i++)
 765     {
 766       g_assert (gbarray->data[4*i] == 'a');
 767       g_assert (gbarray->data[4*i+1] == 'b');
 768       g_assert (gbarray->data[4*i+2] == 'c');
 769       g_assert (gbarray->data[4*i+3] == 'd');
 770     }
 771
 772   g_byte_array_free (gbarray, TRUE);
 773 }
 774
 775 static void
 776 byte_array_remove_fast (void)
 777 {
 778   GByteArray *gbarray;
 779   gint i;
 780
 781   gbarray = g_byte_array_new ();
 782   for (i = 0; i < 100; i++)
 783     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 784
 785   g_assert_cmpint (gbarray->len, ==, 400);
 786
 787   g_byte_array_remove_index_fast (gbarray, 4);
 788   g_byte_array_remove_index_fast (gbarray, 4);
 789   g_byte_array_remove_index_fast (gbarray, 4);
 790   g_byte_array_remove_index_fast (gbarray, 4);
 791
 792   g_assert_cmpint (gbarray->len, ==, 396);
 793
 794   for (i = 0; i < 99; i++)
 795     {
 796       g_assert (gbarray->data[4*i] == 'a');
 797       g_assert (gbarray->data[4*i+1] == 'b');
 798       g_assert (gbarray->data[4*i+2] == 'c');
 799       g_assert (gbarray->data[4*i+3] == 'd');
 800     }
 801
 802   g_byte_array_free (gbarray, TRUE);
 803 }
 804
 805 static void
 806 byte_array_remove_range (void)
 807 {
 808   GByteArray *gbarray;
 809   gint i;
 810
 811   gbarray = g_byte_array_new ();
 812   for (i = 0; i < 100; i++)
 813     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 814
 815   g_assert_cmpint (gbarray->len, ==, 400);
 816
 817   g_byte_array_remove_range (gbarray, 12, 4);
 818
 819   g_assert_cmpint (gbarray->len, ==, 396);
 820
 821   for (i = 0; i < 99; i++)
 822     {
 823       g_assert (gbarray->data[4*i] == 'a');
 824       g_assert (gbarray->data[4*i+1] == 'b');
 825       g_assert (gbarray->data[4*i+2] == 'c');
 826       g_assert (gbarray->data[4*i+3] == 'd');
 827     }
 828
 829   /* Ensure the entire array can be cleared, even when empty. */
 830   g_byte_array_remove_range (gbarray, 0, gbarray->len);
 831   g_byte_array_remove_range (gbarray, 0, gbarray->len);
 832
 833   g_byte_array_free (gbarray, TRUE);
 834 }
 835
 836 static int
 837 byte_compare (gconstpointer p1, gconstpointer p2)
 838 {
 839   const guint8 *i1 = p1;
 840   const guint8 *i2 = p2;
 841
 842   return *i1 - *i2;
 843 }
 844
 845 static int
 846 byte_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
 847 {
 848   const guint8 *i1 = p1;
 849   const guint8 *i2 = p2;
 850
 851   return *i1 - *i2;
 852 }
 853
 854 static void
 855 byte_array_sort (void)
 856 {
 857   GByteArray *gbarray;
 858   gint i;
 859   guint8 val;
 860   guint8 prev, cur;
 861
 862   gbarray = g_byte_array_new ();
 863   for (i = 0; i < 100; i++)
 864     {
 865       val = 'a' + g_random_int_range (0, 26);
 866       g_byte_array_append (gbarray, (guint8*) &val, 1);
 867     }
 868
 869   g_byte_array_sort (gbarray, byte_compare);
 870
 871   prev = 'a';
 872   for (i = 0; i < gbarray->len; i++)
 873     {
 874       cur = gbarray->data[i];
 875       g_assert_cmpint (prev, <=, cur);
 876       prev = cur;
 877     }
 878
 879   g_byte_array_free (gbarray, TRUE);
 880 }
 881
 882 static void
 883 byte_array_sort_with_data (void)
 884 {
 885   GByteArray *gbarray;
 886   gint i;
 887   guint8 val;
 888   guint8 prev, cur;
 889
 890   gbarray = g_byte_array_new ();
 891   for (i = 0; i < 100; i++)
 892     {
 893       val = 'a' + g_random_int_range (0, 26);
 894       g_byte_array_append (gbarray, (guint8*) &val, 1);
 895     }
 896
 897   g_byte_array_sort_with_data (gbarray, byte_compare_data, NULL);
 898
 899   prev = 'a';
 900   for (i = 0; i < gbarray->len; i++)
 901     {
 902       cur = gbarray->data[i];
 903       g_assert_cmpint (prev, <=, cur);
 904       prev = cur;
 905     }
 906
 907   g_byte_array_free (gbarray, TRUE);
 908 }
 909
 910 static void
 911 byte_array_new_take (void)
 912 {
 913   GByteArray *gbarray;
 914   guint8 *data;
 915
 916   data = g_memdup ("woooweeewow", 11);
 917   gbarray = g_byte_array_new_take (data, 11);
 918   g_assert (gbarray->data == data);
 919   g_assert_cmpuint (gbarray->len, ==, 11);
 920   g_byte_array_free (gbarray, TRUE);
 921 }
 922
 923 static void
 924 byte_array_free_to_bytes (void)
 925 {
 926   GByteArray *gbarray;
 927   gpointer memory;
 928   GBytes *bytes;
 929   gsize size;
 930
 931   gbarray = g_byte_array_new ();
 932   g_byte_array_append (gbarray, (guint8 *)"woooweeewow", 11);
 933   memory = gbarray->data;
 934
 935   bytes = g_byte_array_free_to_bytes (gbarray);
 936   g_assert (bytes != NULL);
 937   g_assert_cmpuint (g_bytes_get_size (bytes), ==, 11);
 938   g_assert (g_bytes_get_data (bytes, &size) == memory);
 939   g_assert_cmpuint (size, ==, 11);
 940
 941   g_bytes_unref (bytes);
 942 }
 943 int
 944 main (int argc, char *argv[])
 945 {
 946   g_test_init (&argc, &argv, NULL);
 947
 948   g_test_bug_base ("https://bugzilla.gnome.org/");
 949
 950   /* array tests */
 951   g_test_add_func ("/array/new/cleared", array_new_cleared);
 952   g_test_add_func ("/array/new/sized-cleared", array_new_sized_cleared);
 953   g_test_add_func ("/array/new/zero-terminated", array_new_zero_terminated);
 954   g_test_add_func ("/array/append", array_append);
 955   g_test_add_func ("/array/prepend", array_prepend);
 956   g_test_add_func ("/array/remove", array_remove);
 957   g_test_add_func ("/array/remove-fast", array_remove_fast);
 958   g_test_add_func ("/array/remove-range", array_remove_range);
 959   g_test_add_func ("/array/ref-count", array_ref_count);
 960   g_test_add_func ("/array/sort", array_sort);
 961   g_test_add_func ("/array/sort-with-data", array_sort_with_data);
 962   g_test_add_func ("/array/clear-func", array_clear_func);
 963
 964   /* pointer arrays */
 965   g_test_add_func ("/pointerarray/add", pointer_array_add);
 966   g_test_add_func ("/pointerarray/insert", pointer_array_insert);
 967   g_test_add_func ("/pointerarray/ref-count", pointer_array_ref_count);
 968   g_test_add_func ("/pointerarray/free-func", pointer_array_free_func);
 969   g_test_add_func ("/pointerarray/sort", pointer_array_sort);
 970   g_test_add_func ("/pointerarray/sort-with-data", pointer_array_sort_with_data);
 971   g_test_add_func ("/pointerarray/find/empty", pointer_array_find_empty);
 972   g_test_add_func ("/pointerarray/find/non-empty", pointer_array_find_non_empty);
 973
 974   /* byte arrays */
 975   g_test_add_func ("/bytearray/append", byte_array_append);
 976   g_test_add_func ("/bytearray/prepend", byte_array_prepend);
 977   g_test_add_func ("/bytearray/remove", byte_array_remove);
 978   g_test_add_func ("/bytearray/remove-fast", byte_array_remove_fast);
 979   g_test_add_func ("/bytearray/remove-range", byte_array_remove_range);
 980   g_test_add_func ("/bytearray/ref-count", byte_array_ref_count);
 981   g_test_add_func ("/bytearray/sort", byte_array_sort);
 982   g_test_add_func ("/bytearray/sort-with-data", byte_array_sort_with_data);
 983   g_test_add_func ("/bytearray/new-take", byte_array_new_take);
 984   g_test_add_func ("/bytearray/free-to-bytes", byte_array_free_to_bytes);
 985
 986   return g_test_run ();
 987 }
 988