gobject/tests/boxed.c

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