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; we'll never
208 * actually use any of the 2G of memory that it requests, so it's
209 * OK that we don't actually allocate the whole thing.
211 return realloc (mem, MIN (n_bytes, 1024 * 1024));
214 static GMemVTable array_large_size_mem_vtable = {
215 malloc, array_large_size_remalloc_impl, free,
220 array_large_size (void)
224 g_test_bug ("568760");
226 array = g_array_new (FALSE, FALSE, sizeof (char));
228 if (g_test_trap_fork (5 /* s */ * 1000 /* ms */ * 1000 /* µs */, 0))
230 g_mem_set_vtable (&array_large_size_mem_vtable);
231 g_array_set_size (array, 1073750016);
232 exit (0); /* success */
234 g_test_trap_assert_passed ();
236 g_array_free (array, TRUE);
240 int_compare (gconstpointer p1, gconstpointer p2)
249 int_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
263 garray = g_array_new (FALSE, FALSE, sizeof (gint));
264 for (i = 0; i < 10000; i++)
266 cur = g_random_int_range (0, 10000);
267 g_array_append_val (garray, cur);
269 g_array_sort (garray, int_compare);
272 for (i = 0; i < garray->len; i++)
274 cur = g_array_index (garray, gint, i);
275 g_assert_cmpint (prev, <=, cur);
279 g_array_free (garray, TRUE);
283 array_sort_with_data (void)
289 garray = g_array_new (FALSE, FALSE, sizeof (gint));
290 for (i = 0; i < 10000; i++)
292 cur = g_random_int_range (0, 10000);
293 g_array_append_val (garray, cur);
295 g_array_sort_with_data (garray, int_compare_data, NULL);
298 for (i = 0; i < garray->len; i++)
300 cur = g_array_index (garray, gint, i);
301 g_assert_cmpint (prev, <=, cur);
305 g_array_free (garray, TRUE);
309 pointer_array_add (void)
316 gparray = g_ptr_array_sized_new (1000);
318 for (i = 0; i < 10000; i++)
319 g_ptr_array_add (gparray, GINT_TO_POINTER (i));
321 for (i = 0; i < 10000; i++)
322 g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
324 g_ptr_array_foreach (gparray, sum_up, &sum);
325 g_assert (sum == 49995000);
327 segment = g_ptr_array_free (gparray, FALSE);
328 for (i = 0; i < 10000; i++)
329 g_assert (segment[i] == GINT_TO_POINTER (i));
334 pointer_array_ref_count (void)
341 gparray = g_ptr_array_new ();
342 for (i = 0; i < 10000; i++)
343 g_ptr_array_add (gparray, GINT_TO_POINTER (i));
345 /* check we can ref, unref and still access the array */
346 gparray2 = g_ptr_array_ref (gparray);
347 g_assert (gparray == gparray2);
348 g_ptr_array_unref (gparray2);
349 for (i = 0; i < 10000; i++)
350 g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
352 g_ptr_array_foreach (gparray, sum_up, &sum);
353 g_assert (sum == 49995000);
355 /* gparray2 should be an empty valid GPtrArray wrapper */
356 gparray2 = g_ptr_array_ref (gparray);
357 g_ptr_array_free (gparray, TRUE);
359 g_assert_cmpint (gparray2->len, ==, 0);
360 g_ptr_array_unref (gparray2);
363 static gint num_free_func_invocations = 0;
366 my_free_func (gpointer data)
368 num_free_func_invocations++;
373 pointer_array_free_func (void)
380 num_free_func_invocations = 0;
381 gparray = g_ptr_array_new_with_free_func (my_free_func);
382 g_ptr_array_unref (gparray);
383 g_assert_cmpint (num_free_func_invocations, ==, 0);
385 gparray = g_ptr_array_new_with_free_func (my_free_func);
386 g_ptr_array_free (gparray, TRUE);
387 g_assert_cmpint (num_free_func_invocations, ==, 0);
389 num_free_func_invocations = 0;
390 gparray = g_ptr_array_new_with_free_func (my_free_func);
391 g_ptr_array_add (gparray, g_strdup ("foo"));
392 g_ptr_array_add (gparray, g_strdup ("bar"));
393 g_ptr_array_add (gparray, g_strdup ("baz"));
394 g_ptr_array_remove_index (gparray, 0);
395 g_assert_cmpint (num_free_func_invocations, ==, 1);
396 s = g_strdup ("frob");
397 g_ptr_array_add (gparray, s);
398 g_assert (g_ptr_array_remove (gparray, s));
399 g_assert_cmpint (num_free_func_invocations, ==, 2);
400 g_ptr_array_set_size (gparray, 1);
401 g_assert_cmpint (num_free_func_invocations, ==, 3);
402 g_ptr_array_ref (gparray);
403 g_ptr_array_unref (gparray);
404 g_assert_cmpint (num_free_func_invocations, ==, 3);
405 g_ptr_array_unref (gparray);
406 g_assert_cmpint (num_free_func_invocations, ==, 4);
408 num_free_func_invocations = 0;
409 gparray = g_ptr_array_new_with_free_func (my_free_func);
410 g_ptr_array_add (gparray, g_strdup ("foo"));
411 g_ptr_array_add (gparray, g_strdup ("bar"));
412 g_ptr_array_add (gparray, g_strdup ("baz"));
413 g_ptr_array_add (gparray, NULL);
414 gparray2 = g_ptr_array_ref (gparray);
415 strv = (gchar **) g_ptr_array_free (gparray, FALSE);
416 g_assert_cmpint (num_free_func_invocations, ==, 0);
418 g_ptr_array_unref (gparray2);
419 g_assert_cmpint (num_free_func_invocations, ==, 0);
421 num_free_func_invocations = 0;
422 gparray = g_ptr_array_new_with_free_func (my_free_func);
423 g_ptr_array_add (gparray, g_strdup ("foo"));
424 g_ptr_array_add (gparray, g_strdup ("bar"));
425 g_ptr_array_add (gparray, g_strdup ("baz"));
426 g_ptr_array_unref (gparray);
427 g_assert_cmpint (num_free_func_invocations, ==, 3);
429 num_free_func_invocations = 0;
430 gparray = g_ptr_array_new_with_free_func (my_free_func);
431 g_ptr_array_add (gparray, g_strdup ("foo"));
432 g_ptr_array_add (gparray, g_strdup ("bar"));
433 g_ptr_array_add (gparray, g_strdup ("baz"));
434 g_ptr_array_free (gparray, TRUE);
435 g_assert_cmpint (num_free_func_invocations, ==, 3);
437 num_free_func_invocations = 0;
438 gparray = g_ptr_array_new_with_free_func (my_free_func);
439 g_ptr_array_add (gparray, "foo");
440 g_ptr_array_add (gparray, "bar");
441 g_ptr_array_add (gparray, "baz");
442 g_ptr_array_set_free_func (gparray, NULL);
443 g_ptr_array_free (gparray, TRUE);
444 g_assert_cmpint (num_free_func_invocations, ==, 0);
448 ptr_compare (gconstpointer p1, gconstpointer p2)
450 gpointer i1 = *(gpointer*)p1;
451 gpointer i2 = *(gpointer*)p2;
453 return GPOINTER_TO_INT (i1) - GPOINTER_TO_INT (i2);
457 ptr_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
459 gpointer i1 = *(gpointer*)p1;
460 gpointer i2 = *(gpointer*)p2;
462 return GPOINTER_TO_INT (i1) - GPOINTER_TO_INT (i2);
466 pointer_array_sort (void)
473 gparray = g_ptr_array_new ();
474 for (i = 0; i < 10000; i++)
476 val = g_random_int_range (0, 10000);
477 g_ptr_array_add (gparray, GINT_TO_POINTER (val));
480 g_ptr_array_sort (gparray, ptr_compare);
483 for (i = 0; i < 10000; i++)
485 cur = GPOINTER_TO_INT (g_ptr_array_index (gparray, i));
486 g_assert_cmpint (prev, <=, cur);
490 g_ptr_array_free (gparray, TRUE);
494 pointer_array_sort_with_data (void)
500 gparray = g_ptr_array_new ();
501 for (i = 0; i < 10000; i++)
502 g_ptr_array_add (gparray, GINT_TO_POINTER (g_random_int_range (0, 10000)));
504 g_ptr_array_sort_with_data (gparray, ptr_compare_data, NULL);
507 for (i = 0; i < 10000; i++)
509 cur = GPOINTER_TO_INT (g_ptr_array_index (gparray, i));
510 g_assert_cmpint (prev, <=, cur);
514 g_ptr_array_free (gparray, TRUE);
518 byte_array_append (void)
524 gbarray = g_byte_array_sized_new (1000);
525 for (i = 0; i < 10000; i++)
526 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
528 for (i = 0; i < 10000; i++)
530 g_assert (gbarray->data[4*i] == 'a');
531 g_assert (gbarray->data[4*i+1] == 'b');
532 g_assert (gbarray->data[4*i+2] == 'c');
533 g_assert (gbarray->data[4*i+3] == 'd');
536 segment = g_byte_array_free (gbarray, FALSE);
538 for (i = 0; i < 10000; i++)
540 g_assert (segment[4*i] == 'a');
541 g_assert (segment[4*i+1] == 'b');
542 g_assert (segment[4*i+2] == 'c');
543 g_assert (segment[4*i+3] == 'd');
550 byte_array_prepend (void)
555 gbarray = g_byte_array_new ();
556 g_byte_array_set_size (gbarray, 1000);
558 for (i = 0; i < 10000; i++)
559 g_byte_array_prepend (gbarray, (guint8*) "abcd", 4);
561 for (i = 0; i < 10000; i++)
563 g_assert (gbarray->data[4*i] == 'a');
564 g_assert (gbarray->data[4*i+1] == 'b');
565 g_assert (gbarray->data[4*i+2] == 'c');
566 g_assert (gbarray->data[4*i+3] == 'd');
569 g_byte_array_free (gbarray, TRUE);
573 byte_array_ref_count (void)
576 GByteArray *gbarray2;
579 gbarray = g_byte_array_new ();
580 for (i = 0; i < 10000; i++)
581 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
583 gbarray2 = g_byte_array_ref (gbarray);
584 g_assert (gbarray2 == gbarray);
585 g_byte_array_unref (gbarray2);
586 for (i = 0; i < 10000; i++)
588 g_assert (gbarray->data[4*i] == 'a');
589 g_assert (gbarray->data[4*i+1] == 'b');
590 g_assert (gbarray->data[4*i+2] == 'c');
591 g_assert (gbarray->data[4*i+3] == 'd');
594 gbarray2 = g_byte_array_ref (gbarray);
595 g_assert (gbarray2 == gbarray);
596 g_byte_array_free (gbarray, TRUE);
597 g_assert_cmpint (gbarray2->len, ==, 0);
598 g_byte_array_unref (gbarray2);
602 byte_array_remove (void)
607 gbarray = g_byte_array_new ();
608 for (i = 0; i < 100; i++)
609 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
611 g_assert_cmpint (gbarray->len, ==, 400);
613 g_byte_array_remove_index (gbarray, 4);
614 g_byte_array_remove_index (gbarray, 4);
615 g_byte_array_remove_index (gbarray, 4);
616 g_byte_array_remove_index (gbarray, 4);
618 g_assert_cmpint (gbarray->len, ==, 396);
620 for (i = 0; i < 99; i++)
622 g_assert (gbarray->data[4*i] == 'a');
623 g_assert (gbarray->data[4*i+1] == 'b');
624 g_assert (gbarray->data[4*i+2] == 'c');
625 g_assert (gbarray->data[4*i+3] == 'd');
628 g_byte_array_free (gbarray, TRUE);
632 byte_array_remove_fast (void)
637 gbarray = g_byte_array_new ();
638 for (i = 0; i < 100; i++)
639 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
641 g_assert_cmpint (gbarray->len, ==, 400);
643 g_byte_array_remove_index_fast (gbarray, 4);
644 g_byte_array_remove_index_fast (gbarray, 4);
645 g_byte_array_remove_index_fast (gbarray, 4);
646 g_byte_array_remove_index_fast (gbarray, 4);
648 g_assert_cmpint (gbarray->len, ==, 396);
650 for (i = 0; i < 99; i++)
652 g_assert (gbarray->data[4*i] == 'a');
653 g_assert (gbarray->data[4*i+1] == 'b');
654 g_assert (gbarray->data[4*i+2] == 'c');
655 g_assert (gbarray->data[4*i+3] == 'd');
658 g_byte_array_free (gbarray, TRUE);
662 byte_array_remove_range (void)
667 gbarray = g_byte_array_new ();
668 for (i = 0; i < 100; i++)
669 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
671 g_assert_cmpint (gbarray->len, ==, 400);
673 g_byte_array_remove_range (gbarray, 12, 4);
675 g_assert_cmpint (gbarray->len, ==, 396);
677 for (i = 0; i < 99; i++)
679 g_assert (gbarray->data[4*i] == 'a');
680 g_assert (gbarray->data[4*i+1] == 'b');
681 g_assert (gbarray->data[4*i+2] == 'c');
682 g_assert (gbarray->data[4*i+3] == 'd');
685 g_byte_array_free (gbarray, TRUE);
689 byte_compare (gconstpointer p1, gconstpointer p2)
691 const guint8 *i1 = p1;
692 const guint8 *i2 = p2;
698 byte_compare_data (gconstpointer p1, gconstpointer p2, gpointer data)
700 const guint8 *i1 = p1;
701 const guint8 *i2 = p2;
707 byte_array_sort (void)
714 gbarray = g_byte_array_new ();
715 for (i = 0; i < 100; i++)
717 val = 'a' + g_random_int_range (0, 26);
718 g_byte_array_append (gbarray, (guint8*) &val, 1);
721 g_byte_array_sort (gbarray, byte_compare);
724 for (i = 0; i < gbarray->len; i++)
726 cur = gbarray->data[i];
727 g_assert_cmpint (prev, <=, cur);
731 g_byte_array_free (gbarray, TRUE);
735 byte_array_sort_with_data (void)
742 gbarray = g_byte_array_new ();
743 for (i = 0; i < 100; i++)
745 val = 'a' + g_random_int_range (0, 26);
746 g_byte_array_append (gbarray, (guint8*) &val, 1);
749 g_byte_array_sort_with_data (gbarray, byte_compare_data, NULL);
752 for (i = 0; i < gbarray->len; i++)
754 cur = gbarray->data[i];
755 g_assert_cmpint (prev, <=, cur);
759 g_byte_array_free (gbarray, TRUE);
763 main (int argc, char *argv[])
765 g_test_init (&argc, &argv, NULL);
767 g_test_bug_base ("http://bugs.gnome.org/%s");
770 g_test_add_func ("/array/append", array_append);
771 g_test_add_func ("/array/prepend", array_prepend);
772 g_test_add_func ("/array/remove", array_remove);
773 g_test_add_func ("/array/remove-fast", array_remove_fast);
774 g_test_add_func ("/array/remove-range", array_remove_range);
775 g_test_add_func ("/array/ref-count", array_ref_count);
776 g_test_add_func ("/array/large-size", array_large_size);
777 g_test_add_func ("/array/sort", array_sort);
778 g_test_add_func ("/array/sort-with-data", array_sort_with_data);
781 g_test_add_func ("/pointerarray/add", pointer_array_add);
782 g_test_add_func ("/pointerarray/ref-count", pointer_array_ref_count);
783 g_test_add_func ("/pointerarray/free-func", pointer_array_free_func);
784 g_test_add_func ("/pointerarray/sort", pointer_array_sort);
785 g_test_add_func ("/pointerarray/sort-with-data", pointer_array_sort_with_data);
788 g_test_add_func ("/bytearray/append", byte_array_append);
789 g_test_add_func ("/bytearray/prepend", byte_array_prepend);
790 g_test_add_func ("/bytearray/remove", byte_array_remove);
791 g_test_add_func ("/bytearray/remove-fast", byte_array_remove_fast);
792 g_test_add_func ("/bytearray/remove-range", byte_array_remove_range);
793 g_test_add_func ("/bytearray/ref-count", byte_array_ref_count);
794 g_test_add_func ("/bytearray/sort", byte_array_sort);
795 g_test_add_func ("/bytearray/sort-with-data", byte_array_sort_with_data);
797 return g_test_run ();