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 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, write to the
16 * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
17 * Boston, MA 02111-1307, USA.
21 * Modified by the GLib Team and others 1997-2000. See the AUTHORS
22 * file for a list of people on the GLib Team. See the ChangeLog
23 * files for a list of changes. These files are distributed with
24 * GLib at ftp://ftp.gtk.org/pub/gtk/.
27 #undef G_DISABLE_ASSERT
36 sum_up (gpointer data,
39 gint *sum = (gint *)user_data;
41 *sum += GPOINTER_TO_INT (data);
51 garray = g_array_new (FALSE, FALSE, sizeof (gint));
52 for (i = 0; i < 10000; i++)
53 g_array_append_val (garray, i);
55 for (i = 0; i < 10000; i++)
56 g_assert_cmpint (g_array_index (garray, gint, i), ==, i);
58 segment = (gint*)g_array_free (garray, FALSE);
59 for (i = 0; i < 10000; i++)
60 g_assert_cmpint (segment[i], ==, i);
70 garray = g_array_new (FALSE, FALSE, sizeof (gint));
71 for (i = 0; i < 100; i++)
72 g_array_prepend_val (garray, i);
74 for (i = 0; i < 100; i++)
75 g_assert_cmpint (g_array_index (garray, gint, i), ==, (100 - i - 1));
77 g_array_free (garray, TRUE);
87 garray = g_array_new (FALSE, FALSE, sizeof (gint));
88 for (i = 0; i < 100; i++)
89 g_array_append_val (garray, i);
91 g_assert_cmpint (garray->len, ==, 100);
93 g_array_remove_index (garray, 1);
94 g_array_remove_index (garray, 3);
95 g_array_remove_index (garray, 21);
96 g_array_remove_index (garray, 57);
98 g_assert_cmpint (garray->len, ==, 96);
101 for (i = 0; i < garray->len; i++)
103 cur = g_array_index (garray, gint, i);
104 g_assert (cur != 1 && cur != 4 && cur != 23 && cur != 60);
105 g_assert_cmpint (prev, <, cur);
109 g_array_free (garray, TRUE);
113 array_remove_fast (void)
119 garray = g_array_new (FALSE, FALSE, sizeof (gint));
120 for (i = 0; i < 100; i++)
121 g_array_append_val (garray, i);
123 g_assert_cmpint (garray->len, ==, 100);
125 g_array_remove_index_fast (garray, 1);
126 g_array_remove_index_fast (garray, 3);
127 g_array_remove_index_fast (garray, 21);
128 g_array_remove_index_fast (garray, 57);
130 g_assert_cmpint (garray->len, ==, 96);
133 for (i = 0; i < garray->len; i++)
135 cur = g_array_index (garray, gint, i);
136 g_assert (cur != 1 && cur != 3 && cur != 21 && cur != 57);
139 g_assert_cmpint (prev, <, cur);
144 g_array_free (garray, TRUE);
148 array_remove_range (void)
154 garray = g_array_new (FALSE, FALSE, sizeof (gint));
155 for (i = 0; i < 100; i++)
156 g_array_append_val (garray, i);
158 g_assert_cmpint (garray->len, ==, 100);
160 g_array_remove_range (garray, 31, 4);
162 g_assert_cmpint (garray->len, ==, 96);
165 for (i = 0; i < garray->len; i++)
167 cur = g_array_index (garray, gint, i);
168 g_assert (cur < 31 || cur > 34);
169 g_assert_cmpint (prev, <, cur);
173 g_array_free (garray, TRUE);
177 array_ref_count (void)
183 garray = g_array_new (FALSE, FALSE, sizeof (gint));
184 g_assert_cmpint (g_array_get_element_size (garray), ==, sizeof (gint));
185 for (i = 0; i < 100; i++)
186 g_array_prepend_val (garray, i);
188 /* check we can ref, unref and still access the array */
189 garray2 = g_array_ref (garray);
190 g_assert (garray == garray2);
191 g_array_unref (garray2);
192 for (i = 0; i < 100; i++)
193 g_assert_cmpint (g_array_index (garray, gint, i), ==, (100 - i - 1));
195 /* garray2 should be an empty valid GArray wrapper */
196 garray2 = g_array_ref (garray);
197 g_array_free (garray, TRUE);
199 g_assert_cmpint (garray2->len, ==, 0);
200 g_array_unref (garray2);
204 array_large_size_remalloc_impl (gpointer mem,
207 /* We only care that g_array_set_size() doesn't hang before
208 * calling g_realloc(). So if we got here, we already won.
213 static GMemVTable array_large_size_mem_vtable = {
214 malloc, array_large_size_remalloc_impl, free,
219 array_large_size_subprocess (void)
223 array = g_array_new (FALSE, FALSE, sizeof (char));
225 g_mem_set_vtable (&array_large_size_mem_vtable);
226 g_array_set_size (array, 1073750016);
227 g_assert_not_reached ();
231 array_large_size (void)
233 g_test_bug ("568760");
235 g_test_trap_subprocess ("/array/large-size/subprocess",
236 5 /* s */ * 1000 /* ms */ * 1000 /* µs */, 0);
237 g_test_trap_assert_passed ();
241 int_compare (gconstpointer p1, gconstpointer p2)
250 int_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
264 garray = g_array_new (FALSE, FALSE, sizeof (gint));
265 for (i = 0; i < 10000; i++)
267 cur = g_random_int_range (0, 10000);
268 g_array_append_val (garray, cur);
270 g_array_sort (garray, int_compare);
273 for (i = 0; i < garray->len; i++)
275 cur = g_array_index (garray, gint, i);
276 g_assert_cmpint (prev, <=, cur);
280 g_array_free (garray, TRUE);
284 array_sort_with_data (void)
290 garray = g_array_new (FALSE, FALSE, sizeof (gint));
291 for (i = 0; i < 10000; i++)
293 cur = g_random_int_range (0, 10000);
294 g_array_append_val (garray, cur);
296 g_array_sort_with_data (garray, int_compare_data, NULL);
299 for (i = 0; i < garray->len; i++)
301 cur = g_array_index (garray, gint, i);
302 g_assert_cmpint (prev, <=, cur);
306 g_array_free (garray, TRUE);
309 static gint num_clear_func_invocations = 0;
312 my_clear_func (gpointer data)
314 num_clear_func_invocations += 1;
318 array_clear_func (void)
324 garray = g_array_new (FALSE, FALSE, sizeof (gint));
325 g_array_set_clear_func (garray, my_clear_func);
327 for (i = 0; i < 10; i++)
329 cur = g_random_int_range (0, 100);
330 g_array_append_val (garray, cur);
333 g_array_remove_index (garray, 9);
334 g_assert_cmpint (num_clear_func_invocations, ==, 1);
336 g_array_remove_range (garray, 5, 3);
337 g_assert_cmpint (num_clear_func_invocations, ==, 4);
339 g_array_remove_index_fast (garray, 4);
340 g_assert_cmpint (num_clear_func_invocations, ==, 5);
342 g_array_free (garray, TRUE);
343 g_assert_cmpint (num_clear_func_invocations, ==, 10);
347 pointer_array_add (void)
354 gparray = g_ptr_array_sized_new (1000);
356 for (i = 0; i < 10000; i++)
357 g_ptr_array_add (gparray, GINT_TO_POINTER (i));
359 for (i = 0; i < 10000; i++)
360 g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
362 g_ptr_array_foreach (gparray, sum_up, &sum);
363 g_assert (sum == 49995000);
365 segment = g_ptr_array_free (gparray, FALSE);
366 for (i = 0; i < 10000; i++)
367 g_assert (segment[i] == GINT_TO_POINTER (i));
372 pointer_array_insert (void)
379 gparray = g_ptr_array_sized_new (1000);
381 for (i = 0; i < 10000; i++)
383 index = g_random_int_range (-1, i + 1);
384 g_ptr_array_insert (gparray, index, GINT_TO_POINTER (i));
387 g_ptr_array_foreach (gparray, sum_up, &sum);
388 g_assert (sum == 49995000);
390 g_ptr_array_free (gparray, TRUE);
394 pointer_array_ref_count (void)
401 gparray = g_ptr_array_new ();
402 for (i = 0; i < 10000; i++)
403 g_ptr_array_add (gparray, GINT_TO_POINTER (i));
405 /* check we can ref, unref and still access the array */
406 gparray2 = g_ptr_array_ref (gparray);
407 g_assert (gparray == gparray2);
408 g_ptr_array_unref (gparray2);
409 for (i = 0; i < 10000; i++)
410 g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
412 g_ptr_array_foreach (gparray, sum_up, &sum);
413 g_assert (sum == 49995000);
415 /* gparray2 should be an empty valid GPtrArray wrapper */
416 gparray2 = g_ptr_array_ref (gparray);
417 g_ptr_array_free (gparray, TRUE);
419 g_assert_cmpint (gparray2->len, ==, 0);
420 g_ptr_array_unref (gparray2);
423 static gint num_free_func_invocations = 0;
426 my_free_func (gpointer data)
428 num_free_func_invocations++;
433 pointer_array_free_func (void)
440 num_free_func_invocations = 0;
441 gparray = g_ptr_array_new_with_free_func (my_free_func);
442 g_ptr_array_unref (gparray);
443 g_assert_cmpint (num_free_func_invocations, ==, 0);
445 gparray = g_ptr_array_new_with_free_func (my_free_func);
446 g_ptr_array_free (gparray, TRUE);
447 g_assert_cmpint (num_free_func_invocations, ==, 0);
449 num_free_func_invocations = 0;
450 gparray = g_ptr_array_new_with_free_func (my_free_func);
451 g_ptr_array_add (gparray, g_strdup ("foo"));
452 g_ptr_array_add (gparray, g_strdup ("bar"));
453 g_ptr_array_add (gparray, g_strdup ("baz"));
454 g_ptr_array_remove_index (gparray, 0);
455 g_assert_cmpint (num_free_func_invocations, ==, 1);
456 g_ptr_array_remove_index_fast (gparray, 1);
457 g_assert_cmpint (num_free_func_invocations, ==, 2);
458 s = g_strdup ("frob");
459 g_ptr_array_add (gparray, s);
460 g_assert (g_ptr_array_remove (gparray, s));
461 g_assert (!g_ptr_array_remove (gparray, "nuun"));
462 g_assert (!g_ptr_array_remove_fast (gparray, "mlo"));
463 g_assert_cmpint (num_free_func_invocations, ==, 3);
464 s = g_strdup ("frob");
465 g_ptr_array_add (gparray, s);
466 g_ptr_array_set_size (gparray, 1);
467 g_assert_cmpint (num_free_func_invocations, ==, 4);
468 g_ptr_array_ref (gparray);
469 g_ptr_array_unref (gparray);
470 g_assert_cmpint (num_free_func_invocations, ==, 4);
471 g_ptr_array_unref (gparray);
472 g_assert_cmpint (num_free_func_invocations, ==, 5);
474 num_free_func_invocations = 0;
475 gparray = g_ptr_array_new_full (10, my_free_func);
476 g_ptr_array_add (gparray, g_strdup ("foo"));
477 g_ptr_array_add (gparray, g_strdup ("bar"));
478 g_ptr_array_add (gparray, g_strdup ("baz"));
479 g_ptr_array_set_size (gparray, 20);
480 g_ptr_array_add (gparray, NULL);
481 gparray2 = g_ptr_array_ref (gparray);
482 strv = (gchar **) g_ptr_array_free (gparray, FALSE);
483 g_assert_cmpint (num_free_func_invocations, ==, 0);
485 g_ptr_array_unref (gparray2);
486 g_assert_cmpint (num_free_func_invocations, ==, 0);
488 num_free_func_invocations = 0;
489 gparray = g_ptr_array_new_with_free_func (my_free_func);
490 g_ptr_array_add (gparray, g_strdup ("foo"));
491 g_ptr_array_add (gparray, g_strdup ("bar"));
492 g_ptr_array_add (gparray, g_strdup ("baz"));
493 g_ptr_array_remove_range (gparray, 1, 1);
494 g_ptr_array_unref (gparray);
495 g_assert_cmpint (num_free_func_invocations, ==, 3);
497 num_free_func_invocations = 0;
498 gparray = g_ptr_array_new_with_free_func (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_free (gparray, TRUE);
503 g_assert_cmpint (num_free_func_invocations, ==, 3);
505 num_free_func_invocations = 0;
506 gparray = g_ptr_array_new_with_free_func (my_free_func);
507 g_ptr_array_add (gparray, "foo");
508 g_ptr_array_add (gparray, "bar");
509 g_ptr_array_add (gparray, "baz");
510 g_ptr_array_set_free_func (gparray, NULL);
511 g_ptr_array_free (gparray, TRUE);
512 g_assert_cmpint (num_free_func_invocations, ==, 0);
516 ptr_compare (gconstpointer p1, gconstpointer p2)
518 gpointer i1 = *(gpointer*)p1;
519 gpointer i2 = *(gpointer*)p2;
521 return GPOINTER_TO_INT (i1) - GPOINTER_TO_INT (i2);
525 ptr_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
527 gpointer i1 = *(gpointer*)p1;
528 gpointer i2 = *(gpointer*)p2;
530 return GPOINTER_TO_INT (i1) - GPOINTER_TO_INT (i2);
534 pointer_array_sort (void)
541 gparray = g_ptr_array_new ();
542 for (i = 0; i < 10000; i++)
544 val = g_random_int_range (0, 10000);
545 g_ptr_array_add (gparray, GINT_TO_POINTER (val));
548 g_ptr_array_sort (gparray, ptr_compare);
551 for (i = 0; i < 10000; i++)
553 cur = GPOINTER_TO_INT (g_ptr_array_index (gparray, i));
554 g_assert_cmpint (prev, <=, cur);
558 g_ptr_array_free (gparray, TRUE);
562 pointer_array_sort_with_data (void)
568 gparray = g_ptr_array_new ();
569 for (i = 0; i < 10000; i++)
570 g_ptr_array_add (gparray, GINT_TO_POINTER (g_random_int_range (0, 10000)));
572 g_ptr_array_sort_with_data (gparray, ptr_compare_data, NULL);
575 for (i = 0; i < 10000; i++)
577 cur = GPOINTER_TO_INT (g_ptr_array_index (gparray, i));
578 g_assert_cmpint (prev, <=, cur);
582 g_ptr_array_free (gparray, TRUE);
586 byte_array_append (void)
592 gbarray = g_byte_array_sized_new (1000);
593 for (i = 0; i < 10000; i++)
594 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
596 for (i = 0; i < 10000; i++)
598 g_assert (gbarray->data[4*i] == 'a');
599 g_assert (gbarray->data[4*i+1] == 'b');
600 g_assert (gbarray->data[4*i+2] == 'c');
601 g_assert (gbarray->data[4*i+3] == 'd');
604 segment = g_byte_array_free (gbarray, FALSE);
606 for (i = 0; i < 10000; i++)
608 g_assert (segment[4*i] == 'a');
609 g_assert (segment[4*i+1] == 'b');
610 g_assert (segment[4*i+2] == 'c');
611 g_assert (segment[4*i+3] == 'd');
618 byte_array_prepend (void)
623 gbarray = g_byte_array_new ();
624 g_byte_array_set_size (gbarray, 1000);
626 for (i = 0; i < 10000; i++)
627 g_byte_array_prepend (gbarray, (guint8*) "abcd", 4);
629 for (i = 0; i < 10000; i++)
631 g_assert (gbarray->data[4*i] == 'a');
632 g_assert (gbarray->data[4*i+1] == 'b');
633 g_assert (gbarray->data[4*i+2] == 'c');
634 g_assert (gbarray->data[4*i+3] == 'd');
637 g_byte_array_free (gbarray, TRUE);
641 byte_array_ref_count (void)
644 GByteArray *gbarray2;
647 gbarray = g_byte_array_new ();
648 for (i = 0; i < 10000; i++)
649 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
651 gbarray2 = g_byte_array_ref (gbarray);
652 g_assert (gbarray2 == gbarray);
653 g_byte_array_unref (gbarray2);
654 for (i = 0; i < 10000; i++)
656 g_assert (gbarray->data[4*i] == 'a');
657 g_assert (gbarray->data[4*i+1] == 'b');
658 g_assert (gbarray->data[4*i+2] == 'c');
659 g_assert (gbarray->data[4*i+3] == 'd');
662 gbarray2 = g_byte_array_ref (gbarray);
663 g_assert (gbarray2 == gbarray);
664 g_byte_array_free (gbarray, TRUE);
665 g_assert_cmpint (gbarray2->len, ==, 0);
666 g_byte_array_unref (gbarray2);
670 byte_array_remove (void)
675 gbarray = g_byte_array_new ();
676 for (i = 0; i < 100; i++)
677 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
679 g_assert_cmpint (gbarray->len, ==, 400);
681 g_byte_array_remove_index (gbarray, 4);
682 g_byte_array_remove_index (gbarray, 4);
683 g_byte_array_remove_index (gbarray, 4);
684 g_byte_array_remove_index (gbarray, 4);
686 g_assert_cmpint (gbarray->len, ==, 396);
688 for (i = 0; i < 99; i++)
690 g_assert (gbarray->data[4*i] == 'a');
691 g_assert (gbarray->data[4*i+1] == 'b');
692 g_assert (gbarray->data[4*i+2] == 'c');
693 g_assert (gbarray->data[4*i+3] == 'd');
696 g_byte_array_free (gbarray, TRUE);
700 byte_array_remove_fast (void)
705 gbarray = g_byte_array_new ();
706 for (i = 0; i < 100; i++)
707 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
709 g_assert_cmpint (gbarray->len, ==, 400);
711 g_byte_array_remove_index_fast (gbarray, 4);
712 g_byte_array_remove_index_fast (gbarray, 4);
713 g_byte_array_remove_index_fast (gbarray, 4);
714 g_byte_array_remove_index_fast (gbarray, 4);
716 g_assert_cmpint (gbarray->len, ==, 396);
718 for (i = 0; i < 99; i++)
720 g_assert (gbarray->data[4*i] == 'a');
721 g_assert (gbarray->data[4*i+1] == 'b');
722 g_assert (gbarray->data[4*i+2] == 'c');
723 g_assert (gbarray->data[4*i+3] == 'd');
726 g_byte_array_free (gbarray, TRUE);
730 byte_array_remove_range (void)
735 gbarray = g_byte_array_new ();
736 for (i = 0; i < 100; i++)
737 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
739 g_assert_cmpint (gbarray->len, ==, 400);
741 g_byte_array_remove_range (gbarray, 12, 4);
743 g_assert_cmpint (gbarray->len, ==, 396);
745 for (i = 0; i < 99; i++)
747 g_assert (gbarray->data[4*i] == 'a');
748 g_assert (gbarray->data[4*i+1] == 'b');
749 g_assert (gbarray->data[4*i+2] == 'c');
750 g_assert (gbarray->data[4*i+3] == 'd');
753 g_byte_array_free (gbarray, TRUE);
757 byte_compare (gconstpointer p1, gconstpointer p2)
759 const guint8 *i1 = p1;
760 const guint8 *i2 = p2;
766 byte_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
768 const guint8 *i1 = p1;
769 const guint8 *i2 = p2;
775 byte_array_sort (void)
782 gbarray = g_byte_array_new ();
783 for (i = 0; i < 100; i++)
785 val = 'a' + g_random_int_range (0, 26);
786 g_byte_array_append (gbarray, (guint8*) &val, 1);
789 g_byte_array_sort (gbarray, byte_compare);
792 for (i = 0; i < gbarray->len; i++)
794 cur = gbarray->data[i];
795 g_assert_cmpint (prev, <=, cur);
799 g_byte_array_free (gbarray, TRUE);
803 byte_array_sort_with_data (void)
810 gbarray = g_byte_array_new ();
811 for (i = 0; i < 100; i++)
813 val = 'a' + g_random_int_range (0, 26);
814 g_byte_array_append (gbarray, (guint8*) &val, 1);
817 g_byte_array_sort_with_data (gbarray, byte_compare_data, NULL);
820 for (i = 0; i < gbarray->len; i++)
822 cur = gbarray->data[i];
823 g_assert_cmpint (prev, <=, cur);
827 g_byte_array_free (gbarray, TRUE);
831 byte_array_new_take (void)
836 data = g_memdup ("woooweeewow", 11);
837 gbarray = g_byte_array_new_take (data, 11);
838 g_assert (gbarray->data == data);
839 g_assert_cmpuint (gbarray->len, ==, 11);
840 g_byte_array_free (gbarray, TRUE);
844 byte_array_free_to_bytes (void)
851 gbarray = g_byte_array_new ();
852 g_byte_array_append (gbarray, (guint8 *)"woooweeewow", 11);
853 memory = gbarray->data;
855 bytes = g_byte_array_free_to_bytes (gbarray);
856 g_assert (bytes != NULL);
857 g_assert_cmpuint (g_bytes_get_size (bytes), ==, 11);
858 g_assert (g_bytes_get_data (bytes, &size) == memory);
859 g_assert_cmpuint (size, ==, 11);
861 g_bytes_unref (bytes);
864 main (int argc, char *argv[])
866 g_test_init (&argc, &argv, NULL);
868 g_test_bug_base ("http://bugs.gnome.org/");
871 g_test_add_func ("/array/append", array_append);
872 g_test_add_func ("/array/prepend", array_prepend);
873 g_test_add_func ("/array/remove", array_remove);
874 g_test_add_func ("/array/remove-fast", array_remove_fast);
875 g_test_add_func ("/array/remove-range", array_remove_range);
876 g_test_add_func ("/array/ref-count", array_ref_count);
877 g_test_add_func ("/array/large-size", array_large_size);
878 g_test_add_func ("/array/large-size/subprocess", array_large_size_subprocess);
879 g_test_add_func ("/array/sort", array_sort);
880 g_test_add_func ("/array/sort-with-data", array_sort_with_data);
881 g_test_add_func ("/array/clear-func", array_clear_func);
884 g_test_add_func ("/pointerarray/add", pointer_array_add);
885 g_test_add_func ("/pointerarray/insert", pointer_array_insert);
886 g_test_add_func ("/pointerarray/ref-count", pointer_array_ref_count);
887 g_test_add_func ("/pointerarray/free-func", pointer_array_free_func);
888 g_test_add_func ("/pointerarray/sort", pointer_array_sort);
889 g_test_add_func ("/pointerarray/sort-with-data", pointer_array_sort_with_data);
892 g_test_add_func ("/bytearray/append", byte_array_append);
893 g_test_add_func ("/bytearray/prepend", byte_array_prepend);
894 g_test_add_func ("/bytearray/remove", byte_array_remove);
895 g_test_add_func ("/bytearray/remove-fast", byte_array_remove_fast);
896 g_test_add_func ("/bytearray/remove-range", byte_array_remove_range);
897 g_test_add_func ("/bytearray/ref-count", byte_array_ref_count);
898 g_test_add_func ("/bytearray/sort", byte_array_sort);
899 g_test_add_func ("/bytearray/sort-with-data", byte_array_sort_with_data);
900 g_test_add_func ("/bytearray/new-take", byte_array_new_take);
901 g_test_add_func ("/bytearray/free-to-bytes", byte_array_free_to_bytes);
903 return g_test_run ();