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 (void)
223 g_test_bug ("568760");
225 array = g_array_new (FALSE, FALSE, sizeof (char));
227 if (g_test_trap_fork (5 /* s */ * 1000 /* ms */ * 1000 /* µs */, 0))
229 g_mem_set_vtable (&array_large_size_mem_vtable);
230 g_array_set_size (array, 1073750016);
231 g_assert_not_reached ();
233 g_test_trap_assert_passed ();
235 g_array_free (array, TRUE);
239 int_compare (gconstpointer p1, gconstpointer p2)
248 int_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
262 garray = g_array_new (FALSE, FALSE, sizeof (gint));
263 for (i = 0; i < 10000; i++)
265 cur = g_random_int_range (0, 10000);
266 g_array_append_val (garray, cur);
268 g_array_sort (garray, int_compare);
271 for (i = 0; i < garray->len; i++)
273 cur = g_array_index (garray, gint, i);
274 g_assert_cmpint (prev, <=, cur);
278 g_array_free (garray, TRUE);
282 array_sort_with_data (void)
288 garray = g_array_new (FALSE, FALSE, sizeof (gint));
289 for (i = 0; i < 10000; i++)
291 cur = g_random_int_range (0, 10000);
292 g_array_append_val (garray, cur);
294 g_array_sort_with_data (garray, int_compare_data, NULL);
297 for (i = 0; i < garray->len; i++)
299 cur = g_array_index (garray, gint, i);
300 g_assert_cmpint (prev, <=, cur);
304 g_array_free (garray, TRUE);
308 pointer_array_add (void)
315 gparray = g_ptr_array_sized_new (1000);
317 for (i = 0; i < 10000; i++)
318 g_ptr_array_add (gparray, GINT_TO_POINTER (i));
320 for (i = 0; i < 10000; i++)
321 g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
323 g_ptr_array_foreach (gparray, sum_up, &sum);
324 g_assert (sum == 49995000);
326 segment = g_ptr_array_free (gparray, FALSE);
327 for (i = 0; i < 10000; i++)
328 g_assert (segment[i] == GINT_TO_POINTER (i));
333 pointer_array_ref_count (void)
340 gparray = g_ptr_array_new ();
341 for (i = 0; i < 10000; i++)
342 g_ptr_array_add (gparray, GINT_TO_POINTER (i));
344 /* check we can ref, unref and still access the array */
345 gparray2 = g_ptr_array_ref (gparray);
346 g_assert (gparray == gparray2);
347 g_ptr_array_unref (gparray2);
348 for (i = 0; i < 10000; i++)
349 g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
351 g_ptr_array_foreach (gparray, sum_up, &sum);
352 g_assert (sum == 49995000);
354 /* gparray2 should be an empty valid GPtrArray wrapper */
355 gparray2 = g_ptr_array_ref (gparray);
356 g_ptr_array_free (gparray, TRUE);
358 g_assert_cmpint (gparray2->len, ==, 0);
359 g_ptr_array_unref (gparray2);
362 static gint num_free_func_invocations = 0;
365 my_free_func (gpointer data)
367 num_free_func_invocations++;
372 pointer_array_free_func (void)
379 num_free_func_invocations = 0;
380 gparray = g_ptr_array_new_with_free_func (my_free_func);
381 g_ptr_array_unref (gparray);
382 g_assert_cmpint (num_free_func_invocations, ==, 0);
384 gparray = g_ptr_array_new_with_free_func (my_free_func);
385 g_ptr_array_free (gparray, TRUE);
386 g_assert_cmpint (num_free_func_invocations, ==, 0);
388 num_free_func_invocations = 0;
389 gparray = g_ptr_array_new_with_free_func (my_free_func);
390 g_ptr_array_add (gparray, g_strdup ("foo"));
391 g_ptr_array_add (gparray, g_strdup ("bar"));
392 g_ptr_array_add (gparray, g_strdup ("baz"));
393 g_ptr_array_remove_index (gparray, 0);
394 g_assert_cmpint (num_free_func_invocations, ==, 1);
395 s = g_strdup ("frob");
396 g_ptr_array_add (gparray, s);
397 g_assert (g_ptr_array_remove (gparray, s));
398 g_assert (!g_ptr_array_remove (gparray, "nuun"));
399 g_assert (!g_ptr_array_remove_fast (gparray, "mlo"));
400 g_assert_cmpint (num_free_func_invocations, ==, 2);
401 g_ptr_array_set_size (gparray, 1);
402 g_assert_cmpint (num_free_func_invocations, ==, 3);
403 g_ptr_array_ref (gparray);
404 g_ptr_array_unref (gparray);
405 g_assert_cmpint (num_free_func_invocations, ==, 3);
406 g_ptr_array_unref (gparray);
407 g_assert_cmpint (num_free_func_invocations, ==, 4);
409 num_free_func_invocations = 0;
410 gparray = g_ptr_array_new_full (10, my_free_func);
411 g_ptr_array_add (gparray, g_strdup ("foo"));
412 g_ptr_array_add (gparray, g_strdup ("bar"));
413 g_ptr_array_add (gparray, g_strdup ("baz"));
414 g_ptr_array_set_size (gparray, 20);
415 g_ptr_array_add (gparray, NULL);
416 gparray2 = g_ptr_array_ref (gparray);
417 strv = (gchar **) g_ptr_array_free (gparray, FALSE);
418 g_assert_cmpint (num_free_func_invocations, ==, 0);
420 g_ptr_array_unref (gparray2);
421 g_assert_cmpint (num_free_func_invocations, ==, 0);
423 num_free_func_invocations = 0;
424 gparray = g_ptr_array_new_with_free_func (my_free_func);
425 g_ptr_array_add (gparray, g_strdup ("foo"));
426 g_ptr_array_add (gparray, g_strdup ("bar"));
427 g_ptr_array_add (gparray, g_strdup ("baz"));
428 g_ptr_array_remove_range (gparray, 1, 1);
429 g_ptr_array_unref (gparray);
430 g_assert_cmpint (num_free_func_invocations, ==, 3);
432 num_free_func_invocations = 0;
433 gparray = g_ptr_array_new_with_free_func (my_free_func);
434 g_ptr_array_add (gparray, g_strdup ("foo"));
435 g_ptr_array_add (gparray, g_strdup ("bar"));
436 g_ptr_array_add (gparray, g_strdup ("baz"));
437 g_ptr_array_free (gparray, TRUE);
438 g_assert_cmpint (num_free_func_invocations, ==, 3);
440 num_free_func_invocations = 0;
441 gparray = g_ptr_array_new_with_free_func (my_free_func);
442 g_ptr_array_add (gparray, "foo");
443 g_ptr_array_add (gparray, "bar");
444 g_ptr_array_add (gparray, "baz");
445 g_ptr_array_set_free_func (gparray, NULL);
446 g_ptr_array_free (gparray, TRUE);
447 g_assert_cmpint (num_free_func_invocations, ==, 0);
451 ptr_compare (gconstpointer p1, gconstpointer p2)
453 gpointer i1 = *(gpointer*)p1;
454 gpointer i2 = *(gpointer*)p2;
456 return GPOINTER_TO_INT (i1) - GPOINTER_TO_INT (i2);
460 ptr_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
462 gpointer i1 = *(gpointer*)p1;
463 gpointer i2 = *(gpointer*)p2;
465 return GPOINTER_TO_INT (i1) - GPOINTER_TO_INT (i2);
469 pointer_array_sort (void)
476 gparray = g_ptr_array_new ();
477 for (i = 0; i < 10000; i++)
479 val = g_random_int_range (0, 10000);
480 g_ptr_array_add (gparray, GINT_TO_POINTER (val));
483 g_ptr_array_sort (gparray, ptr_compare);
486 for (i = 0; i < 10000; i++)
488 cur = GPOINTER_TO_INT (g_ptr_array_index (gparray, i));
489 g_assert_cmpint (prev, <=, cur);
493 g_ptr_array_free (gparray, TRUE);
497 pointer_array_sort_with_data (void)
503 gparray = g_ptr_array_new ();
504 for (i = 0; i < 10000; i++)
505 g_ptr_array_add (gparray, GINT_TO_POINTER (g_random_int_range (0, 10000)));
507 g_ptr_array_sort_with_data (gparray, ptr_compare_data, NULL);
510 for (i = 0; i < 10000; i++)
512 cur = GPOINTER_TO_INT (g_ptr_array_index (gparray, i));
513 g_assert_cmpint (prev, <=, cur);
517 g_ptr_array_free (gparray, TRUE);
521 byte_array_append (void)
527 gbarray = g_byte_array_sized_new (1000);
528 for (i = 0; i < 10000; i++)
529 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
531 for (i = 0; i < 10000; i++)
533 g_assert (gbarray->data[4*i] == 'a');
534 g_assert (gbarray->data[4*i+1] == 'b');
535 g_assert (gbarray->data[4*i+2] == 'c');
536 g_assert (gbarray->data[4*i+3] == 'd');
539 segment = g_byte_array_free (gbarray, FALSE);
541 for (i = 0; i < 10000; i++)
543 g_assert (segment[4*i] == 'a');
544 g_assert (segment[4*i+1] == 'b');
545 g_assert (segment[4*i+2] == 'c');
546 g_assert (segment[4*i+3] == 'd');
553 byte_array_prepend (void)
558 gbarray = g_byte_array_new ();
559 g_byte_array_set_size (gbarray, 1000);
561 for (i = 0; i < 10000; i++)
562 g_byte_array_prepend (gbarray, (guint8*) "abcd", 4);
564 for (i = 0; i < 10000; i++)
566 g_assert (gbarray->data[4*i] == 'a');
567 g_assert (gbarray->data[4*i+1] == 'b');
568 g_assert (gbarray->data[4*i+2] == 'c');
569 g_assert (gbarray->data[4*i+3] == 'd');
572 g_byte_array_free (gbarray, TRUE);
576 byte_array_ref_count (void)
579 GByteArray *gbarray2;
582 gbarray = g_byte_array_new ();
583 for (i = 0; i < 10000; i++)
584 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
586 gbarray2 = g_byte_array_ref (gbarray);
587 g_assert (gbarray2 == gbarray);
588 g_byte_array_unref (gbarray2);
589 for (i = 0; i < 10000; i++)
591 g_assert (gbarray->data[4*i] == 'a');
592 g_assert (gbarray->data[4*i+1] == 'b');
593 g_assert (gbarray->data[4*i+2] == 'c');
594 g_assert (gbarray->data[4*i+3] == 'd');
597 gbarray2 = g_byte_array_ref (gbarray);
598 g_assert (gbarray2 == gbarray);
599 g_byte_array_free (gbarray, TRUE);
600 g_assert_cmpint (gbarray2->len, ==, 0);
601 g_byte_array_unref (gbarray2);
605 byte_array_remove (void)
610 gbarray = g_byte_array_new ();
611 for (i = 0; i < 100; i++)
612 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
614 g_assert_cmpint (gbarray->len, ==, 400);
616 g_byte_array_remove_index (gbarray, 4);
617 g_byte_array_remove_index (gbarray, 4);
618 g_byte_array_remove_index (gbarray, 4);
619 g_byte_array_remove_index (gbarray, 4);
621 g_assert_cmpint (gbarray->len, ==, 396);
623 for (i = 0; i < 99; i++)
625 g_assert (gbarray->data[4*i] == 'a');
626 g_assert (gbarray->data[4*i+1] == 'b');
627 g_assert (gbarray->data[4*i+2] == 'c');
628 g_assert (gbarray->data[4*i+3] == 'd');
631 g_byte_array_free (gbarray, TRUE);
635 byte_array_remove_fast (void)
640 gbarray = g_byte_array_new ();
641 for (i = 0; i < 100; i++)
642 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
644 g_assert_cmpint (gbarray->len, ==, 400);
646 g_byte_array_remove_index_fast (gbarray, 4);
647 g_byte_array_remove_index_fast (gbarray, 4);
648 g_byte_array_remove_index_fast (gbarray, 4);
649 g_byte_array_remove_index_fast (gbarray, 4);
651 g_assert_cmpint (gbarray->len, ==, 396);
653 for (i = 0; i < 99; i++)
655 g_assert (gbarray->data[4*i] == 'a');
656 g_assert (gbarray->data[4*i+1] == 'b');
657 g_assert (gbarray->data[4*i+2] == 'c');
658 g_assert (gbarray->data[4*i+3] == 'd');
661 g_byte_array_free (gbarray, TRUE);
665 byte_array_remove_range (void)
670 gbarray = g_byte_array_new ();
671 for (i = 0; i < 100; i++)
672 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
674 g_assert_cmpint (gbarray->len, ==, 400);
676 g_byte_array_remove_range (gbarray, 12, 4);
678 g_assert_cmpint (gbarray->len, ==, 396);
680 for (i = 0; i < 99; i++)
682 g_assert (gbarray->data[4*i] == 'a');
683 g_assert (gbarray->data[4*i+1] == 'b');
684 g_assert (gbarray->data[4*i+2] == 'c');
685 g_assert (gbarray->data[4*i+3] == 'd');
688 g_byte_array_free (gbarray, TRUE);
692 byte_compare (gconstpointer p1, gconstpointer p2)
694 const guint8 *i1 = p1;
695 const guint8 *i2 = p2;
701 byte_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
703 const guint8 *i1 = p1;
704 const guint8 *i2 = p2;
710 byte_array_sort (void)
717 gbarray = g_byte_array_new ();
718 for (i = 0; i < 100; i++)
720 val = 'a' + g_random_int_range (0, 26);
721 g_byte_array_append (gbarray, (guint8*) &val, 1);
724 g_byte_array_sort (gbarray, byte_compare);
727 for (i = 0; i < gbarray->len; i++)
729 cur = gbarray->data[i];
730 g_assert_cmpint (prev, <=, cur);
734 g_byte_array_free (gbarray, TRUE);
738 byte_array_sort_with_data (void)
745 gbarray = g_byte_array_new ();
746 for (i = 0; i < 100; i++)
748 val = 'a' + g_random_int_range (0, 26);
749 g_byte_array_append (gbarray, (guint8*) &val, 1);
752 g_byte_array_sort_with_data (gbarray, byte_compare_data, NULL);
755 for (i = 0; i < gbarray->len; i++)
757 cur = gbarray->data[i];
758 g_assert_cmpint (prev, <=, cur);
762 g_byte_array_free (gbarray, TRUE);
766 byte_array_new_take (void)
771 data = g_memdup ("woooweeewow", 11);
772 gbarray = g_byte_array_new_take (data, 11);
773 g_assert (gbarray->data == data);
774 g_assert_cmpuint (gbarray->len, ==, 11);
775 g_byte_array_free (gbarray, TRUE);
779 byte_array_free_to_bytes (void)
785 gbarray = g_byte_array_new ();
786 g_byte_array_append (gbarray, (guint8 *)"woooweeewow", 11);
787 memory = gbarray->data;
789 bytes = g_byte_array_free_to_bytes (gbarray);
790 g_assert (bytes != NULL);
791 g_assert_cmpuint (g_bytes_get_size (bytes), ==, 11);
792 g_assert (g_bytes_get_data (bytes) == memory);
794 g_bytes_unref (bytes);
797 main (int argc, char *argv[])
799 g_test_init (&argc, &argv, NULL);
801 g_test_bug_base ("http://bugs.gnome.org/");
804 g_test_add_func ("/array/append", array_append);
805 g_test_add_func ("/array/prepend", array_prepend);
806 g_test_add_func ("/array/remove", array_remove);
807 g_test_add_func ("/array/remove-fast", array_remove_fast);
808 g_test_add_func ("/array/remove-range", array_remove_range);
809 g_test_add_func ("/array/ref-count", array_ref_count);
810 g_test_add_func ("/array/large-size", array_large_size);
811 g_test_add_func ("/array/sort", array_sort);
812 g_test_add_func ("/array/sort-with-data", array_sort_with_data);
815 g_test_add_func ("/pointerarray/add", pointer_array_add);
816 g_test_add_func ("/pointerarray/ref-count", pointer_array_ref_count);
817 g_test_add_func ("/pointerarray/free-func", pointer_array_free_func);
818 g_test_add_func ("/pointerarray/sort", pointer_array_sort);
819 g_test_add_func ("/pointerarray/sort-with-data", pointer_array_sort_with_data);
822 g_test_add_func ("/bytearray/append", byte_array_append);
823 g_test_add_func ("/bytearray/prepend", byte_array_prepend);
824 g_test_add_func ("/bytearray/remove", byte_array_remove);
825 g_test_add_func ("/bytearray/remove-fast", byte_array_remove_fast);
826 g_test_add_func ("/bytearray/remove-range", byte_array_remove_range);
827 g_test_add_func ("/bytearray/ref-count", byte_array_ref_count);
828 g_test_add_func ("/bytearray/sort", byte_array_sort);
829 g_test_add_func ("/bytearray/sort-with-data", byte_array_sort_with_data);
830 g_test_add_func ("/bytearray/new-take", byte_array_new_take);
831 g_test_add_func ("/bytearray/free-to-bytes", byte_array_free_to_bytes);
833 return g_test_run ();