gobject/tests/boxed.c

   1 #ifndef GLIB_DISABLE_DEPRECATION_WARNINGS
   2 #define GLIB_DISABLE_DEPRECATION_WARNINGS
   3 #endif
   4
   5 #include <glib-object.h>
   6
   7 typedef struct _MyBoxed MyBoxed;
   8
   9 struct _MyBoxed
  10 {
  11   gint ivalue;
  12   gchar *bla;
  13 };
  14
  15 static gpointer
  16 my_boxed_copy (gpointer orig)
  17 {
  18   MyBoxed *a = orig;
  19   MyBoxed *b;
  20
  21   b = g_slice_new (MyBoxed);
  22   b->ivalue = a->ivalue;
  23   b->bla = g_strdup (a->bla);
  24
  25   return b;
  26 }
  27
  28 static gint my_boxed_free_count;
  29
  30 static void
  31 my_boxed_free (gpointer orig)
  32 {
  33   MyBoxed *a = orig;
  34
  35   g_free (a->bla);
  36   g_slice_free (MyBoxed, a);
  37
  38   my_boxed_free_count++;
  39 }
  40
  41 static GType my_boxed_get_type (void);
  42 #define MY_TYPE_BOXED (my_boxed_get_type ())
  43
  44 G_DEFINE_BOXED_TYPE (MyBoxed, my_boxed, my_boxed_copy, my_boxed_free)
  45
  46 static void
  47 test_define_boxed (void)
  48 {
  49   MyBoxed a;
  50   MyBoxed *b;
  51
  52   a.ivalue = 20;
  53   a.bla = g_strdup ("bla");
  54
  55   b = g_boxed_copy (MY_TYPE_BOXED, &a);
  56
  57   g_assert_cmpint (b->ivalue, ==, 20);
  58   g_assert_cmpstr (b->bla, ==, "bla");
  59
  60   g_boxed_free (MY_TYPE_BOXED, b);
  61
  62   g_free (a.bla);
  63 }
  64
  65 static void
  66 test_boxed_ownership (void)
  67 {
  68   GValue value = G_VALUE_INIT;
  69   static MyBoxed boxed = { 10, "bla" };
  70
  71   g_value_init (&value, MY_TYPE_BOXED);
  72
  73   my_boxed_free_count = 0;
  74
  75   g_value_set_static_boxed (&value, &boxed);
  76   g_value_reset (&value);
  77
  78   g_assert_cmpint (my_boxed_free_count, ==, 0);
  79
  80   g_value_set_boxed_take_ownership (&value, g_boxed_copy (MY_TYPE_BOXED, &boxed));
  81   g_value_reset (&value);
  82   g_assert_cmpint (my_boxed_free_count, ==, 1);
  83
  84   g_value_take_boxed (&value, g_boxed_copy (MY_TYPE_BOXED, &boxed));
  85   g_value_reset (&value);
  86   g_assert_cmpint (my_boxed_free_count, ==, 2);
  87
  88   g_value_set_boxed (&value, &boxed);
  89   g_value_reset (&value);
  90   g_assert_cmpint (my_boxed_free_count, ==, 3);
  91 }
  92
  93 static void
  94 my_callback (gpointer user_data)
  95 {
  96 }
  97
  98 static gint destroy_count;
  99
 100 static void
 101 my_closure_notify (gpointer user_data, GClosure *closure)
 102 {
 103   destroy_count++;
 104 }
 105
 106 static void
 107 test_boxed_closure (void)
 108 {
 109   GClosure *closure;
 110   GClosure *closure2;
 111   GValue value = G_VALUE_INIT;
 112
 113   g_value_init (&value, G_TYPE_CLOSURE);
 114   g_assert (G_VALUE_HOLDS_BOXED (&value));
 115
 116   closure = g_cclosure_new (G_CALLBACK (my_callback), "bla", my_closure_notify);
 117   g_value_take_boxed (&value, closure);
 118
 119   closure2 = g_value_get_boxed (&value);
 120   g_assert (closure2 == closure);
 121
 122   closure2 = g_value_dup_boxed (&value);
 123   g_assert (closure2 == closure); /* closures use ref/unref for copy/free */
 124   g_closure_unref (closure2);
 125
 126   g_value_unset (&value);
 127   g_assert_cmpint (destroy_count, ==, 1);
 128 }
 129
 130 static void
 131 test_boxed_date (void)
 132 {
 133   GDate *date;
 134   GDate *date2;
 135   GValue value = G_VALUE_INIT;
 136
 137   g_value_init (&value, G_TYPE_DATE);
 138   g_assert (G_VALUE_HOLDS_BOXED (&value));
 139
 140   date = g_date_new_dmy (1, 3, 1970);
 141   g_value_take_boxed (&value, date);
 142
 143   date2 = g_value_get_boxed (&value);
 144   g_assert (date2 == date);
 145
 146   date2 = g_value_dup_boxed (&value);
 147   g_assert (date2 != date);
 148   g_assert (g_date_compare (date, date2) == 0);
 149   g_date_free (date2);
 150
 151   g_value_unset (&value);
 152 }
 153
 154 static void
 155 test_boxed_value (void)
 156 {
 157   GValue value1 = G_VALUE_INIT;
 158   GValue *value2;
 159   GValue value = G_VALUE_INIT;
 160
 161   g_value_init (&value, G_TYPE_VALUE);
 162   g_assert (G_VALUE_HOLDS_BOXED (&value));
 163
 164   g_value_init (&value1, G_TYPE_INT);
 165   g_value_set_int (&value1, 26);
 166
 167   g_value_set_static_boxed (&value, &value1);
 168
 169   value2 = g_value_get_boxed (&value);
 170   g_assert (value2 == &value1);
 171
 172   value2 = g_value_dup_boxed (&value);
 173   g_assert (value2 != &value1);
 174   g_assert (G_VALUE_HOLDS_INT (value2));
 175   g_assert_cmpint (g_value_get_int (value2), ==, 26);
 176   g_boxed_free (G_TYPE_VALUE, value2);
 177
 178   g_value_unset (&value);
 179 }
 180
 181 static void
 182 test_boxed_string (void)
 183 {
 184   GString *v;
 185   GString *v2;
 186   GValue value = G_VALUE_INIT;
 187
 188   g_value_init (&value, G_TYPE_GSTRING);
 189   g_assert (G_VALUE_HOLDS_BOXED (&value));
 190
 191   v = g_string_new ("bla");
 192   g_value_take_boxed (&value, v);
 193
 194   v2 = g_value_get_boxed (&value);
 195   g_assert (v2 == v);
 196
 197   v2 = g_value_dup_boxed (&value);
 198   g_assert (v2 != v);
 199   g_assert (g_string_equal (v, v2));
 200   g_string_free (v2, TRUE);
 201
 202   g_value_unset (&value);
 203 }
 204
 205 static void
 206 test_boxed_hashtable (void)
 207 {
 208   GHashTable *v;
 209   GHashTable *v2;
 210   GValue value = G_VALUE_INIT;
 211
 212   g_value_init (&value, G_TYPE_HASH_TABLE);
 213   g_assert (G_VALUE_HOLDS_BOXED (&value));
 214
 215   v = g_hash_table_new (g_str_hash, g_str_equal);
 216   g_value_take_boxed (&value, v);
 217
 218   v2 = g_value_get_boxed (&value);
 219   g_assert (v2 == v);
 220
 221   v2 = g_value_dup_boxed (&value);
 222   g_assert (v2 == v);  /* hash tables use ref/unref for copy/free */
 223   g_hash_table_unref (v2);
 224
 225   g_value_unset (&value);
 226 }
 227
 228 static void
 229 test_boxed_array (void)
 230 {
 231   GArray *v;
 232   GArray *v2;
 233   GValue value = G_VALUE_INIT;
 234
 235   g_value_init (&value, G_TYPE_ARRAY);
 236   g_assert (G_VALUE_HOLDS_BOXED (&value));
 237
 238   v = g_array_new (TRUE, FALSE, 1);
 239   g_value_take_boxed (&value, v);
 240
 241   v2 = g_value_get_boxed (&value);
 242   g_assert (v2 == v);
 243
 244   v2 = g_value_dup_boxed (&value);
 245   g_assert (v2 == v);  /* arrays use ref/unref for copy/free */
 246   g_array_unref (v2);
 247
 248   g_value_unset (&value);
 249 }
 250
 251 static void
 252 test_boxed_ptrarray (void)
 253 {
 254   GPtrArray *v;
 255   GPtrArray *v2;
 256   GValue value = G_VALUE_INIT;
 257
 258   g_value_init (&value, G_TYPE_PTR_ARRAY);
 259   g_assert (G_VALUE_HOLDS_BOXED (&value));
 260
 261   v = g_ptr_array_new ();
 262   g_value_take_boxed (&value, v);
 263
 264   v2 = g_value_get_boxed (&value);
 265   g_assert (v2 == v);
 266
 267   v2 = g_value_dup_boxed (&value);
 268   g_assert (v2 == v);  /* ptr arrays use ref/unref for copy/free */
 269   g_ptr_array_unref (v2);
 270
 271   g_value_unset (&value);
 272 }
 273
 274 static void
 275 test_boxed_regex (void)
 276 {
 277   GRegex *v;
 278   GRegex *v2;
 279   GValue value = G_VALUE_INIT;
 280
 281   g_value_init (&value, G_TYPE_REGEX);
 282   g_assert (G_VALUE_HOLDS_BOXED (&value));
 283
 284   v = g_regex_new ("a+b+", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, NULL);
 285   g_value_take_boxed (&value, v);
 286
 287   v2 = g_value_get_boxed (&value);
 288   g_assert (v2 == v);
 289
 290   v2 = g_value_dup_boxed (&value);
 291   g_assert (v2 == v);  /* regexes use ref/unref for copy/free */
 292   g_regex_unref (v2);
 293
 294   g_value_unset (&value);
 295 }
 296
 297 static void
 298 test_boxed_matchinfo (void)
 299 {
 300   GRegex *r;
 301   GMatchInfo *info, *info2;
 302   gboolean ret;
 303   GValue value = G_VALUE_INIT;
 304
 305   g_value_init (&value, G_TYPE_MATCH_INFO);
 306   g_assert (G_VALUE_HOLDS_BOXED (&value));
 307
 308   r = g_regex_new ("ab", G_REGEX_DEFAULT, G_REGEX_MATCH_DEFAULT, NULL);
 309   ret = g_regex_match (r, "blabla abab bla", 0, &info);
 310   g_assert (ret);
 311   g_value_take_boxed (&value, info);
 312
 313   info2 = g_value_get_boxed (&value);
 314   g_assert (info == info2);
 315
 316   info2 = g_value_dup_boxed (&value);
 317   g_assert (info == info2);  /* matchinfo uses ref/unref for copy/free */
 318   g_match_info_unref (info2);
 319
 320   g_value_unset (&value);
 321   g_regex_unref (r);
 322 }
 323
 324 static void
 325 test_boxed_varianttype (void)
 326 {
 327   GVariantType *v;
 328   GVariantType *v2;
 329   GValue value = G_VALUE_INIT;
 330
 331   g_value_init (&value, G_TYPE_VARIANT_TYPE);
 332   g_assert (G_VALUE_HOLDS_BOXED (&value));
 333
 334   v = g_variant_type_new ("mas");
 335   g_value_take_boxed (&value, v);
 336
 337   v2 = g_value_get_boxed (&value);
 338   g_assert (v2 == v);
 339
 340   v2 = g_value_dup_boxed (&value);
 341   g_assert (v2 != v);
 342   g_assert_cmpstr (g_variant_type_peek_string (v), ==, g_variant_type_peek_string (v2));
 343   g_variant_type_free (v2);
 344
 345   g_value_unset (&value);
 346 }
 347
 348 static void
 349 test_boxed_datetime (void)
 350 {
 351   GDateTime *v;
 352   GDateTime *v2;
 353   GValue value = G_VALUE_INIT;
 354
 355   g_value_init (&value, G_TYPE_DATE_TIME);
 356   g_assert (G_VALUE_HOLDS_BOXED (&value));
 357
 358   v = g_date_time_new_now_local ();
 359   g_value_take_boxed (&value, v);
 360
 361   v2 = g_value_get_boxed (&value);
 362   g_assert (v2 == v);
 363
 364   v2 = g_value_dup_boxed (&value);
 365   g_assert (v2 == v); /* datetime uses ref/unref for copy/free */
 366   g_date_time_unref (v2);
 367
 368   g_value_unset (&value);
 369 }
 370
 371 static void
 372 test_boxed_error (void)
 373 {
 374   GError *v;
 375   GError *v2;
 376   GValue value = G_VALUE_INIT;
 377
 378   g_value_init (&value, G_TYPE_ERROR);
 379   g_assert (G_VALUE_HOLDS_BOXED (&value));
 380
 381   v = g_error_new_literal (G_VARIANT_PARSE_ERROR,
 382                            G_VARIANT_PARSE_ERROR_NUMBER_TOO_BIG,
 383                            "Too damn big");
 384   g_value_take_boxed (&value, v);
 385
 386   v2 = g_value_get_boxed (&value);
 387   g_assert (v2 == v);
 388
 389   v2 = g_value_dup_boxed (&value);
 390   g_assert (v2 != v);
 391   g_assert_cmpint (v->domain, ==, v2->domain);
 392   g_assert_cmpint (v->code, ==, v2->code);
 393   g_assert_cmpstr (v->message, ==, v2->message);
 394   g_error_free (v2);
 395
 396   g_value_unset (&value);
 397 }
 398
 399 static void
 400 test_boxed_keyfile (void)
 401 {
 402   GKeyFile *k, *k2;
 403   GValue value = G_VALUE_INIT;
 404
 405   g_value_init (&value, G_TYPE_KEY_FILE);
 406   g_assert (G_VALUE_HOLDS_BOXED (&value));
 407
 408   k = g_key_file_new ();
 409   g_value_take_boxed (&value, k);
 410
 411   k2 = g_value_get_boxed (&value);
 412   g_assert (k == k2);
 413
 414   k2 = g_value_dup_boxed (&value);
 415   g_assert (k == k2);  /* keyfile uses ref/unref for copy/free */
 416   g_key_file_unref (k2);
 417
 418   g_value_unset (&value);
 419 }
 420
 421 static void
 422 test_boxed_mainloop (void)
 423 {
 424   GMainLoop *l, *l2;
 425   GValue value = G_VALUE_INIT;
 426
 427   g_value_init (&value, G_TYPE_MAIN_LOOP);
 428   g_assert (G_VALUE_HOLDS_BOXED (&value));
 429
 430   l = g_main_loop_new (NULL, FALSE);
 431   g_value_take_boxed (&value, l);
 432
 433   l2 = g_value_get_boxed (&value);
 434   g_assert (l == l2);
 435
 436   l2 = g_value_dup_boxed (&value);
 437   g_assert (l == l2);  /* mainloop uses ref/unref for copy/free */
 438   g_main_loop_unref (l2);
 439
 440   g_value_unset (&value);
 441 }
 442
 443 static void
 444 test_boxed_maincontext (void)
 445 {
 446   GMainContext *c, *c2;
 447   GValue value = G_VALUE_INIT;
 448
 449   g_value_init (&value, G_TYPE_MAIN_CONTEXT);
 450   g_assert (G_VALUE_HOLDS_BOXED (&value));
 451
 452   c = g_main_context_new ();
 453   g_value_take_boxed (&value, c);
 454
 455   c2 = g_value_get_boxed (&value);
 456   g_assert (c == c2);
 457
 458   c2 = g_value_dup_boxed (&value);
 459   g_assert (c == c2);  /* maincontext uses ref/unref for copy/free */
 460   g_main_context_unref (c2);
 461
 462   g_value_unset (&value);
 463 }
 464
 465 static void
 466 test_boxed_source (void)
 467 {
 468   GSource *s, *s2;
 469   GValue value = G_VALUE_INIT;
 470
 471   g_value_init (&value, G_TYPE_SOURCE);
 472   g_assert (G_VALUE_HOLDS_BOXED (&value));
 473
 474   s = g_idle_source_new ();
 475   g_value_take_boxed (&value, s);
 476
 477   s2 = g_value_get_boxed (&value);
 478   g_assert (s == s2);
 479
 480   s2 = g_value_dup_boxed (&value);
 481   g_assert (s == s2);  /* source uses ref/unref for copy/free */
 482   g_source_unref (s2);
 483
 484   g_value_unset (&value);
 485 }
 486
 487 static void
 488 test_boxed_variantbuilder (void)
 489 {
 490   GVariantBuilder *v, *v2;
 491   GValue value = G_VALUE_INIT;
 492
 493   g_value_init (&value, G_TYPE_VARIANT_BUILDER);
 494   g_assert (G_VALUE_HOLDS_BOXED (&value));
 495
 496   v = g_variant_builder_new (G_VARIANT_TYPE_OBJECT_PATH_ARRAY);
 497   g_value_take_boxed (&value, v);
 498
 499   v2 = g_value_get_boxed (&value);
 500   g_assert (v == v2);
 501
 502   v2 = g_value_dup_boxed (&value);
 503   g_assert (v == v2);  /* variantbuilder uses ref/unref for copy/free */
 504   g_variant_builder_unref (v2);
 505
 506   g_value_unset (&value);
 507 }
 508
 509 static void
 510 test_boxed_timezone (void)
 511 {
 512   GTimeZone *z, *z2;
 513   GValue value = G_VALUE_INIT;
 514
 515   g_value_init (&value, G_TYPE_TIME_ZONE);
 516   g_assert (G_VALUE_HOLDS_BOXED (&value));
 517
 518   z = g_time_zone_new_utc ();
 519   g_value_take_boxed (&value, z);
 520
 521   z2 = g_value_get_boxed (&value);
 522   g_assert (z == z2);
 523
 524   z2 = g_value_dup_boxed (&value);
 525   g_assert (z == z2);  /* timezone uses ref/unref for copy/free */
 526   g_time_zone_unref (z2);
 527
 528   g_value_unset (&value);
 529 }
 530
 531 static void
 532 test_boxed_pollfd (void)
 533 {
 534   GPollFD *p, *p2;
 535   GValue value = G_VALUE_INIT;
 536
 537   g_value_init (&value, G_TYPE_POLLFD);
 538   g_assert (G_VALUE_HOLDS_BOXED (&value));
 539
 540   p = g_new (GPollFD, 1);
 541   g_value_take_boxed (&value, p);
 542
 543   p2 = g_value_get_boxed (&value);
 544   g_assert (p == p2);
 545
 546   p2 = g_value_dup_boxed (&value);
 547   g_assert (p != p2);
 548   g_free (p2);
 549
 550   g_value_unset (&value);
 551 }
 552
 553 static void
 554 test_boxed_markup (void)
 555 {
 556   GMarkupParseContext *c, *c2;
 557   const GMarkupParser parser = { 0 };
 558   GValue value = G_VALUE_INIT;
 559
 560   g_value_init (&value, G_TYPE_MARKUP_PARSE_CONTEXT);
 561   g_assert (G_VALUE_HOLDS_BOXED (&value));
 562
 563   c = g_markup_parse_context_new (&parser, G_MARKUP_DEFAULT_FLAGS, NULL, NULL);
 564   g_value_take_boxed (&value, c);
 565
 566   c2 = g_value_get_boxed (&value);
 567   g_assert (c == c2);
 568
 569   c2 = g_value_dup_boxed (&value);
 570   g_assert (c == c2);
 571   g_markup_parse_context_unref (c2);
 572
 573   g_value_unset (&value);
 574 }
 575
 576 static void
 577 test_boxed_thread (void)
 578 {
 579   GThread *t, *t2;
 580   GValue value = G_VALUE_INIT;
 581
 582   g_value_init (&value, G_TYPE_THREAD);
 583   g_assert (G_VALUE_HOLDS_BOXED (&value));
 584
 585   t = g_thread_self ();
 586   g_value_set_boxed (&value, t);
 587
 588   t2 = g_value_get_boxed (&value);
 589   g_assert (t == t2);
 590
 591   t2 = g_value_dup_boxed (&value);
 592   g_assert (t == t2);
 593   g_thread_unref (t2);
 594
 595   g_value_unset (&value);
 596 }
 597
 598 static void
 599 test_boxed_checksum (void)
 600 {
 601   GChecksum *c, *c2;
 602   GValue value = G_VALUE_INIT;
 603
 604   g_value_init (&value, G_TYPE_CHECKSUM);
 605   g_assert (G_VALUE_HOLDS_BOXED (&value));
 606
 607   c = g_checksum_new (G_CHECKSUM_SHA512);
 608   g_value_take_boxed (&value, c);
 609
 610   c2 = g_value_get_boxed (&value);
 611   g_assert (c == c2);
 612
 613   c2 = g_value_dup_boxed (&value);
 614   g_assert (c != c2);
 615   g_checksum_free (c2);
 616
 617   g_value_unset (&value);
 618 }
 619
 620 static gint
 621 treecmp (gconstpointer a, gconstpointer b)
 622 {
 623   return (a < b) ? -1 : (a > b);
 624 }
 625
 626 static void
 627 test_boxed_tree (void)
 628 {
 629   GTree *t, *t2;
 630   GValue value = G_VALUE_INIT;
 631
 632   g_value_init (&value, G_TYPE_TREE);
 633   g_assert_true (G_VALUE_HOLDS_BOXED (&value));
 634
 635   t = g_tree_new (treecmp);
 636   g_value_take_boxed (&value, t);
 637
 638   t2 = g_value_get_boxed (&value);
 639   g_assert_true (t == t2);
 640
 641   t2 = g_value_dup_boxed (&value);
 642   g_assert_true (t == t2); /* trees use ref/unref for copy/free */
 643   g_tree_unref (t2);
 644
 645   g_value_unset (&value);
 646 }
 647
 648 static void
 649 test_boxed_pattern_spec (void)
 650 {
 651   GPatternSpec *ps, *ps2;
 652   GValue value = G_VALUE_INIT;
 653
 654   g_value_init (&value, G_TYPE_PATTERN_SPEC);
 655   g_assert_true (G_VALUE_HOLDS_BOXED (&value));
 656
 657   ps = g_pattern_spec_new ("*abc*?cde");
 658   g_value_take_boxed (&value, ps);
 659
 660   ps2 = g_value_get_boxed (&value);
 661   g_assert_true (ps == ps2);
 662
 663   ps2 = g_value_dup_boxed (&value);
 664   g_assert_true (ps != ps2);
 665   g_assert_true (g_pattern_spec_equal (ps, ps2));
 666   g_pattern_spec_free (ps2);
 667
 668   g_value_unset (&value);
 669 }
 670
 671 static void
 672 test_boxed_rand (void)
 673 {
 674   GRand *r, *r2;
 675   GValue value = G_VALUE_INIT;
 676
 677   g_value_init (&value, G_TYPE_RAND);
 678   g_assert_true (G_VALUE_HOLDS_BOXED (&value));
 679
 680   r = g_rand_new ();
 681   g_value_take_boxed (&value, r);
 682
 683   r2 = g_value_get_boxed (&value);
 684   g_assert_true (r == r2);
 685
 686   r2 = g_value_dup_boxed (&value);
 687   g_assert_true (r != r2);
 688   g_rand_free (r2);
 689
 690   g_value_unset (&value);
 691 }
 692
 693 int
 694 main (int argc, char *argv[])
 695 {
 696   g_test_init (&argc, &argv, NULL);
 697
 698   g_test_add_func ("/boxed/define", test_define_boxed);
 699   g_test_add_func ("/boxed/ownership", test_boxed_ownership);
 700   g_test_add_func ("/boxed/closure", test_boxed_closure);
 701   g_test_add_func ("/boxed/date", test_boxed_date);
 702   g_test_add_func ("/boxed/value", test_boxed_value);
 703   g_test_add_func ("/boxed/string", test_boxed_string);
 704   g_test_add_func ("/boxed/hashtable", test_boxed_hashtable);
 705   g_test_add_func ("/boxed/array", test_boxed_array);
 706   g_test_add_func ("/boxed/ptrarray", test_boxed_ptrarray);
 707   g_test_add_func ("/boxed/regex", test_boxed_regex);
 708   g_test_add_func ("/boxed/varianttype", test_boxed_varianttype);
 709   g_test_add_func ("/boxed/error", test_boxed_error);
 710   g_test_add_func ("/boxed/datetime", test_boxed_datetime);
 711   g_test_add_func ("/boxed/matchinfo", test_boxed_matchinfo);
 712   g_test_add_func ("/boxed/keyfile", test_boxed_keyfile);
 713   g_test_add_func ("/boxed/mainloop", test_boxed_mainloop);
 714   g_test_add_func ("/boxed/maincontext", test_boxed_maincontext);
 715   g_test_add_func ("/boxed/source", test_boxed_source);
 716   g_test_add_func ("/boxed/variantbuilder", test_boxed_variantbuilder);
 717   g_test_add_func ("/boxed/timezone", test_boxed_timezone);
 718   g_test_add_func ("/boxed/pollfd", test_boxed_pollfd);
 719   g_test_add_func ("/boxed/markup", test_boxed_markup);
 720   g_test_add_func ("/boxed/thread", test_boxed_thread);
 721   g_test_add_func ("/boxed/checksum", test_boxed_checksum);
 722   g_test_add_func ("/boxed/tree", test_boxed_tree);
 723   g_test_add_func ("/boxed/patternspec", test_boxed_pattern_spec);
 724   g_test_add_func ("/boxed/rand", test_boxed_rand);
 725
 726   return g_test_run ();
 727 }