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, 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 g_array_free (garray
, TRUE
);
175 array_ref_count (void)
181 garray
= g_array_new (FALSE
, FALSE
, sizeof (gint
));
182 g_assert_cmpint (g_array_get_element_size (garray
), ==, sizeof (gint
));
183 for (i
= 0; i
< 100; i
++)
184 g_array_prepend_val (garray
, i
);
186 /* check we can ref, unref and still access the array */
187 garray2
= g_array_ref (garray
);
188 g_assert (garray
== garray2
);
189 g_array_unref (garray2
);
190 for (i
= 0; i
< 100; i
++)
191 g_assert_cmpint (g_array_index (garray
, gint
, i
), ==, (100 - i
- 1));
193 /* garray2 should be an empty valid GArray wrapper */
194 garray2
= g_array_ref (garray
);
195 g_array_free (garray
, TRUE
);
197 g_assert_cmpint (garray2
->len
, ==, 0);
198 g_array_unref (garray2
);
202 int_compare (gconstpointer p1
, gconstpointer p2
)
211 int_compare_data (gconstpointer p1
, gconstpointer p2
, gpointer data
)
225 garray
= g_array_new (FALSE
, FALSE
, sizeof (gint
));
226 for (i
= 0; i
< 10000; i
++)
228 cur
= g_random_int_range (0, 10000);
229 g_array_append_val (garray
, cur
);
231 g_array_sort (garray
, int_compare
);
234 for (i
= 0; i
< garray
->len
; i
++)
236 cur
= g_array_index (garray
, gint
, i
);
237 g_assert_cmpint (prev
, <=, cur
);
241 g_array_free (garray
, TRUE
);
245 array_sort_with_data (void)
251 garray
= g_array_new (FALSE
, FALSE
, sizeof (gint
));
252 for (i
= 0; i
< 10000; i
++)
254 cur
= g_random_int_range (0, 10000);
255 g_array_append_val (garray
, cur
);
257 g_array_sort_with_data (garray
, int_compare_data
, NULL
);
260 for (i
= 0; i
< garray
->len
; i
++)
262 cur
= g_array_index (garray
, gint
, i
);
263 g_assert_cmpint (prev
, <=, cur
);
267 g_array_free (garray
, TRUE
);
270 static gint num_clear_func_invocations
= 0;
273 my_clear_func (gpointer data
)
275 num_clear_func_invocations
+= 1;
279 array_clear_func (void)
285 garray
= g_array_new (FALSE
, FALSE
, sizeof (gint
));
286 g_array_set_clear_func (garray
, my_clear_func
);
288 for (i
= 0; i
< 10; i
++)
290 cur
= g_random_int_range (0, 100);
291 g_array_append_val (garray
, cur
);
294 g_array_remove_index (garray
, 9);
295 g_assert_cmpint (num_clear_func_invocations
, ==, 1);
297 g_array_remove_range (garray
, 5, 3);
298 g_assert_cmpint (num_clear_func_invocations
, ==, 4);
300 g_array_remove_index_fast (garray
, 4);
301 g_assert_cmpint (num_clear_func_invocations
, ==, 5);
303 g_array_free (garray
, TRUE
);
304 g_assert_cmpint (num_clear_func_invocations
, ==, 10);
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_insert (void)
340 gparray
= g_ptr_array_sized_new (1000);
342 for (i
= 0; i
< 10000; i
++)
344 index
= g_random_int_range (-1, i
+ 1);
345 g_ptr_array_insert (gparray
, index
, GINT_TO_POINTER (i
));
348 g_ptr_array_foreach (gparray
, sum_up
, &sum
);
349 g_assert (sum
== 49995000);
351 g_ptr_array_free (gparray
, TRUE
);
355 pointer_array_ref_count (void)
362 gparray
= g_ptr_array_new ();
363 for (i
= 0; i
< 10000; i
++)
364 g_ptr_array_add (gparray
, GINT_TO_POINTER (i
));
366 /* check we can ref, unref and still access the array */
367 gparray2
= g_ptr_array_ref (gparray
);
368 g_assert (gparray
== gparray2
);
369 g_ptr_array_unref (gparray2
);
370 for (i
= 0; i
< 10000; i
++)
371 g_assert (g_ptr_array_index (gparray
, i
) == GINT_TO_POINTER (i
));
373 g_ptr_array_foreach (gparray
, sum_up
, &sum
);
374 g_assert (sum
== 49995000);
376 /* gparray2 should be an empty valid GPtrArray wrapper */
377 gparray2
= g_ptr_array_ref (gparray
);
378 g_ptr_array_free (gparray
, TRUE
);
380 g_assert_cmpint (gparray2
->len
, ==, 0);
381 g_ptr_array_unref (gparray2
);
384 static gint num_free_func_invocations
= 0;
387 my_free_func (gpointer data
)
389 num_free_func_invocations
++;
394 pointer_array_free_func (void)
401 num_free_func_invocations
= 0;
402 gparray
= g_ptr_array_new_with_free_func (my_free_func
);
403 g_ptr_array_unref (gparray
);
404 g_assert_cmpint (num_free_func_invocations
, ==, 0);
406 gparray
= g_ptr_array_new_with_free_func (my_free_func
);
407 g_ptr_array_free (gparray
, TRUE
);
408 g_assert_cmpint (num_free_func_invocations
, ==, 0);
410 num_free_func_invocations
= 0;
411 gparray
= g_ptr_array_new_with_free_func (my_free_func
);
412 g_ptr_array_add (gparray
, g_strdup ("foo"));
413 g_ptr_array_add (gparray
, g_strdup ("bar"));
414 g_ptr_array_add (gparray
, g_strdup ("baz"));
415 g_ptr_array_remove_index (gparray
, 0);
416 g_assert_cmpint (num_free_func_invocations
, ==, 1);
417 g_ptr_array_remove_index_fast (gparray
, 1);
418 g_assert_cmpint (num_free_func_invocations
, ==, 2);
419 s
= g_strdup ("frob");
420 g_ptr_array_add (gparray
, s
);
421 g_assert (g_ptr_array_remove (gparray
, s
));
422 g_assert (!g_ptr_array_remove (gparray
, "nuun"));
423 g_assert (!g_ptr_array_remove_fast (gparray
, "mlo"));
424 g_assert_cmpint (num_free_func_invocations
, ==, 3);
425 s
= g_strdup ("frob");
426 g_ptr_array_add (gparray
, s
);
427 g_ptr_array_set_size (gparray
, 1);
428 g_assert_cmpint (num_free_func_invocations
, ==, 4);
429 g_ptr_array_ref (gparray
);
430 g_ptr_array_unref (gparray
);
431 g_assert_cmpint (num_free_func_invocations
, ==, 4);
432 g_ptr_array_unref (gparray
);
433 g_assert_cmpint (num_free_func_invocations
, ==, 5);
435 num_free_func_invocations
= 0;
436 gparray
= g_ptr_array_new_full (10, my_free_func
);
437 g_ptr_array_add (gparray
, g_strdup ("foo"));
438 g_ptr_array_add (gparray
, g_strdup ("bar"));
439 g_ptr_array_add (gparray
, g_strdup ("baz"));
440 g_ptr_array_set_size (gparray
, 20);
441 g_ptr_array_add (gparray
, NULL
);
442 gparray2
= g_ptr_array_ref (gparray
);
443 strv
= (gchar
**) g_ptr_array_free (gparray
, FALSE
);
444 g_assert_cmpint (num_free_func_invocations
, ==, 0);
446 g_ptr_array_unref (gparray2
);
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_range (gparray
, 1, 1);
455 g_ptr_array_unref (gparray
);
456 g_assert_cmpint (num_free_func_invocations
, ==, 3);
458 num_free_func_invocations
= 0;
459 gparray
= g_ptr_array_new_with_free_func (my_free_func
);
460 g_ptr_array_add (gparray
, g_strdup ("foo"));
461 g_ptr_array_add (gparray
, g_strdup ("bar"));
462 g_ptr_array_add (gparray
, g_strdup ("baz"));
463 g_ptr_array_free (gparray
, TRUE
);
464 g_assert_cmpint (num_free_func_invocations
, ==, 3);
466 num_free_func_invocations
= 0;
467 gparray
= g_ptr_array_new_with_free_func (my_free_func
);
468 g_ptr_array_add (gparray
, "foo");
469 g_ptr_array_add (gparray
, "bar");
470 g_ptr_array_add (gparray
, "baz");
471 g_ptr_array_set_free_func (gparray
, NULL
);
472 g_ptr_array_free (gparray
, TRUE
);
473 g_assert_cmpint (num_free_func_invocations
, ==, 0);
477 ptr_compare (gconstpointer p1
, gconstpointer p2
)
479 gpointer i1
= *(gpointer
*)p1
;
480 gpointer i2
= *(gpointer
*)p2
;
482 return GPOINTER_TO_INT (i1
) - GPOINTER_TO_INT (i2
);
486 ptr_compare_data (gconstpointer p1
, gconstpointer p2
, gpointer data
)
488 gpointer i1
= *(gpointer
*)p1
;
489 gpointer i2
= *(gpointer
*)p2
;
491 return GPOINTER_TO_INT (i1
) - GPOINTER_TO_INT (i2
);
495 pointer_array_sort (void)
502 gparray
= g_ptr_array_new ();
503 for (i
= 0; i
< 10000; i
++)
505 val
= g_random_int_range (0, 10000);
506 g_ptr_array_add (gparray
, GINT_TO_POINTER (val
));
509 g_ptr_array_sort (gparray
, ptr_compare
);
512 for (i
= 0; i
< 10000; i
++)
514 cur
= GPOINTER_TO_INT (g_ptr_array_index (gparray
, i
));
515 g_assert_cmpint (prev
, <=, cur
);
519 g_ptr_array_free (gparray
, TRUE
);
523 pointer_array_sort_with_data (void)
529 gparray
= g_ptr_array_new ();
530 for (i
= 0; i
< 10000; i
++)
531 g_ptr_array_add (gparray
, GINT_TO_POINTER (g_random_int_range (0, 10000)));
533 g_ptr_array_sort_with_data (gparray
, ptr_compare_data
, NULL
);
536 for (i
= 0; i
< 10000; i
++)
538 cur
= GPOINTER_TO_INT (g_ptr_array_index (gparray
, i
));
539 g_assert_cmpint (prev
, <=, cur
);
543 g_ptr_array_free (gparray
, TRUE
);
547 byte_array_append (void)
553 gbarray
= g_byte_array_sized_new (1000);
554 for (i
= 0; i
< 10000; i
++)
555 g_byte_array_append (gbarray
, (guint8
*) "abcd", 4);
557 for (i
= 0; i
< 10000; i
++)
559 g_assert (gbarray
->data
[4*i
] == 'a');
560 g_assert (gbarray
->data
[4*i
+1] == 'b');
561 g_assert (gbarray
->data
[4*i
+2] == 'c');
562 g_assert (gbarray
->data
[4*i
+3] == 'd');
565 segment
= g_byte_array_free (gbarray
, FALSE
);
567 for (i
= 0; i
< 10000; i
++)
569 g_assert (segment
[4*i
] == 'a');
570 g_assert (segment
[4*i
+1] == 'b');
571 g_assert (segment
[4*i
+2] == 'c');
572 g_assert (segment
[4*i
+3] == 'd');
579 byte_array_prepend (void)
584 gbarray
= g_byte_array_new ();
585 g_byte_array_set_size (gbarray
, 1000);
587 for (i
= 0; i
< 10000; i
++)
588 g_byte_array_prepend (gbarray
, (guint8
*) "abcd", 4);
590 for (i
= 0; i
< 10000; i
++)
592 g_assert (gbarray
->data
[4*i
] == 'a');
593 g_assert (gbarray
->data
[4*i
+1] == 'b');
594 g_assert (gbarray
->data
[4*i
+2] == 'c');
595 g_assert (gbarray
->data
[4*i
+3] == 'd');
598 g_byte_array_free (gbarray
, TRUE
);
602 byte_array_ref_count (void)
605 GByteArray
*gbarray2
;
608 gbarray
= g_byte_array_new ();
609 for (i
= 0; i
< 10000; i
++)
610 g_byte_array_append (gbarray
, (guint8
*) "abcd", 4);
612 gbarray2
= g_byte_array_ref (gbarray
);
613 g_assert (gbarray2
== gbarray
);
614 g_byte_array_unref (gbarray2
);
615 for (i
= 0; i
< 10000; i
++)
617 g_assert (gbarray
->data
[4*i
] == 'a');
618 g_assert (gbarray
->data
[4*i
+1] == 'b');
619 g_assert (gbarray
->data
[4*i
+2] == 'c');
620 g_assert (gbarray
->data
[4*i
+3] == 'd');
623 gbarray2
= g_byte_array_ref (gbarray
);
624 g_assert (gbarray2
== gbarray
);
625 g_byte_array_free (gbarray
, TRUE
);
626 g_assert_cmpint (gbarray2
->len
, ==, 0);
627 g_byte_array_unref (gbarray2
);
631 byte_array_remove (void)
636 gbarray
= g_byte_array_new ();
637 for (i
= 0; i
< 100; i
++)
638 g_byte_array_append (gbarray
, (guint8
*) "abcd", 4);
640 g_assert_cmpint (gbarray
->len
, ==, 400);
642 g_byte_array_remove_index (gbarray
, 4);
643 g_byte_array_remove_index (gbarray
, 4);
644 g_byte_array_remove_index (gbarray
, 4);
645 g_byte_array_remove_index (gbarray
, 4);
647 g_assert_cmpint (gbarray
->len
, ==, 396);
649 for (i
= 0; i
< 99; i
++)
651 g_assert (gbarray
->data
[4*i
] == 'a');
652 g_assert (gbarray
->data
[4*i
+1] == 'b');
653 g_assert (gbarray
->data
[4*i
+2] == 'c');
654 g_assert (gbarray
->data
[4*i
+3] == 'd');
657 g_byte_array_free (gbarray
, TRUE
);
661 byte_array_remove_fast (void)
666 gbarray
= g_byte_array_new ();
667 for (i
= 0; i
< 100; i
++)
668 g_byte_array_append (gbarray
, (guint8
*) "abcd", 4);
670 g_assert_cmpint (gbarray
->len
, ==, 400);
672 g_byte_array_remove_index_fast (gbarray
, 4);
673 g_byte_array_remove_index_fast (gbarray
, 4);
674 g_byte_array_remove_index_fast (gbarray
, 4);
675 g_byte_array_remove_index_fast (gbarray
, 4);
677 g_assert_cmpint (gbarray
->len
, ==, 396);
679 for (i
= 0; i
< 99; i
++)
681 g_assert (gbarray
->data
[4*i
] == 'a');
682 g_assert (gbarray
->data
[4*i
+1] == 'b');
683 g_assert (gbarray
->data
[4*i
+2] == 'c');
684 g_assert (gbarray
->data
[4*i
+3] == 'd');
687 g_byte_array_free (gbarray
, TRUE
);
691 byte_array_remove_range (void)
696 gbarray
= g_byte_array_new ();
697 for (i
= 0; i
< 100; i
++)
698 g_byte_array_append (gbarray
, (guint8
*) "abcd", 4);
700 g_assert_cmpint (gbarray
->len
, ==, 400);
702 g_byte_array_remove_range (gbarray
, 12, 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_compare (gconstpointer p1
, gconstpointer p2
)
720 const guint8
*i1
= p1
;
721 const guint8
*i2
= p2
;
727 byte_compare_data (gconstpointer p1
, gconstpointer p2
, gpointer data
)
729 const guint8
*i1
= p1
;
730 const guint8
*i2
= p2
;
736 byte_array_sort (void)
743 gbarray
= g_byte_array_new ();
744 for (i
= 0; i
< 100; i
++)
746 val
= 'a' + g_random_int_range (0, 26);
747 g_byte_array_append (gbarray
, (guint8
*) &val
, 1);
750 g_byte_array_sort (gbarray
, byte_compare
);
753 for (i
= 0; i
< gbarray
->len
; i
++)
755 cur
= gbarray
->data
[i
];
756 g_assert_cmpint (prev
, <=, cur
);
760 g_byte_array_free (gbarray
, TRUE
);
764 byte_array_sort_with_data (void)
771 gbarray
= g_byte_array_new ();
772 for (i
= 0; i
< 100; i
++)
774 val
= 'a' + g_random_int_range (0, 26);
775 g_byte_array_append (gbarray
, (guint8
*) &val
, 1);
778 g_byte_array_sort_with_data (gbarray
, byte_compare_data
, NULL
);
781 for (i
= 0; i
< gbarray
->len
; i
++)
783 cur
= gbarray
->data
[i
];
784 g_assert_cmpint (prev
, <=, cur
);
788 g_byte_array_free (gbarray
, TRUE
);
792 byte_array_new_take (void)
797 data
= g_memdup ("woooweeewow", 11);
798 gbarray
= g_byte_array_new_take (data
, 11);
799 g_assert (gbarray
->data
== data
);
800 g_assert_cmpuint (gbarray
->len
, ==, 11);
801 g_byte_array_free (gbarray
, TRUE
);
805 byte_array_free_to_bytes (void)
812 gbarray
= g_byte_array_new ();
813 g_byte_array_append (gbarray
, (guint8
*)"woooweeewow", 11);
814 memory
= gbarray
->data
;
816 bytes
= g_byte_array_free_to_bytes (gbarray
);
817 g_assert (bytes
!= NULL
);
818 g_assert_cmpuint (g_bytes_get_size (bytes
), ==, 11);
819 g_assert (g_bytes_get_data (bytes
, &size
) == memory
);
820 g_assert_cmpuint (size
, ==, 11);
822 g_bytes_unref (bytes
);
825 main (int argc
, char *argv
[])
827 g_test_init (&argc
, &argv
, NULL
);
829 g_test_bug_base ("http://bugs.gnome.org/");
832 g_test_add_func ("/array/append", array_append
);
833 g_test_add_func ("/array/prepend", array_prepend
);
834 g_test_add_func ("/array/remove", array_remove
);
835 g_test_add_func ("/array/remove-fast", array_remove_fast
);
836 g_test_add_func ("/array/remove-range", array_remove_range
);
837 g_test_add_func ("/array/ref-count", array_ref_count
);
838 g_test_add_func ("/array/sort", array_sort
);
839 g_test_add_func ("/array/sort-with-data", array_sort_with_data
);
840 g_test_add_func ("/array/clear-func", array_clear_func
);
843 g_test_add_func ("/pointerarray/add", pointer_array_add
);
844 g_test_add_func ("/pointerarray/insert", pointer_array_insert
);
845 g_test_add_func ("/pointerarray/ref-count", pointer_array_ref_count
);
846 g_test_add_func ("/pointerarray/free-func", pointer_array_free_func
);
847 g_test_add_func ("/pointerarray/sort", pointer_array_sort
);
848 g_test_add_func ("/pointerarray/sort-with-data", pointer_array_sort_with_data
);
851 g_test_add_func ("/bytearray/append", byte_array_append
);
852 g_test_add_func ("/bytearray/prepend", byte_array_prepend
);
853 g_test_add_func ("/bytearray/remove", byte_array_remove
);
854 g_test_add_func ("/bytearray/remove-fast", byte_array_remove_fast
);
855 g_test_add_func ("/bytearray/remove-range", byte_array_remove_range
);
856 g_test_add_func ("/bytearray/ref-count", byte_array_ref_count
);
857 g_test_add_func ("/bytearray/sort", byte_array_sort
);
858 g_test_add_func ("/bytearray/sort-with-data", byte_array_sort_with_data
);
859 g_test_add_func ("/bytearray/new-take", byte_array_new_take
);
860 g_test_add_func ("/bytearray/free-to-bytes", byte_array_free_to_bytes
);
862 return g_test_run ();