gobject/tests/boxed.c

   1 #include <glib-object.h>
   2
   3 typedef struct _MyBoxed MyBoxed;
   4
   5 struct _MyBoxed
   6 {
   7   gint ivalue;
   8   gchar *bla;
   9 };
  10
  11 static gpointer
  12 my_boxed_copy (gpointer orig)
  13 {
  14   MyBoxed *a = orig;
  15   MyBoxed *b;
  16
  17   b = g_slice_new (MyBoxed);
  18   b->ivalue = a->ivalue;
  19   b->bla = g_strdup (a->bla);
  20
  21   return b;
  22 }
  23
  24 static gint my_boxed_free_count;
  25
  26 static void
  27 my_boxed_free (gpointer orig)
  28 {
  29   MyBoxed *a = orig;
  30
  31   g_free (a->bla);
  32   g_slice_free (MyBoxed, a);
  33
  34   my_boxed_free_count++;
  35 }
  36
  37 #define MY_TYPE_BOXED (my_boxed_get_type ())
  38
  39 G_DEFINE_BOXED_TYPE (MyBoxed, my_boxed, my_boxed_copy, my_boxed_free)
  40
  41 static void
  42 test_define_boxed (void)
  43 {
  44   MyBoxed a;
  45   MyBoxed *b;
  46
  47   a.ivalue = 20;
  48   a.bla = g_strdup ("bla");
  49
  50   b = g_boxed_copy (MY_TYPE_BOXED, &a);
  51
  52   g_assert_cmpint (b->ivalue, ==, 20);
  53   g_assert_cmpstr (b->bla, ==, "bla");
  54
  55   g_boxed_free (MY_TYPE_BOXED, b);
  56 }
  57
  58 static void
  59 test_boxed_ownership (void)
  60 {
  61   GValue value = { 0, };
  62   static MyBoxed boxed = { 10, "bla" };
  63
  64   g_value_init (&value, MY_TYPE_BOXED);
  65
  66   my_boxed_free_count = 0;
  67
  68   g_value_set_static_boxed (&value, &boxed);
  69   g_value_reset (&value);
  70
  71   g_assert_cmpint (my_boxed_free_count, ==, 0);
  72
  73   g_value_set_boxed_take_ownership (&value, g_boxed_copy (MY_TYPE_BOXED, &boxed));
  74   g_value_reset (&value);
  75   g_assert_cmpint (my_boxed_free_count, ==, 1);
  76
  77   g_value_take_boxed (&value, g_boxed_copy (MY_TYPE_BOXED, &boxed));
  78   g_value_reset (&value);
  79   g_assert_cmpint (my_boxed_free_count, ==, 2);
  80
  81   g_value_set_boxed (&value, &boxed);
  82   g_value_reset (&value);
  83   g_assert_cmpint (my_boxed_free_count, ==, 3);
  84 }
  85
  86 static void
  87 my_callback (gpointer user_data)
  88 {
  89 }
  90
  91 static gint destroy_count;
  92
  93 static void
  94 my_closure_notify (gpointer user_data, GClosure *closure)
  95 {
  96   destroy_count++;
  97 }
  98
  99 static void
 100 test_boxed_closure (void)
 101 {
 102   GClosure *closure;
 103   GClosure *closure2;
 104   GValue value = { 0, };
 105
 106   g_value_init (&value, G_TYPE_CLOSURE);
 107   g_assert (G_VALUE_HOLDS_BOXED (&value));
 108
 109   closure = g_cclosure_new (G_CALLBACK (my_callback), "bla", my_closure_notify);
 110   g_value_take_boxed (&value, closure);
 111
 112   closure2 = g_value_get_boxed (&value);
 113   g_assert (closure2 == closure);
 114
 115   closure2 = g_value_dup_boxed (&value);
 116   g_assert (closure2 == closure); /* closures use ref/unref for copy/free */
 117   g_closure_unref (closure2);
 118
 119   g_value_unset (&value);
 120   g_assert_cmpint (destroy_count, ==, 1);
 121 }
 122
 123 static void
 124 test_boxed_date (void)
 125 {
 126   GDate *date;
 127   GDate *date2;
 128   GValue value = { 0, };
 129
 130   g_value_init (&value, G_TYPE_DATE);
 131   g_assert (G_VALUE_HOLDS_BOXED (&value));
 132
 133   date = g_date_new_dmy (1, 3, 1970);
 134   g_value_take_boxed (&value, date);
 135
 136   date2 = g_value_get_boxed (&value);
 137   g_assert (date2 == date);
 138
 139   date2 = g_value_dup_boxed (&value);
 140   g_assert (date2 != date);
 141   g_assert (g_date_compare (date, date2) == 0);
 142   g_date_free (date2);
 143
 144   g_value_unset (&value);
 145 }
 146
 147 static void
 148 test_boxed_value (void)
 149 {
 150   GValue value1 = { 0, };
 151   GValue *value2;
 152   GValue value = { 0, };
 153
 154   g_value_init (&value, G_TYPE_VALUE);
 155   g_assert (G_VALUE_HOLDS_BOXED (&value));
 156
 157   g_value_init (&value1, G_TYPE_INT);
 158   g_value_set_int (&value1, 26);
 159
 160   g_value_set_static_boxed (&value, &value1);
 161
 162   value2 = g_value_get_boxed (&value);
 163   g_assert (value2 == &value1);
 164
 165   value2 = g_value_dup_boxed (&value);
 166   g_assert (value2 != &value1);
 167   g_assert (G_VALUE_HOLDS_INT (value2));
 168   g_assert_cmpint (g_value_get_int (value2), ==, 26);
 169   g_boxed_free (G_TYPE_VALUE, value2);
 170
 171   g_value_unset (&value);
 172 }
 173
 174 static void
 175 test_boxed_string (void)
 176 {
 177   GString *v;
 178   GString *v2;
 179   GValue value = { 0, };
 180
 181   g_value_init (&value, G_TYPE_GSTRING);
 182   g_assert (G_VALUE_HOLDS_BOXED (&value));
 183
 184   v = g_string_new ("bla");
 185   g_value_take_boxed (&value, v);
 186
 187   v2 = g_value_get_boxed (&value);
 188   g_assert (v2 == v);
 189
 190   v2 = g_value_dup_boxed (&value);
 191   g_assert (v2 != v);
 192   g_assert (g_string_equal (v, v2));
 193   g_string_free (v2, TRUE);
 194
 195   g_value_unset (&value);
 196 }
 197
 198 static void
 199 test_boxed_hashtable (void)
 200 {
 201   GHashTable *v;
 202   GHashTable *v2;
 203   GValue value = { 0, };
 204
 205   g_value_init (&value, G_TYPE_HASH_TABLE);
 206   g_assert (G_VALUE_HOLDS_BOXED (&value));
 207
 208   v = g_hash_table_new (g_str_hash, g_str_equal);
 209   g_value_take_boxed (&value, v);
 210
 211   v2 = g_value_get_boxed (&value);
 212   g_assert (v2 == v);
 213
 214   v2 = g_value_dup_boxed (&value);
 215   g_assert (v2 == v);  /* hash tables use ref/unref for copy/free */
 216   g_hash_table_unref (v2);
 217
 218   g_value_unset (&value);
 219 }
 220
 221 static void
 222 test_boxed_array (void)
 223 {
 224   GArray *v;
 225   GArray *v2;
 226   GValue value = { 0, };
 227
 228   g_value_init (&value, G_TYPE_ARRAY);
 229   g_assert (G_VALUE_HOLDS_BOXED (&value));
 230
 231   v = g_array_new (TRUE, FALSE, 1);
 232   g_value_take_boxed (&value, v);
 233
 234   v2 = g_value_get_boxed (&value);
 235   g_assert (v2 == v);
 236
 237   v2 = g_value_dup_boxed (&value);
 238   g_assert (v2 == v);  /* arrays use ref/unref for copy/free */
 239   g_array_unref (v2);
 240
 241   g_value_unset (&value);
 242 }
 243
 244 static void
 245 test_boxed_ptrarray (void)
 246 {
 247   GPtrArray *v;
 248   GPtrArray *v2;
 249   GValue value = { 0, };
 250
 251   g_value_init (&value, G_TYPE_PTR_ARRAY);
 252   g_assert (G_VALUE_HOLDS_BOXED (&value));
 253
 254   v = g_ptr_array_new ();
 255   g_value_take_boxed (&value, v);
 256
 257   v2 = g_value_get_boxed (&value);
 258   g_assert (v2 == v);
 259
 260   v2 = g_value_dup_boxed (&value);
 261   g_assert (v2 == v);  /* ptr arrays use ref/unref for copy/free */
 262   g_ptr_array_unref (v2);
 263
 264   g_value_unset (&value);
 265 }
 266
 267 static void
 268 test_boxed_regex (void)
 269 {
 270   GRegex *v;
 271   GRegex *v2;
 272   GValue value = { 0, };
 273
 274   g_value_init (&value, G_TYPE_REGEX);
 275   g_assert (G_VALUE_HOLDS_BOXED (&value));
 276
 277   v = g_regex_new ("a+b+", 0, 0, NULL);
 278   g_value_take_boxed (&value, v);
 279
 280   v2 = g_value_get_boxed (&value);
 281   g_assert (v2 == v);
 282
 283   v2 = g_value_dup_boxed (&value);
 284   g_assert (v2 == v);  /* regexes use ref/unref for copy/free */
 285   g_regex_unref (v2);
 286
 287   g_value_unset (&value);
 288 }
 289
 290 static void
 291 test_boxed_varianttype (void)
 292 {
 293   GVariantType *v;
 294   GVariantType *v2;
 295   GValue value = { 0, };
 296
 297   g_value_init (&value, G_TYPE_VARIANT_TYPE);
 298   g_assert (G_VALUE_HOLDS_BOXED (&value));
 299
 300   v = g_variant_type_new ("mas");
 301   g_value_take_boxed (&value, v);
 302
 303   v2 = g_value_get_boxed (&value);
 304   g_assert (v2 == v);
 305
 306   v2 = g_value_dup_boxed (&value);
 307   g_assert (v2 != v);
 308   g_assert_cmpstr (g_variant_type_peek_string (v), ==, g_variant_type_peek_string (v2));
 309   g_variant_type_free (v2);
 310
 311   g_value_unset (&value);
 312 }
 313
 314 static void
 315 test_boxed_datetime (void)
 316 {
 317   GDateTime *v;
 318   GDateTime *v2;
 319   GValue value = { 0, };
 320
 321   g_value_init (&value, G_TYPE_DATE_TIME);
 322   g_assert (G_VALUE_HOLDS_BOXED (&value));
 323
 324   v = g_date_time_new_now_local ();
 325   g_value_take_boxed (&value, v);
 326
 327   v2 = g_value_get_boxed (&value);
 328   g_assert (v2 == v);
 329
 330   v2 = g_value_dup_boxed (&value);
 331   g_assert (v2 == v); /* datetime uses ref/unref for copy/free */
 332   g_date_time_unref (v2);
 333
 334   g_value_unset (&value);
 335 }
 336
 337 static void
 338 test_boxed_error (void)
 339 {
 340   GError *v;
 341   GError *v2;
 342   GValue value = { 0, };
 343
 344   g_value_init (&value, G_TYPE_ERROR);
 345   g_assert (G_VALUE_HOLDS_BOXED (&value));
 346
 347   v = g_error_new_literal (G_VARIANT_PARSE_ERROR,
 348                            G_VARIANT_PARSE_ERROR_NUMBER_TOO_BIG,
 349                            "Too damn big");
 350   g_value_take_boxed (&value, v);
 351
 352   v2 = g_value_get_boxed (&value);
 353   g_assert (v2 == v);
 354
 355   v2 = g_value_dup_boxed (&value);
 356   g_assert (v2 != v);
 357   g_assert_cmpint (v->domain, ==, v2->domain);
 358   g_assert_cmpint (v->code, ==, v2->code);
 359   g_assert_cmpstr (v->message, ==, v2->message);
 360   g_error_free (v2);
 361
 362   g_value_unset (&value);
 363 }
 364
 365 int
 366 main (int argc, char *argv[])
 367 {
 368   g_type_init ();
 369   g_test_init (&argc, &argv, NULL);
 370
 371   g_test_add_func ("/boxed/define", test_define_boxed);
 372   g_test_add_func ("/boxed/ownership", test_boxed_ownership);
 373   g_test_add_func ("/boxed/closure", test_boxed_closure);
 374   g_test_add_func ("/boxed/date", test_boxed_date);
 375   g_test_add_func ("/boxed/value", test_boxed_value);
 376   g_test_add_func ("/boxed/string", test_boxed_string);
 377   g_test_add_func ("/boxed/hashtable", test_boxed_hashtable);
 378   g_test_add_func ("/boxed/array", test_boxed_array);
 379   g_test_add_func ("/boxed/ptrarray", test_boxed_ptrarray);
 380   g_test_add_func ("/boxed/regex", test_boxed_regex);
 381   g_test_add_func ("/boxed/varianttype", test_boxed_varianttype);
 382   g_test_add_func ("/boxed/error", test_boxed_error);
 383   g_test_add_func ("/boxed/datetime", test_boxed_datetime);
 384
 385   return g_test_run ();
 386 }