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