1 /* GLIB - Library of useful routines for C programming
2 * Copyright (C) 1995-1997 Peter Mattis, Spencer Kimball and Josh MacDonald
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.
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.
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/>.
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/.
25 #undef G_DISABLE_ASSERT
34 sum_up (gpointer data,
37 gint *sum = (gint *)user_data;
39 *sum += GPOINTER_TO_INT (data);
49 garray = g_array_new (FALSE, FALSE, sizeof (gint));
50 for (i = 0; i < 10000; i++)
51 g_array_append_val (garray, i);
53 for (i = 0; i < 10000; i++)
54 g_assert_cmpint (g_array_index (garray, gint, i), ==, i);
56 segment = (gint*)g_array_free (garray, FALSE);
57 for (i = 0; i < 10000; i++)
58 g_assert_cmpint (segment[i], ==, i);
68 garray = g_array_new (FALSE, FALSE, sizeof (gint));
69 for (i = 0; i < 100; i++)
70 g_array_prepend_val (garray, i);
72 for (i = 0; i < 100; i++)
73 g_assert_cmpint (g_array_index (garray, gint, i), ==, (100 - i - 1));
75 g_array_free (garray, TRUE);
85 garray = g_array_new (FALSE, FALSE, sizeof (gint));
86 for (i = 0; i < 100; i++)
87 g_array_append_val (garray, i);
89 g_assert_cmpint (garray->len, ==, 100);
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);
96 g_assert_cmpint (garray->len, ==, 96);
99 for (i = 0; i < garray->len; i++)
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);
107 g_array_free (garray, TRUE);
111 array_remove_fast (void)
117 garray = g_array_new (FALSE, FALSE, sizeof (gint));
118 for (i = 0; i < 100; i++)
119 g_array_append_val (garray, i);
121 g_assert_cmpint (garray->len, ==, 100);
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);
128 g_assert_cmpint (garray->len, ==, 96);
131 for (i = 0; i < garray->len; i++)
133 cur = g_array_index (garray, gint, i);
134 g_assert (cur != 1 && cur != 3 && cur != 21 && cur != 57);
137 g_assert_cmpint (prev, <, cur);
142 g_array_free (garray, TRUE);
146 array_remove_range (void)
152 garray = g_array_new (FALSE, FALSE, sizeof (gint));
153 for (i = 0; i < 100; i++)
154 g_array_append_val (garray, i);
156 g_assert_cmpint (garray->len, ==, 100);
158 g_array_remove_range (garray, 31, 4);
160 g_assert_cmpint (garray->len, ==, 96);
163 for (i = 0; i < garray->len; i++)
165 cur = g_array_index (garray, gint, i);
166 g_assert (cur < 31 || cur > 34);
167 g_assert_cmpint (prev, <, cur);
171 /* Ensure the entire array can be cleared, even when empty. */
172 g_array_remove_range (garray, 0, garray->len);
173 g_array_remove_range (garray, 0, garray->len);
175 g_array_free (garray, TRUE);
179 array_ref_count (void)
185 garray = g_array_new (FALSE, FALSE, sizeof (gint));
186 g_assert_cmpint (g_array_get_element_size (garray), ==, sizeof (gint));
187 for (i = 0; i < 100; i++)
188 g_array_prepend_val (garray, i);
190 /* check we can ref, unref and still access the array */
191 garray2 = g_array_ref (garray);
192 g_assert (garray == garray2);
193 g_array_unref (garray2);
194 for (i = 0; i < 100; i++)
195 g_assert_cmpint (g_array_index (garray, gint, i), ==, (100 - i - 1));
197 /* garray2 should be an empty valid GArray wrapper */
198 garray2 = g_array_ref (garray);
199 g_array_free (garray, TRUE);
201 g_assert_cmpint (garray2->len, ==, 0);
202 g_array_unref (garray2);
206 int_compare (gconstpointer p1, gconstpointer p2)
215 int_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
229 garray = g_array_new (FALSE, FALSE, sizeof (gint));
230 for (i = 0; i < 10000; i++)
232 cur = g_random_int_range (0, 10000);
233 g_array_append_val (garray, cur);
235 g_array_sort (garray, int_compare);
238 for (i = 0; i < garray->len; i++)
240 cur = g_array_index (garray, gint, i);
241 g_assert_cmpint (prev, <=, cur);
245 g_array_free (garray, TRUE);
249 array_sort_with_data (void)
255 garray = g_array_new (FALSE, FALSE, sizeof (gint));
256 for (i = 0; i < 10000; i++)
258 cur = g_random_int_range (0, 10000);
259 g_array_append_val (garray, cur);
261 g_array_sort_with_data (garray, int_compare_data, NULL);
264 for (i = 0; i < garray->len; i++)
266 cur = g_array_index (garray, gint, i);
267 g_assert_cmpint (prev, <=, cur);
271 g_array_free (garray, TRUE);
274 static gint num_clear_func_invocations = 0;
277 my_clear_func (gpointer data)
279 num_clear_func_invocations += 1;
283 array_clear_func (void)
289 garray = g_array_new (FALSE, FALSE, sizeof (gint));
290 g_array_set_clear_func (garray, my_clear_func);
292 for (i = 0; i < 10; i++)
294 cur = g_random_int_range (0, 100);
295 g_array_append_val (garray, cur);
298 g_array_remove_index (garray, 9);
299 g_assert_cmpint (num_clear_func_invocations, ==, 1);
301 g_array_remove_range (garray, 5, 3);
302 g_assert_cmpint (num_clear_func_invocations, ==, 4);
304 g_array_remove_index_fast (garray, 4);
305 g_assert_cmpint (num_clear_func_invocations, ==, 5);
307 g_array_free (garray, TRUE);
308 g_assert_cmpint (num_clear_func_invocations, ==, 10);
312 pointer_array_add (void)
319 gparray = g_ptr_array_sized_new (1000);
321 for (i = 0; i < 10000; i++)
322 g_ptr_array_add (gparray, GINT_TO_POINTER (i));
324 for (i = 0; i < 10000; i++)
325 g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
327 g_ptr_array_foreach (gparray, sum_up, &sum);
328 g_assert (sum == 49995000);
330 segment = g_ptr_array_free (gparray, FALSE);
331 for (i = 0; i < 10000; i++)
332 g_assert (segment[i] == GINT_TO_POINTER (i));
337 pointer_array_insert (void)
344 gparray = g_ptr_array_sized_new (1000);
346 for (i = 0; i < 10000; i++)
348 index = g_random_int_range (-1, i + 1);
349 g_ptr_array_insert (gparray, index, GINT_TO_POINTER (i));
352 g_ptr_array_foreach (gparray, sum_up, &sum);
353 g_assert (sum == 49995000);
355 g_ptr_array_free (gparray, TRUE);
359 pointer_array_ref_count (void)
366 gparray = g_ptr_array_new ();
367 for (i = 0; i < 10000; i++)
368 g_ptr_array_add (gparray, GINT_TO_POINTER (i));
370 /* check we can ref, unref and still access the array */
371 gparray2 = g_ptr_array_ref (gparray);
372 g_assert (gparray == gparray2);
373 g_ptr_array_unref (gparray2);
374 for (i = 0; i < 10000; i++)
375 g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
377 g_ptr_array_foreach (gparray, sum_up, &sum);
378 g_assert (sum == 49995000);
380 /* gparray2 should be an empty valid GPtrArray wrapper */
381 gparray2 = g_ptr_array_ref (gparray);
382 g_ptr_array_free (gparray, TRUE);
384 g_assert_cmpint (gparray2->len, ==, 0);
385 g_ptr_array_unref (gparray2);
388 static gint num_free_func_invocations = 0;
391 my_free_func (gpointer data)
393 num_free_func_invocations++;
398 pointer_array_free_func (void)
405 num_free_func_invocations = 0;
406 gparray = g_ptr_array_new_with_free_func (my_free_func);
407 g_ptr_array_unref (gparray);
408 g_assert_cmpint (num_free_func_invocations, ==, 0);
410 gparray = g_ptr_array_new_with_free_func (my_free_func);
411 g_ptr_array_free (gparray, TRUE);
412 g_assert_cmpint (num_free_func_invocations, ==, 0);
414 num_free_func_invocations = 0;
415 gparray = g_ptr_array_new_with_free_func (my_free_func);
416 g_ptr_array_add (gparray, g_strdup ("foo"));
417 g_ptr_array_add (gparray, g_strdup ("bar"));
418 g_ptr_array_add (gparray, g_strdup ("baz"));
419 g_ptr_array_remove_index (gparray, 0);
420 g_assert_cmpint (num_free_func_invocations, ==, 1);
421 g_ptr_array_remove_index_fast (gparray, 1);
422 g_assert_cmpint (num_free_func_invocations, ==, 2);
423 s = g_strdup ("frob");
424 g_ptr_array_add (gparray, s);
425 g_assert (g_ptr_array_remove (gparray, s));
426 g_assert (!g_ptr_array_remove (gparray, "nuun"));
427 g_assert (!g_ptr_array_remove_fast (gparray, "mlo"));
428 g_assert_cmpint (num_free_func_invocations, ==, 3);
429 s = g_strdup ("frob");
430 g_ptr_array_add (gparray, s);
431 g_ptr_array_set_size (gparray, 1);
432 g_assert_cmpint (num_free_func_invocations, ==, 4);
433 g_ptr_array_ref (gparray);
434 g_ptr_array_unref (gparray);
435 g_assert_cmpint (num_free_func_invocations, ==, 4);
436 g_ptr_array_unref (gparray);
437 g_assert_cmpint (num_free_func_invocations, ==, 5);
439 num_free_func_invocations = 0;
440 gparray = g_ptr_array_new_full (10, my_free_func);
441 g_ptr_array_add (gparray, g_strdup ("foo"));
442 g_ptr_array_add (gparray, g_strdup ("bar"));
443 g_ptr_array_add (gparray, g_strdup ("baz"));
444 g_ptr_array_set_size (gparray, 20);
445 g_ptr_array_add (gparray, NULL);
446 gparray2 = g_ptr_array_ref (gparray);
447 strv = (gchar **) g_ptr_array_free (gparray, FALSE);
448 g_assert_cmpint (num_free_func_invocations, ==, 0);
450 g_ptr_array_unref (gparray2);
451 g_assert_cmpint (num_free_func_invocations, ==, 0);
453 num_free_func_invocations = 0;
454 gparray = g_ptr_array_new_with_free_func (my_free_func);
455 g_ptr_array_add (gparray, g_strdup ("foo"));
456 g_ptr_array_add (gparray, g_strdup ("bar"));
457 g_ptr_array_add (gparray, g_strdup ("baz"));
458 g_ptr_array_remove_range (gparray, 1, 1);
459 g_ptr_array_unref (gparray);
460 g_assert_cmpint (num_free_func_invocations, ==, 3);
462 num_free_func_invocations = 0;
463 gparray = g_ptr_array_new_with_free_func (my_free_func);
464 g_ptr_array_add (gparray, g_strdup ("foo"));
465 g_ptr_array_add (gparray, g_strdup ("bar"));
466 g_ptr_array_add (gparray, g_strdup ("baz"));
467 g_ptr_array_free (gparray, TRUE);
468 g_assert_cmpint (num_free_func_invocations, ==, 3);
470 num_free_func_invocations = 0;
471 gparray = g_ptr_array_new_with_free_func (my_free_func);
472 g_ptr_array_add (gparray, "foo");
473 g_ptr_array_add (gparray, "bar");
474 g_ptr_array_add (gparray, "baz");
475 g_ptr_array_set_free_func (gparray, NULL);
476 g_ptr_array_free (gparray, TRUE);
477 g_assert_cmpint (num_free_func_invocations, ==, 0);
481 ptr_compare (gconstpointer p1, gconstpointer p2)
483 gpointer i1 = *(gpointer*)p1;
484 gpointer i2 = *(gpointer*)p2;
486 return GPOINTER_TO_INT (i1) - GPOINTER_TO_INT (i2);
490 ptr_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
492 gpointer i1 = *(gpointer*)p1;
493 gpointer i2 = *(gpointer*)p2;
495 return GPOINTER_TO_INT (i1) - GPOINTER_TO_INT (i2);
499 pointer_array_sort (void)
506 gparray = g_ptr_array_new ();
507 for (i = 0; i < 10000; i++)
509 val = g_random_int_range (0, 10000);
510 g_ptr_array_add (gparray, GINT_TO_POINTER (val));
513 g_ptr_array_sort (gparray, ptr_compare);
516 for (i = 0; i < 10000; i++)
518 cur = GPOINTER_TO_INT (g_ptr_array_index (gparray, i));
519 g_assert_cmpint (prev, <=, cur);
523 g_ptr_array_free (gparray, TRUE);
527 pointer_array_sort_with_data (void)
533 gparray = g_ptr_array_new ();
534 for (i = 0; i < 10000; i++)
535 g_ptr_array_add (gparray, GINT_TO_POINTER (g_random_int_range (0, 10000)));
537 g_ptr_array_sort_with_data (gparray, ptr_compare_data, NULL);
540 for (i = 0; i < 10000; i++)
542 cur = GPOINTER_TO_INT (g_ptr_array_index (gparray, i));
543 g_assert_cmpint (prev, <=, cur);
547 g_ptr_array_free (gparray, TRUE);
551 pointer_array_find_empty (void)
556 array = g_ptr_array_new ();
558 g_assert_false (g_ptr_array_find (array, "some-value", NULL)); /* NULL index */
559 g_assert_false (g_ptr_array_find (array, "some-value", &idx)); /* non-NULL index */
560 g_assert_false (g_ptr_array_find_with_equal_func (array, "some-value", g_str_equal, NULL)); /* NULL index */
561 g_assert_false (g_ptr_array_find_with_equal_func (array, "some-value", g_str_equal, &idx)); /* non-NULL index */
563 g_ptr_array_free (array, TRUE);
567 pointer_array_find_non_empty (void)
571 const gchar *str_pointer = "static-string";
573 array = g_ptr_array_new ();
575 g_ptr_array_add (array, "some");
576 g_ptr_array_add (array, "random");
577 g_ptr_array_add (array, "values");
578 g_ptr_array_add (array, "some");
579 g_ptr_array_add (array, "duplicated");
580 g_ptr_array_add (array, (gpointer) str_pointer);
582 g_assert_true (g_ptr_array_find_with_equal_func (array, "random", g_str_equal, NULL)); /* NULL index */
583 g_assert_true (g_ptr_array_find_with_equal_func (array, "random", g_str_equal, &idx)); /* non-NULL index */
584 g_assert_cmpuint (idx, ==, 1);
586 g_assert_true (g_ptr_array_find_with_equal_func (array, "some", g_str_equal, &idx)); /* duplicate element */
587 g_assert_cmpuint (idx, ==, 0);
589 g_assert_false (g_ptr_array_find_with_equal_func (array, "nope", g_str_equal, NULL));
591 g_assert_true (g_ptr_array_find_with_equal_func (array, str_pointer, g_str_equal, &idx));
592 g_assert_cmpuint (idx, ==, 5);
594 g_assert_true (g_ptr_array_find_with_equal_func (array, str_pointer, NULL, &idx)); /* NULL equal func */
595 g_assert_cmpuint (idx, ==, 5);
597 g_assert_true (g_ptr_array_find (array, str_pointer, &idx)); /* NULL equal func */
598 g_assert_cmpuint (idx, ==, 5);
600 g_ptr_array_free (array, TRUE);
604 byte_array_append (void)
610 gbarray = g_byte_array_sized_new (1000);
611 for (i = 0; i < 10000; i++)
612 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
614 for (i = 0; i < 10000; i++)
616 g_assert (gbarray->data[4*i] == 'a');
617 g_assert (gbarray->data[4*i+1] == 'b');
618 g_assert (gbarray->data[4*i+2] == 'c');
619 g_assert (gbarray->data[4*i+3] == 'd');
622 segment = g_byte_array_free (gbarray, FALSE);
624 for (i = 0; i < 10000; i++)
626 g_assert (segment[4*i] == 'a');
627 g_assert (segment[4*i+1] == 'b');
628 g_assert (segment[4*i+2] == 'c');
629 g_assert (segment[4*i+3] == 'd');
636 byte_array_prepend (void)
641 gbarray = g_byte_array_new ();
642 g_byte_array_set_size (gbarray, 1000);
644 for (i = 0; i < 10000; i++)
645 g_byte_array_prepend (gbarray, (guint8*) "abcd", 4);
647 for (i = 0; i < 10000; i++)
649 g_assert (gbarray->data[4*i] == 'a');
650 g_assert (gbarray->data[4*i+1] == 'b');
651 g_assert (gbarray->data[4*i+2] == 'c');
652 g_assert (gbarray->data[4*i+3] == 'd');
655 g_byte_array_free (gbarray, TRUE);
659 byte_array_ref_count (void)
662 GByteArray *gbarray2;
665 gbarray = g_byte_array_new ();
666 for (i = 0; i < 10000; i++)
667 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
669 gbarray2 = g_byte_array_ref (gbarray);
670 g_assert (gbarray2 == gbarray);
671 g_byte_array_unref (gbarray2);
672 for (i = 0; i < 10000; i++)
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');
680 gbarray2 = g_byte_array_ref (gbarray);
681 g_assert (gbarray2 == gbarray);
682 g_byte_array_free (gbarray, TRUE);
683 g_assert_cmpint (gbarray2->len, ==, 0);
684 g_byte_array_unref (gbarray2);
688 byte_array_remove (void)
693 gbarray = g_byte_array_new ();
694 for (i = 0; i < 100; i++)
695 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
697 g_assert_cmpint (gbarray->len, ==, 400);
699 g_byte_array_remove_index (gbarray, 4);
700 g_byte_array_remove_index (gbarray, 4);
701 g_byte_array_remove_index (gbarray, 4);
702 g_byte_array_remove_index (gbarray, 4);
704 g_assert_cmpint (gbarray->len, ==, 396);
706 for (i = 0; i < 99; i++)
708 g_assert (gbarray->data[4*i] == 'a');
709 g_assert (gbarray->data[4*i+1] == 'b');
710 g_assert (gbarray->data[4*i+2] == 'c');
711 g_assert (gbarray->data[4*i+3] == 'd');
714 g_byte_array_free (gbarray, TRUE);
718 byte_array_remove_fast (void)
723 gbarray = g_byte_array_new ();
724 for (i = 0; i < 100; i++)
725 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
727 g_assert_cmpint (gbarray->len, ==, 400);
729 g_byte_array_remove_index_fast (gbarray, 4);
730 g_byte_array_remove_index_fast (gbarray, 4);
731 g_byte_array_remove_index_fast (gbarray, 4);
732 g_byte_array_remove_index_fast (gbarray, 4);
734 g_assert_cmpint (gbarray->len, ==, 396);
736 for (i = 0; i < 99; i++)
738 g_assert (gbarray->data[4*i] == 'a');
739 g_assert (gbarray->data[4*i+1] == 'b');
740 g_assert (gbarray->data[4*i+2] == 'c');
741 g_assert (gbarray->data[4*i+3] == 'd');
744 g_byte_array_free (gbarray, TRUE);
748 byte_array_remove_range (void)
753 gbarray = g_byte_array_new ();
754 for (i = 0; i < 100; i++)
755 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
757 g_assert_cmpint (gbarray->len, ==, 400);
759 g_byte_array_remove_range (gbarray, 12, 4);
761 g_assert_cmpint (gbarray->len, ==, 396);
763 for (i = 0; i < 99; i++)
765 g_assert (gbarray->data[4*i] == 'a');
766 g_assert (gbarray->data[4*i+1] == 'b');
767 g_assert (gbarray->data[4*i+2] == 'c');
768 g_assert (gbarray->data[4*i+3] == 'd');
771 /* Ensure the entire array can be cleared, even when empty. */
772 g_byte_array_remove_range (gbarray, 0, gbarray->len);
773 g_byte_array_remove_range (gbarray, 0, gbarray->len);
775 g_byte_array_free (gbarray, TRUE);
779 byte_compare (gconstpointer p1, gconstpointer p2)
781 const guint8 *i1 = p1;
782 const guint8 *i2 = p2;
788 byte_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
790 const guint8 *i1 = p1;
791 const guint8 *i2 = p2;
797 byte_array_sort (void)
804 gbarray = g_byte_array_new ();
805 for (i = 0; i < 100; i++)
807 val = 'a' + g_random_int_range (0, 26);
808 g_byte_array_append (gbarray, (guint8*) &val, 1);
811 g_byte_array_sort (gbarray, byte_compare);
814 for (i = 0; i < gbarray->len; i++)
816 cur = gbarray->data[i];
817 g_assert_cmpint (prev, <=, cur);
821 g_byte_array_free (gbarray, TRUE);
825 byte_array_sort_with_data (void)
832 gbarray = g_byte_array_new ();
833 for (i = 0; i < 100; i++)
835 val = 'a' + g_random_int_range (0, 26);
836 g_byte_array_append (gbarray, (guint8*) &val, 1);
839 g_byte_array_sort_with_data (gbarray, byte_compare_data, NULL);
842 for (i = 0; i < gbarray->len; i++)
844 cur = gbarray->data[i];
845 g_assert_cmpint (prev, <=, cur);
849 g_byte_array_free (gbarray, TRUE);
853 byte_array_new_take (void)
858 data = g_memdup ("woooweeewow", 11);
859 gbarray = g_byte_array_new_take (data, 11);
860 g_assert (gbarray->data == data);
861 g_assert_cmpuint (gbarray->len, ==, 11);
862 g_byte_array_free (gbarray, TRUE);
866 byte_array_free_to_bytes (void)
873 gbarray = g_byte_array_new ();
874 g_byte_array_append (gbarray, (guint8 *)"woooweeewow", 11);
875 memory = gbarray->data;
877 bytes = g_byte_array_free_to_bytes (gbarray);
878 g_assert (bytes != NULL);
879 g_assert_cmpuint (g_bytes_get_size (bytes), ==, 11);
880 g_assert (g_bytes_get_data (bytes, &size) == memory);
881 g_assert_cmpuint (size, ==, 11);
883 g_bytes_unref (bytes);
886 main (int argc, char *argv[])
888 g_test_init (&argc, &argv, NULL);
890 g_test_bug_base ("https://bugzilla.gnome.org/");
893 g_test_add_func ("/array/append", array_append);
894 g_test_add_func ("/array/prepend", array_prepend);
895 g_test_add_func ("/array/remove", array_remove);
896 g_test_add_func ("/array/remove-fast", array_remove_fast);
897 g_test_add_func ("/array/remove-range", array_remove_range);
898 g_test_add_func ("/array/ref-count", array_ref_count);
899 g_test_add_func ("/array/sort", array_sort);
900 g_test_add_func ("/array/sort-with-data", array_sort_with_data);
901 g_test_add_func ("/array/clear-func", array_clear_func);
904 g_test_add_func ("/pointerarray/add", pointer_array_add);
905 g_test_add_func ("/pointerarray/insert", pointer_array_insert);
906 g_test_add_func ("/pointerarray/ref-count", pointer_array_ref_count);
907 g_test_add_func ("/pointerarray/free-func", pointer_array_free_func);
908 g_test_add_func ("/pointerarray/sort", pointer_array_sort);
909 g_test_add_func ("/pointerarray/sort-with-data", pointer_array_sort_with_data);
910 g_test_add_func ("/pointerarray/find/empty", pointer_array_find_empty);
911 g_test_add_func ("/pointerarray/find/non-empty", pointer_array_find_non_empty);
914 g_test_add_func ("/bytearray/append", byte_array_append);
915 g_test_add_func ("/bytearray/prepend", byte_array_prepend);
916 g_test_add_func ("/bytearray/remove", byte_array_remove);
917 g_test_add_func ("/bytearray/remove-fast", byte_array_remove_fast);
918 g_test_add_func ("/bytearray/remove-range", byte_array_remove_range);
919 g_test_add_func ("/bytearray/ref-count", byte_array_ref_count);
920 g_test_add_func ("/bytearray/sort", byte_array_sort);
921 g_test_add_func ("/bytearray/sort-with-data", byte_array_sort_with_data);
922 g_test_add_func ("/bytearray/new-take", byte_array_new_take);
923 g_test_add_func ("/bytearray/free-to-bytes", byte_array_free_to_bytes);
925 return g_test_run ();