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 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 static void
  43 array_append (void)
  44 {
  45   GArray *garray;
  46   gint i;
  47   gint *segment;
  48
  49   garray = g_array_new (FALSE, FALSE, sizeof (gint));
  50   for (i = 0; i < 10000; i++)
  51     g_array_append_val (garray, i);
  52
  53   for (i = 0; i < 10000; i++)
  54     g_assert_cmpint (g_array_index (garray, gint, i), ==, i);
  55
  56   segment = (gint*)g_array_free (garray, FALSE);
  57   for (i = 0; i < 10000; i++)
  58     g_assert_cmpint (segment[i], ==, i);
  59   g_free (segment);
  60 }
  61
  62 static void
  63 array_prepend (void)
  64 {
  65   GArray *garray;
  66   gint i;
  67
  68   garray = g_array_new (FALSE, FALSE, sizeof (gint));
  69   for (i = 0; i < 100; i++)
  70     g_array_prepend_val (garray, i);
  71
  72   for (i = 0; i < 100; i++)
  73     g_assert_cmpint (g_array_index (garray, gint, i), ==, (100 - i - 1));
  74
  75   g_array_free (garray, TRUE);
  76 }
  77
  78 static void
  79 array_remove (void)
  80 {
  81   GArray *garray;
  82   gint i;
  83   gint prev, cur;
  84
  85   garray = g_array_new (FALSE, FALSE, sizeof (gint));
  86   for (i = 0; i < 100; i++)
  87     g_array_append_val (garray, i);
  88
  89   g_assert_cmpint (garray->len, ==, 100);
  90
  91   g_array_remove_index (garray, 1);
  92   g_array_remove_index (garray, 3);
  93   g_array_remove_index (garray, 21);
  94   g_array_remove_index (garray, 57);
  95
  96   g_assert_cmpint (garray->len, ==, 96);
  97
  98   prev = -1;
  99   for (i = 0; i < garray->len; i++)
 100     {
 101       cur = g_array_index (garray, gint, i);
 102       g_assert (cur != 1 &&  cur != 4 && cur != 23 && cur != 60);
 103       g_assert_cmpint (prev, <, cur);
 104       prev = cur;
 105     }
 106
 107   g_array_free (garray, TRUE);
 108 }
 109
 110 static void
 111 array_remove_fast (void)
 112 {
 113   GArray *garray;
 114   gint i;
 115   gint prev, cur;
 116
 117   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 118   for (i = 0; i < 100; i++)
 119     g_array_append_val (garray, i);
 120
 121   g_assert_cmpint (garray->len, ==, 100);
 122
 123   g_array_remove_index_fast (garray, 1);
 124   g_array_remove_index_fast (garray, 3);
 125   g_array_remove_index_fast (garray, 21);
 126   g_array_remove_index_fast (garray, 57);
 127
 128   g_assert_cmpint (garray->len, ==, 96);
 129
 130   prev = -1;
 131   for (i = 0; i < garray->len; i++)
 132     {
 133       cur = g_array_index (garray, gint, i);
 134       g_assert (cur != 1 &&  cur != 3 && cur != 21 && cur != 57);
 135       if (cur < 96)
 136         {
 137           g_assert_cmpint (prev, <, cur);
 138           prev = cur;
 139         }
 140     }
 141
 142   g_array_free (garray, TRUE);
 143 }
 144
 145 static void
 146 array_remove_range (void)
 147 {
 148   GArray *garray;
 149   gint i;
 150   gint prev, cur;
 151
 152   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 153   for (i = 0; i < 100; i++)
 154     g_array_append_val (garray, i);
 155
 156   g_assert_cmpint (garray->len, ==, 100);
 157
 158   g_array_remove_range (garray, 31, 4);
 159
 160   g_assert_cmpint (garray->len, ==, 96);
 161
 162   prev = -1;
 163   for (i = 0; i < garray->len; i++)
 164     {
 165       cur = g_array_index (garray, gint, i);
 166       g_assert (cur < 31 || cur > 34);
 167       g_assert_cmpint (prev, <, cur);
 168       prev = cur;
 169     }
 170
 171   g_array_free (garray, TRUE);
 172 }
 173
 174 static void
 175 array_ref_count (void)
 176 {
 177   GArray *garray;
 178   GArray *garray2;
 179   gint i;
 180
 181   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 182   g_assert_cmpint (g_array_get_element_size (garray), ==, sizeof (gint));
 183   for (i = 0; i < 100; i++)
 184     g_array_prepend_val (garray, i);
 185
 186   /* check we can ref, unref and still access the array */
 187   garray2 = g_array_ref (garray);
 188   g_assert (garray == garray2);
 189   g_array_unref (garray2);
 190   for (i = 0; i < 100; i++)
 191     g_assert_cmpint (g_array_index (garray, gint, i), ==, (100 - i - 1));
 192
 193   /* garray2 should be an empty valid GArray wrapper */
 194   garray2 = g_array_ref (garray);
 195   g_array_free (garray, TRUE);
 196
 197   g_assert_cmpint (garray2->len, ==, 0);
 198   g_array_unref (garray2);
 199 }
 200
 201 static gpointer
 202 array_large_size_remalloc_impl (gpointer mem,
 203                                 gsize n_bytes)
 204 {
 205   /* We only care that g_array_set_size() doesn't hang before
 206    * calling g_realloc(). So if we got here, we already won.
 207    */
 208   exit (0);
 209 }
 210
 211 static GMemVTable array_large_size_mem_vtable = {
 212   malloc, array_large_size_remalloc_impl, free,
 213   NULL, NULL, NULL
 214 };
 215
 216 static void
 217 array_large_size (void)
 218 {
 219   g_test_bug ("568760");
 220
 221   if (g_test_subprocess ())
 222     {
 223       GArray *array;
 224
 225       array = g_array_new (FALSE, FALSE, sizeof (char));
 226
 227       g_mem_set_vtable (&array_large_size_mem_vtable);
 228       g_array_set_size (array, 1073750016);
 229       g_assert_not_reached ();
 230       return;
 231     }
 232
 233   g_test_trap_subprocess (NULL, 5000000, 0);
 234   g_test_trap_assert_passed ();
 235 }
 236
 237 static int
 238 int_compare (gconstpointer p1, gconstpointer p2)
 239 {
 240   const gint *i1 = p1;
 241   const gint *i2 = p2;
 242
 243   return *i1 - *i2;
 244 }
 245
 246 static int
 247 int_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
 248 {
 249   const gint *i1 = p1;
 250   const gint *i2 = p2;
 251
 252   return *i1 - *i2;
 253 }
 254 static void
 255 array_sort (void)
 256 {
 257   GArray *garray;
 258   gint i;
 259   gint prev, cur;
 260
 261   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 262   for (i = 0; i < 10000; i++)
 263     {
 264       cur = g_random_int_range (0, 10000);
 265       g_array_append_val (garray, cur);
 266     }
 267   g_array_sort (garray,  int_compare);
 268
 269   prev = -1;
 270   for (i = 0; i < garray->len; i++)
 271     {
 272       cur = g_array_index (garray, gint, i);
 273       g_assert_cmpint (prev, <=, cur);
 274       prev = cur;
 275     }
 276
 277   g_array_free (garray, TRUE);
 278 }
 279
 280 static void
 281 array_sort_with_data (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_with_data (garray, int_compare_data, NULL);
 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 gint num_clear_func_invocations = 0;
 307
 308 static void
 309 my_clear_func (gpointer data)
 310 {
 311   num_clear_func_invocations += 1;
 312 }
 313
 314 static void
 315 array_clear_func (void)
 316 {
 317   GArray *garray;
 318   gint i;
 319   gint cur;
 320
 321   garray = g_array_new (FALSE, FALSE, sizeof (gint));
 322   g_array_set_clear_func (garray, my_clear_func);
 323
 324   for (i = 0; i < 10; i++)
 325     {
 326       cur = g_random_int_range (0, 100);
 327       g_array_append_val (garray, cur);
 328     }
 329
 330   g_array_remove_index (garray, 9);
 331   g_assert_cmpint (num_clear_func_invocations, ==, 1);
 332
 333   g_array_remove_range (garray, 5, 3);
 334   g_assert_cmpint (num_clear_func_invocations, ==, 4);
 335
 336   g_array_remove_index_fast (garray, 4);
 337   g_assert_cmpint (num_clear_func_invocations, ==, 5);
 338
 339   g_array_free (garray, TRUE);
 340   g_assert_cmpint (num_clear_func_invocations, ==, 10);
 341 }
 342
 343 static void
 344 pointer_array_add (void)
 345 {
 346   GPtrArray *gparray;
 347   gint i;
 348   gint sum = 0;
 349   gpointer *segment;
 350
 351   gparray = g_ptr_array_sized_new (1000);
 352
 353   for (i = 0; i < 10000; i++)
 354     g_ptr_array_add (gparray, GINT_TO_POINTER (i));
 355
 356   for (i = 0; i < 10000; i++)
 357     g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
 358
 359   g_ptr_array_foreach (gparray, sum_up, &sum);
 360   g_assert (sum == 49995000);
 361
 362   segment = g_ptr_array_free (gparray, FALSE);
 363   for (i = 0; i < 10000; i++)
 364     g_assert (segment[i] == GINT_TO_POINTER (i));
 365   g_free (segment);
 366 }
 367
 368 static void
 369 pointer_array_insert (void)
 370 {
 371   GPtrArray *gparray;
 372   gint i;
 373   gint sum = 0;
 374   gint index;
 375
 376   gparray = g_ptr_array_sized_new (1000);
 377
 378   for (i = 0; i < 10000; i++)
 379     {
 380       index = g_random_int_range (-1, i + 1);
 381       g_ptr_array_insert (gparray, index, GINT_TO_POINTER (i));
 382     }
 383
 384   g_ptr_array_foreach (gparray, sum_up, &sum);
 385   g_assert (sum == 49995000);
 386
 387   g_ptr_array_free (gparray, TRUE);
 388 }
 389
 390 static void
 391 pointer_array_ref_count (void)
 392 {
 393   GPtrArray *gparray;
 394   GPtrArray *gparray2;
 395   gint i;
 396   gint sum = 0;
 397
 398   gparray = g_ptr_array_new ();
 399   for (i = 0; i < 10000; i++)
 400     g_ptr_array_add (gparray, GINT_TO_POINTER (i));
 401
 402   /* check we can ref, unref and still access the array */
 403   gparray2 = g_ptr_array_ref (gparray);
 404   g_assert (gparray == gparray2);
 405   g_ptr_array_unref (gparray2);
 406   for (i = 0; i < 10000; i++)
 407     g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
 408
 409   g_ptr_array_foreach (gparray, sum_up, &sum);
 410   g_assert (sum == 49995000);
 411
 412   /* gparray2 should be an empty valid GPtrArray wrapper */
 413   gparray2 = g_ptr_array_ref (gparray);
 414   g_ptr_array_free (gparray, TRUE);
 415
 416   g_assert_cmpint (gparray2->len, ==, 0);
 417   g_ptr_array_unref (gparray2);
 418 }
 419
 420 static gint num_free_func_invocations = 0;
 421
 422 static void
 423 my_free_func (gpointer data)
 424 {
 425   num_free_func_invocations++;
 426   g_free (data);
 427 }
 428
 429 static void
 430 pointer_array_free_func (void)
 431 {
 432   GPtrArray *gparray;
 433   GPtrArray *gparray2;
 434   gchar **strv;
 435   gchar *s;
 436
 437   num_free_func_invocations = 0;
 438   gparray = g_ptr_array_new_with_free_func (my_free_func);
 439   g_ptr_array_unref (gparray);
 440   g_assert_cmpint (num_free_func_invocations, ==, 0);
 441
 442   gparray = g_ptr_array_new_with_free_func (my_free_func);
 443   g_ptr_array_free (gparray, TRUE);
 444   g_assert_cmpint (num_free_func_invocations, ==, 0);
 445
 446   num_free_func_invocations = 0;
 447   gparray = g_ptr_array_new_with_free_func (my_free_func);
 448   g_ptr_array_add (gparray, g_strdup ("foo"));
 449   g_ptr_array_add (gparray, g_strdup ("bar"));
 450   g_ptr_array_add (gparray, g_strdup ("baz"));
 451   g_ptr_array_remove_index (gparray, 0);
 452   g_assert_cmpint (num_free_func_invocations, ==, 1);
 453   g_ptr_array_remove_index_fast (gparray, 1);
 454   g_assert_cmpint (num_free_func_invocations, ==, 2);
 455   s = g_strdup ("frob");
 456   g_ptr_array_add (gparray, s);
 457   g_assert (g_ptr_array_remove (gparray, s));
 458   g_assert (!g_ptr_array_remove (gparray, "nuun"));
 459   g_assert (!g_ptr_array_remove_fast (gparray, "mlo"));
 460   g_assert_cmpint (num_free_func_invocations, ==, 3);
 461   s = g_strdup ("frob");
 462   g_ptr_array_add (gparray, s);
 463   g_ptr_array_set_size (gparray, 1);
 464   g_assert_cmpint (num_free_func_invocations, ==, 4);
 465   g_ptr_array_ref (gparray);
 466   g_ptr_array_unref (gparray);
 467   g_assert_cmpint (num_free_func_invocations, ==, 4);
 468   g_ptr_array_unref (gparray);
 469   g_assert_cmpint (num_free_func_invocations, ==, 5);
 470
 471   num_free_func_invocations = 0;
 472   gparray = g_ptr_array_new_full (10, my_free_func);
 473   g_ptr_array_add (gparray, g_strdup ("foo"));
 474   g_ptr_array_add (gparray, g_strdup ("bar"));
 475   g_ptr_array_add (gparray, g_strdup ("baz"));
 476   g_ptr_array_set_size (gparray, 20);
 477   g_ptr_array_add (gparray, NULL);
 478   gparray2 = g_ptr_array_ref (gparray);
 479   strv = (gchar **) g_ptr_array_free (gparray, FALSE);
 480   g_assert_cmpint (num_free_func_invocations, ==, 0);
 481   g_strfreev (strv);
 482   g_ptr_array_unref (gparray2);
 483   g_assert_cmpint (num_free_func_invocations, ==, 0);
 484
 485   num_free_func_invocations = 0;
 486   gparray = g_ptr_array_new_with_free_func (my_free_func);
 487   g_ptr_array_add (gparray, g_strdup ("foo"));
 488   g_ptr_array_add (gparray, g_strdup ("bar"));
 489   g_ptr_array_add (gparray, g_strdup ("baz"));
 490   g_ptr_array_remove_range (gparray, 1, 1);
 491   g_ptr_array_unref (gparray);
 492   g_assert_cmpint (num_free_func_invocations, ==, 3);
 493
 494   num_free_func_invocations = 0;
 495   gparray = g_ptr_array_new_with_free_func (my_free_func);
 496   g_ptr_array_add (gparray, g_strdup ("foo"));
 497   g_ptr_array_add (gparray, g_strdup ("bar"));
 498   g_ptr_array_add (gparray, g_strdup ("baz"));
 499   g_ptr_array_free (gparray, TRUE);
 500   g_assert_cmpint (num_free_func_invocations, ==, 3);
 501
 502   num_free_func_invocations = 0;
 503   gparray = g_ptr_array_new_with_free_func (my_free_func);
 504   g_ptr_array_add (gparray, "foo");
 505   g_ptr_array_add (gparray, "bar");
 506   g_ptr_array_add (gparray, "baz");
 507   g_ptr_array_set_free_func (gparray, NULL);
 508   g_ptr_array_free (gparray, TRUE);
 509   g_assert_cmpint (num_free_func_invocations, ==, 0);
 510 }
 511
 512 static gint
 513 ptr_compare (gconstpointer p1, gconstpointer p2)
 514 {
 515   gpointer i1 = *(gpointer*)p1;
 516   gpointer i2 = *(gpointer*)p2;
 517
 518   return GPOINTER_TO_INT (i1) - GPOINTER_TO_INT (i2);
 519 }
 520
 521 static gint
 522 ptr_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
 523 {
 524   gpointer i1 = *(gpointer*)p1;
 525   gpointer i2 = *(gpointer*)p2;
 526
 527   return GPOINTER_TO_INT (i1) - GPOINTER_TO_INT (i2);
 528 }
 529
 530 static void
 531 pointer_array_sort (void)
 532 {
 533   GPtrArray *gparray;
 534   gint i;
 535   gint val;
 536   gint prev, cur;
 537
 538   gparray = g_ptr_array_new ();
 539   for (i = 0; i < 10000; i++)
 540     {
 541       val = g_random_int_range (0, 10000);
 542       g_ptr_array_add (gparray, GINT_TO_POINTER (val));
 543     }
 544
 545   g_ptr_array_sort (gparray, ptr_compare);
 546
 547   prev = -1;
 548   for (i = 0; i < 10000; i++)
 549     {
 550       cur = GPOINTER_TO_INT (g_ptr_array_index (gparray, i));
 551       g_assert_cmpint (prev, <=, cur);
 552       prev = cur;
 553     }
 554
 555   g_ptr_array_free (gparray, TRUE);
 556 }
 557
 558 static void
 559 pointer_array_sort_with_data (void)
 560 {
 561   GPtrArray *gparray;
 562   gint i;
 563   gint prev, cur;
 564
 565   gparray = g_ptr_array_new ();
 566   for (i = 0; i < 10000; i++)
 567     g_ptr_array_add (gparray, GINT_TO_POINTER (g_random_int_range (0, 10000)));
 568
 569   g_ptr_array_sort_with_data (gparray, ptr_compare_data, NULL);
 570
 571   prev = -1;
 572   for (i = 0; i < 10000; i++)
 573     {
 574       cur = GPOINTER_TO_INT (g_ptr_array_index (gparray, i));
 575       g_assert_cmpint (prev, <=, cur);
 576       prev = cur;
 577     }
 578
 579   g_ptr_array_free (gparray, TRUE);
 580 }
 581
 582 static void
 583 byte_array_append (void)
 584 {
 585   GByteArray *gbarray;
 586   gint i;
 587   guint8 *segment;
 588
 589   gbarray = g_byte_array_sized_new (1000);
 590   for (i = 0; i < 10000; i++)
 591     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 592
 593   for (i = 0; i < 10000; i++)
 594     {
 595       g_assert (gbarray->data[4*i] == 'a');
 596       g_assert (gbarray->data[4*i+1] == 'b');
 597       g_assert (gbarray->data[4*i+2] == 'c');
 598       g_assert (gbarray->data[4*i+3] == 'd');
 599     }
 600
 601   segment = g_byte_array_free (gbarray, FALSE);
 602
 603   for (i = 0; i < 10000; i++)
 604     {
 605       g_assert (segment[4*i] == 'a');
 606       g_assert (segment[4*i+1] == 'b');
 607       g_assert (segment[4*i+2] == 'c');
 608       g_assert (segment[4*i+3] == 'd');
 609     }
 610
 611   g_free (segment);
 612 }
 613
 614 static void
 615 byte_array_prepend (void)
 616 {
 617   GByteArray *gbarray;
 618   gint i;
 619
 620   gbarray = g_byte_array_new ();
 621   g_byte_array_set_size (gbarray, 1000);
 622
 623   for (i = 0; i < 10000; i++)
 624     g_byte_array_prepend (gbarray, (guint8*) "abcd", 4);
 625
 626   for (i = 0; i < 10000; i++)
 627     {
 628       g_assert (gbarray->data[4*i] == 'a');
 629       g_assert (gbarray->data[4*i+1] == 'b');
 630       g_assert (gbarray->data[4*i+2] == 'c');
 631       g_assert (gbarray->data[4*i+3] == 'd');
 632     }
 633
 634   g_byte_array_free (gbarray, TRUE);
 635 }
 636
 637 static void
 638 byte_array_ref_count (void)
 639 {
 640   GByteArray *gbarray;
 641   GByteArray *gbarray2;
 642   gint i;
 643
 644   gbarray = g_byte_array_new ();
 645   for (i = 0; i < 10000; i++)
 646     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 647
 648   gbarray2 = g_byte_array_ref (gbarray);
 649   g_assert (gbarray2 == gbarray);
 650   g_byte_array_unref (gbarray2);
 651   for (i = 0; i < 10000; i++)
 652     {
 653       g_assert (gbarray->data[4*i] == 'a');
 654       g_assert (gbarray->data[4*i+1] == 'b');
 655       g_assert (gbarray->data[4*i+2] == 'c');
 656       g_assert (gbarray->data[4*i+3] == 'd');
 657     }
 658
 659   gbarray2 = g_byte_array_ref (gbarray);
 660   g_assert (gbarray2 == gbarray);
 661   g_byte_array_free (gbarray, TRUE);
 662   g_assert_cmpint (gbarray2->len, ==, 0);
 663   g_byte_array_unref (gbarray2);
 664 }
 665
 666 static void
 667 byte_array_remove (void)
 668 {
 669   GByteArray *gbarray;
 670   gint i;
 671
 672   gbarray = g_byte_array_new ();
 673   for (i = 0; i < 100; i++)
 674     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 675
 676   g_assert_cmpint (gbarray->len, ==, 400);
 677
 678   g_byte_array_remove_index (gbarray, 4);
 679   g_byte_array_remove_index (gbarray, 4);
 680   g_byte_array_remove_index (gbarray, 4);
 681   g_byte_array_remove_index (gbarray, 4);
 682
 683   g_assert_cmpint (gbarray->len, ==, 396);
 684
 685   for (i = 0; i < 99; i++)
 686     {
 687       g_assert (gbarray->data[4*i] == 'a');
 688       g_assert (gbarray->data[4*i+1] == 'b');
 689       g_assert (gbarray->data[4*i+2] == 'c');
 690       g_assert (gbarray->data[4*i+3] == 'd');
 691     }
 692
 693   g_byte_array_free (gbarray, TRUE);
 694 }
 695
 696 static void
 697 byte_array_remove_fast (void)
 698 {
 699   GByteArray *gbarray;
 700   gint i;
 701
 702   gbarray = g_byte_array_new ();
 703   for (i = 0; i < 100; i++)
 704     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 705
 706   g_assert_cmpint (gbarray->len, ==, 400);
 707
 708   g_byte_array_remove_index_fast (gbarray, 4);
 709   g_byte_array_remove_index_fast (gbarray, 4);
 710   g_byte_array_remove_index_fast (gbarray, 4);
 711   g_byte_array_remove_index_fast (gbarray, 4);
 712
 713   g_assert_cmpint (gbarray->len, ==, 396);
 714
 715   for (i = 0; i < 99; i++)
 716     {
 717       g_assert (gbarray->data[4*i] == 'a');
 718       g_assert (gbarray->data[4*i+1] == 'b');
 719       g_assert (gbarray->data[4*i+2] == 'c');
 720       g_assert (gbarray->data[4*i+3] == 'd');
 721     }
 722
 723   g_byte_array_free (gbarray, TRUE);
 724 }
 725
 726 static void
 727 byte_array_remove_range (void)
 728 {
 729   GByteArray *gbarray;
 730   gint i;
 731
 732   gbarray = g_byte_array_new ();
 733   for (i = 0; i < 100; i++)
 734     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 735
 736   g_assert_cmpint (gbarray->len, ==, 400);
 737
 738   g_byte_array_remove_range (gbarray, 12, 4);
 739
 740   g_assert_cmpint (gbarray->len, ==, 396);
 741
 742   for (i = 0; i < 99; i++)
 743     {
 744       g_assert (gbarray->data[4*i] == 'a');
 745       g_assert (gbarray->data[4*i+1] == 'b');
 746       g_assert (gbarray->data[4*i+2] == 'c');
 747       g_assert (gbarray->data[4*i+3] == 'd');
 748     }
 749
 750   g_byte_array_free (gbarray, TRUE);
 751 }
 752
 753 static int
 754 byte_compare (gconstpointer p1, gconstpointer p2)
 755 {
 756   const guint8 *i1 = p1;
 757   const guint8 *i2 = p2;
 758
 759   return *i1 - *i2;
 760 }
 761
 762 static int
 763 byte_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
 764 {
 765   const guint8 *i1 = p1;
 766   const guint8 *i2 = p2;
 767
 768   return *i1 - *i2;
 769 }
 770
 771 static void
 772 byte_array_sort (void)
 773 {
 774   GByteArray *gbarray;
 775   gint i;
 776   guint8 val;
 777   guint8 prev, cur;
 778
 779   gbarray = g_byte_array_new ();
 780   for (i = 0; i < 100; i++)
 781     {
 782       val = 'a' + g_random_int_range (0, 26);
 783       g_byte_array_append (gbarray, (guint8*) &val, 1);
 784     }
 785
 786   g_byte_array_sort (gbarray, byte_compare);
 787
 788   prev = 'a';
 789   for (i = 0; i < gbarray->len; i++)
 790     {
 791       cur = gbarray->data[i];
 792       g_assert_cmpint (prev, <=, cur);
 793       prev = cur;
 794     }
 795
 796   g_byte_array_free (gbarray, TRUE);
 797 }
 798
 799 static void
 800 byte_array_sort_with_data (void)
 801 {
 802   GByteArray *gbarray;
 803   gint i;
 804   guint8 val;
 805   guint8 prev, cur;
 806
 807   gbarray = g_byte_array_new ();
 808   for (i = 0; i < 100; i++)
 809     {
 810       val = 'a' + g_random_int_range (0, 26);
 811       g_byte_array_append (gbarray, (guint8*) &val, 1);
 812     }
 813
 814   g_byte_array_sort_with_data (gbarray, byte_compare_data, NULL);
 815
 816   prev = 'a';
 817   for (i = 0; i < gbarray->len; i++)
 818     {
 819       cur = gbarray->data[i];
 820       g_assert_cmpint (prev, <=, cur);
 821       prev = cur;
 822     }
 823
 824   g_byte_array_free (gbarray, TRUE);
 825 }
 826
 827 static void
 828 byte_array_new_take (void)
 829 {
 830   GByteArray *gbarray;
 831   guint8 *data;
 832
 833   data = g_memdup ("woooweeewow", 11);
 834   gbarray = g_byte_array_new_take (data, 11);
 835   g_assert (gbarray->data == data);
 836   g_assert_cmpuint (gbarray->len, ==, 11);
 837   g_byte_array_free (gbarray, TRUE);
 838 }
 839
 840 static void
 841 byte_array_free_to_bytes (void)
 842 {
 843   GByteArray *gbarray;
 844   gpointer memory;
 845   GBytes *bytes;
 846   gsize size;
 847
 848   gbarray = g_byte_array_new ();
 849   g_byte_array_append (gbarray, (guint8 *)"woooweeewow", 11);
 850   memory = gbarray->data;
 851
 852   bytes = g_byte_array_free_to_bytes (gbarray);
 853   g_assert (bytes != NULL);
 854   g_assert_cmpuint (g_bytes_get_size (bytes), ==, 11);
 855   g_assert (g_bytes_get_data (bytes, &size) == memory);
 856   g_assert_cmpuint (size, ==, 11);
 857
 858   g_bytes_unref (bytes);
 859 }
 860 int
 861 main (int argc, char *argv[])
 862 {
 863   g_test_init (&argc, &argv, NULL);
 864
 865   g_test_bug_base ("http://bugs.gnome.org/");
 866
 867   /* array tests */
 868   g_test_add_func ("/array/append", array_append);
 869   g_test_add_func ("/array/prepend", array_prepend);
 870   g_test_add_func ("/array/remove", array_remove);
 871   g_test_add_func ("/array/remove-fast", array_remove_fast);
 872   g_test_add_func ("/array/remove-range", array_remove_range);
 873   g_test_add_func ("/array/ref-count", array_ref_count);
 874   g_test_add_func ("/array/large-size", array_large_size);
 875   g_test_add_func ("/array/sort", array_sort);
 876   g_test_add_func ("/array/sort-with-data", array_sort_with_data);
 877   g_test_add_func ("/array/clear-func", array_clear_func);
 878
 879   /* pointer arrays */
 880   g_test_add_func ("/pointerarray/add", pointer_array_add);
 881   g_test_add_func ("/pointerarray/insert", pointer_array_insert);
 882   g_test_add_func ("/pointerarray/ref-count", pointer_array_ref_count);
 883   g_test_add_func ("/pointerarray/free-func", pointer_array_free_func);
 884   g_test_add_func ("/pointerarray/sort", pointer_array_sort);
 885   g_test_add_func ("/pointerarray/sort-with-data", pointer_array_sort_with_data);
 886
 887   /* byte arrays */
 888   g_test_add_func ("/bytearray/append", byte_array_append);
 889   g_test_add_func ("/bytearray/prepend", byte_array_prepend);
 890   g_test_add_func ("/bytearray/remove", byte_array_remove);
 891   g_test_add_func ("/bytearray/remove-fast", byte_array_remove_fast);
 892   g_test_add_func ("/bytearray/remove-range", byte_array_remove_range);
 893   g_test_add_func ("/bytearray/ref-count", byte_array_ref_count);
 894   g_test_add_func ("/bytearray/sort", byte_array_sort);
 895   g_test_add_func ("/bytearray/sort-with-data", byte_array_sort_with_data);
 896   g_test_add_func ("/bytearray/new-take", byte_array_new_take);
 897   g_test_add_func ("/bytearray/free-to-bytes", byte_array_free_to_bytes);
 898
 899   return g_test_run ();
 900 }
 901