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);
50 garray = g_array_new (FALSE, FALSE, sizeof (gint));
51 for (i = 0; i < 10000; i++)
52 g_array_append_val (garray, i);
54 for (i = 0; i < 10000; i++)
55 g_assert_cmpint (g_array_index (garray, gint, i), ==, i);
57 g_array_free (garray, TRUE);
66 garray = g_array_new (FALSE, FALSE, sizeof (gint));
67 for (i = 0; i < 100; i++)
68 g_array_prepend_val (garray, i);
70 for (i = 0; i < 100; i++)
71 g_assert_cmpint (g_array_index (garray, gint, i), ==, (100 - i - 1));
73 g_array_free (garray, TRUE);
77 array_ref_count (void)
83 garray = g_array_new (FALSE, FALSE, sizeof (gint));
84 g_assert_cmpint (g_array_get_element_size (garray), ==, sizeof (gint));
85 for (i = 0; i < 100; i++)
86 g_array_prepend_val (garray, i);
88 /* check we can ref, unref and still access the array */
89 garray2 = g_array_ref (garray);
90 g_assert (garray == garray2);
91 g_array_unref (garray2);
92 for (i = 0; i < 100; i++)
93 g_assert_cmpint (g_array_index (garray, gint, i), ==, (100 - i - 1));
95 /* garray2 should be an empty valid GArray wrapper */
96 garray2 = g_array_ref (garray);
97 g_array_free (garray, TRUE);
99 g_assert_cmpint (garray2->len, ==, 0);
100 g_array_unref (garray2);
104 array_large_size_remalloc_impl (gpointer mem,
107 /* We only care that g_array_set_size() doesn't hang; we'll never
108 * actually use any of the 2G of memory that it requests, so it's
109 * OK that we don't actually allocate the whole thing.
111 return realloc (mem, MIN (n_bytes, 1024 * 1024));
114 static GMemVTable array_large_size_mem_vtable = {
115 malloc, array_large_size_remalloc_impl, free,
120 array_large_size (void)
124 g_test_bug ("568760");
126 array = g_array_new (FALSE, FALSE, sizeof (char));
128 if (g_test_trap_fork (5 /* s */ * 1000 /* ms */ * 1000 /* µs */, 0))
130 g_mem_set_vtable (&array_large_size_mem_vtable);
131 g_array_set_size (array, 1073750016);
132 exit (0); /* success */
134 g_test_trap_assert_passed ();
136 g_array_free (array, TRUE);
140 pointer_array_add (void)
146 gparray = g_ptr_array_new ();
147 for (i = 0; i < 10000; i++)
148 g_ptr_array_add (gparray, GINT_TO_POINTER (i));
150 for (i = 0; i < 10000; i++)
151 g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
153 g_ptr_array_foreach (gparray, sum_up, &sum);
154 g_assert (sum == 49995000);
156 g_ptr_array_free (gparray, TRUE);
160 pointer_array_ref_count (void)
167 gparray = g_ptr_array_new ();
168 for (i = 0; i < 10000; i++)
169 g_ptr_array_add (gparray, GINT_TO_POINTER (i));
171 /* check we can ref, unref and still access the array */
172 gparray2 = g_ptr_array_ref (gparray);
173 g_assert (gparray == gparray2);
174 g_ptr_array_unref (gparray2);
175 for (i = 0; i < 10000; i++)
176 g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
178 g_ptr_array_foreach (gparray, sum_up, &sum);
179 g_assert (sum == 49995000);
181 /* gparray2 should be an empty valid GPtrArray wrapper */
182 gparray2 = g_ptr_array_ref (gparray);
183 g_ptr_array_free (gparray, TRUE);
185 g_assert_cmpint (gparray2->len, ==, 0);
186 g_ptr_array_unref (gparray2);
189 static gint num_free_func_invocations = 0;
192 my_free_func (gpointer data)
194 num_free_func_invocations++;
199 pointer_array_free_func (void)
206 num_free_func_invocations = 0;
207 gparray = g_ptr_array_new_with_free_func (my_free_func);
208 g_ptr_array_unref (gparray);
209 g_assert_cmpint (num_free_func_invocations, ==, 0);
211 gparray = g_ptr_array_new_with_free_func (my_free_func);
212 g_ptr_array_free (gparray, TRUE);
213 g_assert_cmpint (num_free_func_invocations, ==, 0);
215 num_free_func_invocations = 0;
216 gparray = g_ptr_array_new_with_free_func (my_free_func);
217 g_ptr_array_add (gparray, g_strdup ("foo"));
218 g_ptr_array_add (gparray, g_strdup ("bar"));
219 g_ptr_array_add (gparray, g_strdup ("baz"));
220 g_ptr_array_remove_index (gparray, 0);
221 g_assert_cmpint (num_free_func_invocations, ==, 1);
222 s = g_strdup ("frob");
223 g_ptr_array_add (gparray, s);
224 g_assert (g_ptr_array_remove (gparray, s));
225 g_assert_cmpint (num_free_func_invocations, ==, 2);
226 g_ptr_array_set_size (gparray, 1);
227 g_assert_cmpint (num_free_func_invocations, ==, 3);
228 g_ptr_array_ref (gparray);
229 g_ptr_array_unref (gparray);
230 g_assert_cmpint (num_free_func_invocations, ==, 3);
231 g_ptr_array_unref (gparray);
232 g_assert_cmpint (num_free_func_invocations, ==, 4);
234 num_free_func_invocations = 0;
235 gparray = g_ptr_array_new_with_free_func (my_free_func);
236 g_ptr_array_add (gparray, g_strdup ("foo"));
237 g_ptr_array_add (gparray, g_strdup ("bar"));
238 g_ptr_array_add (gparray, g_strdup ("baz"));
239 g_ptr_array_add (gparray, NULL);
240 gparray2 = g_ptr_array_ref (gparray);
241 strv = (gchar **) g_ptr_array_free (gparray, FALSE);
242 g_assert_cmpint (num_free_func_invocations, ==, 0);
244 g_ptr_array_unref (gparray2);
245 g_assert_cmpint (num_free_func_invocations, ==, 0);
247 num_free_func_invocations = 0;
248 gparray = g_ptr_array_new_with_free_func (my_free_func);
249 g_ptr_array_add (gparray, g_strdup ("foo"));
250 g_ptr_array_add (gparray, g_strdup ("bar"));
251 g_ptr_array_add (gparray, g_strdup ("baz"));
252 g_ptr_array_unref (gparray);
253 g_assert_cmpint (num_free_func_invocations, ==, 3);
255 num_free_func_invocations = 0;
256 gparray = g_ptr_array_new_with_free_func (my_free_func);
257 g_ptr_array_add (gparray, g_strdup ("foo"));
258 g_ptr_array_add (gparray, g_strdup ("bar"));
259 g_ptr_array_add (gparray, g_strdup ("baz"));
260 g_ptr_array_free (gparray, TRUE);
261 g_assert_cmpint (num_free_func_invocations, ==, 3);
263 num_free_func_invocations = 0;
264 gparray = g_ptr_array_new_with_free_func (my_free_func);
265 g_ptr_array_add (gparray, "foo");
266 g_ptr_array_add (gparray, "bar");
267 g_ptr_array_add (gparray, "baz");
268 g_ptr_array_set_free_func (gparray, NULL);
269 g_ptr_array_free (gparray, TRUE);
270 g_assert_cmpint (num_free_func_invocations, ==, 0);
274 byte_array_append (void)
279 gbarray = g_byte_array_new ();
280 for (i = 0; i < 10000; i++)
281 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
283 for (i = 0; i < 10000; i++)
285 g_assert (gbarray->data[4*i] == 'a');
286 g_assert (gbarray->data[4*i+1] == 'b');
287 g_assert (gbarray->data[4*i+2] == 'c');
288 g_assert (gbarray->data[4*i+3] == 'd');
291 g_byte_array_free (gbarray, TRUE);
295 byte_array_ref_count (void)
298 GByteArray *gbarray2;
301 gbarray = g_byte_array_new ();
302 for (i = 0; i < 10000; i++)
303 g_byte_array_append (gbarray, (guint8*) "abcd", 4);
305 gbarray2 = g_byte_array_ref (gbarray);
306 g_assert (gbarray2 == gbarray);
307 g_byte_array_unref (gbarray2);
308 for (i = 0; i < 10000; i++)
310 g_assert (gbarray->data[4*i] == 'a');
311 g_assert (gbarray->data[4*i+1] == 'b');
312 g_assert (gbarray->data[4*i+2] == 'c');
313 g_assert (gbarray->data[4*i+3] == 'd');
316 gbarray2 = g_byte_array_ref (gbarray);
317 g_assert (gbarray2 == gbarray);
318 g_byte_array_free (gbarray, TRUE);
319 g_assert_cmpint (gbarray2->len, ==, 0);
320 g_byte_array_unref (gbarray2);
324 main (int argc, char *argv[])
326 g_test_init (&argc, &argv, NULL);
328 g_test_bug_base ("http://bugs.gnome.org/%s");
331 g_test_add_func ("/array/append", array_append);
332 g_test_add_func ("/array/prepend", array_prepend);
333 g_test_add_func ("/array/ref-count", array_ref_count);
334 g_test_add_func ("/array/large-size", array_large_size);
337 g_test_add_func ("/pointerarray/add", pointer_array_add);
338 g_test_add_func ("/pointerarray/ref-count", pointer_array_ref_count);
339 g_test_add_func ("/pointerarray/free-func", pointer_array_free_func);
342 g_test_add_func ("/bytearray/append", byte_array_append);
343 g_test_add_func ("/bytearray/ref-count", byte_array_ref_count);
345 return g_test_run ();