glib/tests/array-test.c

   1 /* GLIB - Library of useful routines for C programming
   2  * Copyright (C) 1995-1997  Peter Mattis, Spencer Kimball and Josh MacDonald
   3  *
   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.
   8  *
   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.
  13  *
  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.
  18  */
  19
  20 /*
  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/.
  25  */
  26
  27 #undef G_DISABLE_ASSERT
  28 #undef G_LOG_DOMAIN
  29
  30 #include <stdio.h>
  31 #include <string.h>
  32 #include "glib.h"
  33
  34 static void
  35 sum_up (gpointer data,
  36         gpointer user_data)
  37 {
  38   gint *sum = (gint *)user_data;
  39
  40   *sum += GPOINTER_TO_INT (data);
  41 }
  42
  43 static void
  44 array_append (void)
  45 {
  46   GArray *garray;
  47   gint i;
  48
  49   garray = g_array_new (FALSE, FALSE, sizeof (gint));
  50   for (i = 0; i < 10000; i++)
  51     g_array_append_val (garray, i);
  52
  53   for (i = 0; i < 10000; i++)
  54     g_assert_cmpint (g_array_index (garray, gint, i), ==, i);
  55
  56   g_array_free (garray, TRUE);
  57 }
  58
  59 static void
  60 array_prepend (void)
  61 {
  62   GArray *garray;
  63   gint i;
  64
  65   garray = g_array_new (FALSE, FALSE, sizeof (gint));
  66   for (i = 0; i < 100; i++)
  67     g_array_prepend_val (garray, i);
  68
  69   for (i = 0; i < 100; i++)
  70     g_assert_cmpint (g_array_index (garray, gint, i), ==, (100 - i - 1));
  71
  72   g_array_free (garray, TRUE);
  73 }
  74
  75 static void
  76 array_ref_count (void)
  77 {
  78   GArray *garray;
  79   GArray *garray2;
  80   gint i;
  81
  82   garray = g_array_new (FALSE, FALSE, sizeof (gint));
  83   g_assert_cmpint (g_array_get_element_size (garray), ==, sizeof (gint));
  84   for (i = 0; i < 100; i++)
  85     g_array_prepend_val (garray, i);
  86
  87   /* check we can ref, unref and still access the array */
  88   garray2 = g_array_ref (garray);
  89   g_assert (garray == garray2);
  90   g_array_unref (garray2);
  91   for (i = 0; i < 100; i++)
  92     g_assert_cmpint (g_array_index (garray, gint, i), ==, (100 - i - 1));
  93
  94   /* garray2 should be an empty valid GArray wrapper */
  95   garray2 = g_array_ref (garray);
  96   g_array_free (garray, TRUE);
  97
  98   g_assert_cmpint (garray2->len, ==, 0);
  99   g_array_unref (garray2);
 100 }
 101
 102 static void
 103 pointer_array_add (void)
 104 {
 105   GPtrArray *gparray;
 106   gint i;
 107   gint sum = 0;
 108
 109   gparray = g_ptr_array_new ();
 110   for (i = 0; i < 10000; i++)
 111     g_ptr_array_add (gparray, GINT_TO_POINTER (i));
 112
 113   for (i = 0; i < 10000; i++)
 114     g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
 115
 116   g_ptr_array_foreach (gparray, sum_up, &sum);
 117   g_assert (sum == 49995000);
 118
 119   g_ptr_array_free (gparray, TRUE);
 120 }
 121
 122 static void
 123 pointer_array_ref_count (void)
 124 {
 125   GPtrArray *gparray;
 126   GPtrArray *gparray2;
 127   gint i;
 128   gint sum = 0;
 129
 130   gparray = g_ptr_array_new ();
 131   for (i = 0; i < 10000; i++)
 132     g_ptr_array_add (gparray, GINT_TO_POINTER (i));
 133
 134   /* check we can ref, unref and still access the array */
 135   gparray2 = g_ptr_array_ref (gparray);
 136   g_assert (gparray == gparray2);
 137   g_ptr_array_unref (gparray2);
 138   for (i = 0; i < 10000; i++)
 139     g_assert (g_ptr_array_index (gparray, i) == GINT_TO_POINTER (i));
 140
 141   g_ptr_array_foreach (gparray, sum_up, &sum);
 142   g_assert (sum == 49995000);
 143
 144   /* gparray2 should be an empty valid GPtrArray wrapper */
 145   gparray2 = g_ptr_array_ref (gparray);
 146   g_ptr_array_free (gparray, TRUE);
 147
 148   g_assert_cmpint (gparray2->len, ==, 0);
 149   g_ptr_array_unref (gparray2);
 150 }
 151
 152 static gint num_free_func_invocations = 0;
 153
 154 static void
 155 my_free_func (gpointer data)
 156 {
 157   num_free_func_invocations++;
 158   g_free (data);
 159 }
 160
 161 static void
 162 pointer_array_free_func (void)
 163 {
 164   GPtrArray *gparray;
 165   GPtrArray *gparray2;
 166   gchar **strv;
 167   gchar *s;
 168
 169   num_free_func_invocations = 0;
 170   gparray = g_ptr_array_new_with_free_func (my_free_func);
 171   g_ptr_array_unref (gparray);
 172   g_assert_cmpint (num_free_func_invocations, ==, 0);
 173
 174   gparray = g_ptr_array_new_with_free_func (my_free_func);
 175   g_ptr_array_free (gparray, TRUE);
 176   g_assert_cmpint (num_free_func_invocations, ==, 0);
 177
 178   num_free_func_invocations = 0;
 179   gparray = g_ptr_array_new_with_free_func (my_free_func);
 180   g_ptr_array_add (gparray, g_strdup ("foo"));
 181   g_ptr_array_add (gparray, g_strdup ("bar"));
 182   g_ptr_array_add (gparray, g_strdup ("baz"));
 183   g_ptr_array_remove_index (gparray, 0);
 184   g_assert_cmpint (num_free_func_invocations, ==, 1);
 185   s = g_strdup ("frob");
 186   g_ptr_array_add (gparray, s);
 187   g_assert (g_ptr_array_remove (gparray, s));
 188   g_assert_cmpint (num_free_func_invocations, ==, 2);
 189   g_ptr_array_ref (gparray);
 190   g_ptr_array_unref (gparray);
 191   g_assert_cmpint (num_free_func_invocations, ==, 2);
 192   g_ptr_array_unref (gparray);
 193   g_assert_cmpint (num_free_func_invocations, ==, 4);
 194
 195   num_free_func_invocations = 0;
 196   gparray = g_ptr_array_new_with_free_func (my_free_func);
 197   g_ptr_array_add (gparray, g_strdup ("foo"));
 198   g_ptr_array_add (gparray, g_strdup ("bar"));
 199   g_ptr_array_add (gparray, g_strdup ("baz"));
 200   g_ptr_array_add (gparray, NULL);
 201   gparray2 = g_ptr_array_ref (gparray);
 202   strv = (gchar **) g_ptr_array_free (gparray, FALSE);
 203   g_assert_cmpint (num_free_func_invocations, ==, 0);
 204   g_strfreev (strv);
 205   g_ptr_array_unref (gparray2);
 206   g_assert_cmpint (num_free_func_invocations, ==, 0);
 207
 208   num_free_func_invocations = 0;
 209   gparray = g_ptr_array_new_with_free_func (my_free_func);
 210   g_ptr_array_add (gparray, g_strdup ("foo"));
 211   g_ptr_array_add (gparray, g_strdup ("bar"));
 212   g_ptr_array_add (gparray, g_strdup ("baz"));
 213   g_ptr_array_unref (gparray);
 214   g_assert_cmpint (num_free_func_invocations, ==, 3);
 215
 216   num_free_func_invocations = 0;
 217   gparray = g_ptr_array_new_with_free_func (my_free_func);
 218   g_ptr_array_add (gparray, g_strdup ("foo"));
 219   g_ptr_array_add (gparray, g_strdup ("bar"));
 220   g_ptr_array_add (gparray, g_strdup ("baz"));
 221   g_ptr_array_free (gparray, TRUE);
 222   g_assert_cmpint (num_free_func_invocations, ==, 3);
 223
 224   num_free_func_invocations = 0;
 225   gparray = g_ptr_array_new_with_free_func (my_free_func);
 226   g_ptr_array_add (gparray, "foo");
 227   g_ptr_array_add (gparray, "bar");
 228   g_ptr_array_add (gparray, "baz");
 229   g_ptr_array_set_free_func (gparray, NULL);
 230   g_ptr_array_free (gparray, TRUE);
 231   g_assert_cmpint (num_free_func_invocations, ==, 0);
 232 }
 233
 234 static void
 235 byte_array_append (void)
 236 {
 237   GByteArray *gbarray;
 238   gint i;
 239
 240   gbarray = g_byte_array_new ();
 241   for (i = 0; i < 10000; i++)
 242     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 243
 244   for (i = 0; i < 10000; i++)
 245     {
 246       g_assert (gbarray->data[4*i] == 'a');
 247       g_assert (gbarray->data[4*i+1] == 'b');
 248       g_assert (gbarray->data[4*i+2] == 'c');
 249       g_assert (gbarray->data[4*i+3] == 'd');
 250     }
 251
 252   g_byte_array_free (gbarray, TRUE);
 253 }
 254
 255 static void
 256 byte_array_ref_count (void)
 257 {
 258   GByteArray *gbarray;
 259   GByteArray *gbarray2;
 260   gint i;
 261
 262   gbarray = g_byte_array_new ();
 263   for (i = 0; i < 10000; i++)
 264     g_byte_array_append (gbarray, (guint8*) "abcd", 4);
 265
 266   gbarray2 = g_byte_array_ref (gbarray);
 267   g_assert (gbarray2 == gbarray);
 268   g_byte_array_unref (gbarray2);
 269   for (i = 0; i < 10000; i++)
 270     {
 271       g_assert (gbarray->data[4*i] == 'a');
 272       g_assert (gbarray->data[4*i+1] == 'b');
 273       g_assert (gbarray->data[4*i+2] == 'c');
 274       g_assert (gbarray->data[4*i+3] == 'd');
 275     }
 276
 277   gbarray2 = g_byte_array_ref (gbarray);
 278   g_assert (gbarray2 == gbarray);
 279   g_byte_array_free (gbarray, TRUE);
 280   g_assert_cmpint (gbarray2->len, ==, 0);
 281   g_byte_array_unref (gbarray2);
 282 }
 283
 284 int
 285 main (int argc, char *argv[])
 286 {
 287   g_test_init (&argc, &argv, NULL);
 288
 289   /* array tests */
 290   g_test_add_func ("/array/append", array_append);
 291   g_test_add_func ("/array/prepend", array_prepend);
 292   g_test_add_func ("/array/ref-count", array_ref_count);
 293
 294   /* pointer arrays */
 295   g_test_add_func ("/pointerarray/add", pointer_array_add);
 296   g_test_add_func ("/pointerarray/ref-count", pointer_array_ref_count);
 297   g_test_add_func ("/pointerarray/free-func", pointer_array_free_func);
 298
 299   /* byte arrays */
 300   g_test_add_func ("/bytearray/append", byte_array_append);
 301   g_test_add_func ("/bytearray/ref-count", byte_array_ref_count);
 302
 303   return g_test_run ();
 304 }
 305