gobject/tests/param.c

   1 #define GLIB_DISABLE_DEPRECATION_WARNINGS
   2 #include <glib-object.h>
   3
   4 static void
   5 test_param_value (void)
   6 {
   7   GParamSpec *p, *p2;
   8   GParamSpec *pp;
   9   GValue value = G_VALUE_INIT;
  10
  11   g_value_init (&value, G_TYPE_PARAM);
  12   g_assert (G_VALUE_HOLDS_PARAM (&value));
  13
  14   p = g_param_spec_int ("my-int", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);
  15
  16   g_value_take_param (&value, p);
  17   p2 = g_value_get_param (&value);
  18   g_assert (p2 == p);
  19
  20   pp = g_param_spec_uint ("my-uint", "My UInt", "Blurb", 0, 10, 5, G_PARAM_READWRITE);
  21   g_value_set_param (&value, pp);
  22
  23   p2 = g_value_dup_param (&value);
  24   g_assert (p2 == pp); /* param specs use ref/unref for copy/free */
  25   g_param_spec_unref (p2);
  26
  27   g_value_unset (&value);
  28   g_param_spec_unref (pp);
  29 }
  30
  31 static gint destroy_count;
  32
  33 static void
  34 my_destroy (gpointer data)
  35 {
  36   destroy_count++;
  37 }
  38
  39 static void
  40 test_param_qdata (void)
  41 {
  42   GParamSpec *p;
  43   gchar *bla;
  44   GQuark q;
  45
  46   q = g_quark_from_string ("bla");
  47
  48   p = g_param_spec_int ("my-int", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);
  49   g_param_spec_set_qdata (p, q, "bla");
  50   bla = g_param_spec_get_qdata (p, q);
  51   g_assert_cmpstr (bla, ==, "bla");
  52
  53   g_assert_cmpint (destroy_count, ==, 0);
  54   g_param_spec_set_qdata_full (p, q, "bla", my_destroy);
  55   g_param_spec_set_qdata_full (p, q, "blabla", my_destroy);
  56   g_assert_cmpint (destroy_count, ==, 1);
  57   g_assert_cmpstr (g_param_spec_steal_qdata (p, q), ==, "blabla");
  58   g_assert_cmpint (destroy_count, ==, 1);
  59   g_assert (g_param_spec_get_qdata (p, q) == NULL);
  60
  61   g_param_spec_ref_sink (p);
  62
  63   g_param_spec_unref (p);
  64 }
  65
  66 static void
  67 test_param_validate (void)
  68 {
  69   GParamSpec *p;
  70   GValue value = G_VALUE_INIT;
  71
  72   p = g_param_spec_int ("my-int", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);
  73
  74   g_value_init (&value, G_TYPE_INT);
  75   g_value_set_int (&value, 100);
  76   g_assert (!g_param_value_defaults (p, &value));
  77   g_assert (g_param_value_validate (p, &value));
  78   g_assert_cmpint (g_value_get_int (&value), ==, 20);
  79
  80   g_param_value_set_default (p, &value);
  81   g_assert (g_param_value_defaults (p, &value));
  82   g_assert_cmpint (g_value_get_int (&value), ==, 10);
  83
  84   g_param_spec_unref (p);
  85 }
  86
  87 static void
  88 test_param_strings (void)
  89 {
  90   GParamSpec *p;
  91
  92   /* test canonicalization */
  93   p = g_param_spec_int ("my_int:bla", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);
  94
  95   g_assert_cmpstr (g_param_spec_get_name (p), ==, "my-int-bla");
  96   g_assert_cmpstr (g_param_spec_get_nick (p), ==, "My Int");
  97   g_assert_cmpstr (g_param_spec_get_blurb (p), ==, "Blurb");
  98
  99   g_param_spec_unref (p);
 100
 101   /* test nick defaults to name */
 102   p = g_param_spec_int ("my-int", NULL, NULL, 0, 20, 10, G_PARAM_READWRITE);
 103
 104   g_assert_cmpstr (g_param_spec_get_name (p), ==, "my-int");
 105   g_assert_cmpstr (g_param_spec_get_nick (p), ==, "my-int");
 106   g_assert (g_param_spec_get_blurb (p) == NULL);
 107
 108   g_param_spec_unref (p);
 109 }
 110
 111 static void
 112 test_param_convert (void)
 113 {
 114   GParamSpec *p;
 115   GValue v1 = G_VALUE_INIT;
 116   GValue v2 = G_VALUE_INIT;
 117
 118   p = g_param_spec_int ("my-int", "My Int", "Blurb", 0, 20, 10, G_PARAM_READWRITE);
 119   g_value_init (&v1, G_TYPE_UINT);
 120   g_value_set_uint (&v1, 43);
 121
 122   g_value_init (&v2, G_TYPE_INT);
 123   g_value_set_int (&v2, -4);
 124
 125   g_assert (!g_param_value_convert (p, &v1, &v2, TRUE));
 126   g_assert_cmpint (g_value_get_int (&v2), ==, -4);
 127
 128   g_assert (g_param_value_convert (p, &v1, &v2, FALSE));
 129   g_assert_cmpint (g_value_get_int (&v2), ==, 20);
 130
 131   g_param_spec_unref (p);
 132 }
 133
 134 static void
 135 test_value_transform (void)
 136 {
 137   GValue src = G_VALUE_INIT;
 138   GValue dest = G_VALUE_INIT;
 139
 140 #define CHECK_INT_CONVERSION(type, getter, value)                       \
 141   g_assert (g_value_type_transformable (G_TYPE_INT, type));             \
 142   g_value_init (&src, G_TYPE_INT);                                      \
 143   g_value_init (&dest, type);                                           \
 144   g_value_set_int (&src, value);                                        \
 145   g_assert (g_value_transform (&src, &dest));                           \
 146   g_assert_cmpint (g_value_get_##getter (&dest), ==, value);            \
 147   g_value_unset (&src);                                                 \
 148   g_value_unset (&dest);
 149
 150   /* Keep a check for an integer in the range of 0-127 so we're
 151    * still testing g_value_get_char().  See
 152    * https://bugzilla.gnome.org/show_bug.cgi?id=659870
 153    * for why it is broken.
 154    */
 155   CHECK_INT_CONVERSION(G_TYPE_CHAR, char, 124)
 156
 157   CHECK_INT_CONVERSION(G_TYPE_CHAR, schar, -124)
 158   CHECK_INT_CONVERSION(G_TYPE_CHAR, schar, 124)
 159   CHECK_INT_CONVERSION(G_TYPE_UCHAR, uchar, 0)
 160   CHECK_INT_CONVERSION(G_TYPE_UCHAR, uchar, 255)
 161   CHECK_INT_CONVERSION(G_TYPE_INT, int, -12345)
 162   CHECK_INT_CONVERSION(G_TYPE_INT, int, 12345)
 163   CHECK_INT_CONVERSION(G_TYPE_UINT, uint, 0)
 164   CHECK_INT_CONVERSION(G_TYPE_UINT, uint, 12345)
 165   CHECK_INT_CONVERSION(G_TYPE_LONG, long, -12345678)
 166   CHECK_INT_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
 167   CHECK_INT_CONVERSION(G_TYPE_INT64, int64, -12345678)
 168   CHECK_INT_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
 169   CHECK_INT_CONVERSION(G_TYPE_FLOAT, float, 12345678)
 170   CHECK_INT_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 171
 172 #define CHECK_UINT_CONVERSION(type, getter, value)                      \
 173   g_assert (g_value_type_transformable (G_TYPE_UINT, type));            \
 174   g_value_init (&src, G_TYPE_UINT);                                     \
 175   g_value_init (&dest, type);                                           \
 176   g_value_set_uint (&src, value);                                       \
 177   g_assert (g_value_transform (&src, &dest));                           \
 178   g_assert_cmpuint (g_value_get_##getter (&dest), ==, value);           \
 179   g_value_unset (&src);                                                 \
 180   g_value_unset (&dest);
 181
 182   CHECK_UINT_CONVERSION(G_TYPE_CHAR, char, 124)
 183   CHECK_UINT_CONVERSION(G_TYPE_CHAR, char, 124)
 184   CHECK_UINT_CONVERSION(G_TYPE_UCHAR, uchar, 0)
 185   CHECK_UINT_CONVERSION(G_TYPE_UCHAR, uchar, 255)
 186   CHECK_UINT_CONVERSION(G_TYPE_INT, int, 12345)
 187   CHECK_UINT_CONVERSION(G_TYPE_INT, int, 12345)
 188   CHECK_UINT_CONVERSION(G_TYPE_UINT, uint, 0)
 189   CHECK_UINT_CONVERSION(G_TYPE_UINT, uint, 12345)
 190   CHECK_UINT_CONVERSION(G_TYPE_LONG, long, 12345678)
 191   CHECK_UINT_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
 192   CHECK_UINT_CONVERSION(G_TYPE_INT64, int64, 12345678)
 193   CHECK_UINT_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
 194   CHECK_UINT_CONVERSION(G_TYPE_FLOAT, float, 12345678)
 195   CHECK_UINT_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 196
 197 #define CHECK_LONG_CONVERSION(type, getter, value)                      \
 198   g_assert (g_value_type_transformable (G_TYPE_LONG, type));            \
 199   g_value_init (&src, G_TYPE_LONG);                                     \
 200   g_value_init (&dest, type);                                           \
 201   g_value_set_long (&src, value);                                       \
 202   g_assert (g_value_transform (&src, &dest));                           \
 203   g_assert_cmpint (g_value_get_##getter (&dest), ==, value);            \
 204   g_value_unset (&src);                                                 \
 205   g_value_unset (&dest);
 206
 207   CHECK_LONG_CONVERSION(G_TYPE_CHAR, schar, -124)
 208   CHECK_LONG_CONVERSION(G_TYPE_CHAR, schar, 124)
 209   CHECK_LONG_CONVERSION(G_TYPE_UCHAR, uchar, 0)
 210   CHECK_LONG_CONVERSION(G_TYPE_UCHAR, uchar, 255)
 211   CHECK_LONG_CONVERSION(G_TYPE_INT, int, -12345)
 212   CHECK_LONG_CONVERSION(G_TYPE_INT, int, 12345)
 213   CHECK_LONG_CONVERSION(G_TYPE_UINT, uint, 0)
 214   CHECK_LONG_CONVERSION(G_TYPE_UINT, uint, 12345)
 215   CHECK_LONG_CONVERSION(G_TYPE_LONG, long, -12345678)
 216   CHECK_LONG_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
 217   CHECK_LONG_CONVERSION(G_TYPE_INT64, int64, -12345678)
 218   CHECK_LONG_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
 219   CHECK_LONG_CONVERSION(G_TYPE_FLOAT, float, 12345678)
 220   CHECK_LONG_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 221
 222 #define CHECK_ULONG_CONVERSION(type, getter, value)                     \
 223   g_assert (g_value_type_transformable (G_TYPE_ULONG, type));           \
 224   g_value_init (&src, G_TYPE_ULONG);                                    \
 225   g_value_init (&dest, type);                                           \
 226   g_value_set_ulong (&src, value);                                      \
 227   g_assert (g_value_transform (&src, &dest));                           \
 228   g_assert_cmpuint (g_value_get_##getter (&dest), ==, value);           \
 229   g_value_unset (&src);                                                 \
 230   g_value_unset (&dest);
 231
 232   CHECK_ULONG_CONVERSION(G_TYPE_CHAR, char, 124)
 233   CHECK_ULONG_CONVERSION(G_TYPE_CHAR, char, 124)
 234   CHECK_ULONG_CONVERSION(G_TYPE_UCHAR, uchar, 0)
 235   CHECK_ULONG_CONVERSION(G_TYPE_UCHAR, uchar, 255)
 236   CHECK_ULONG_CONVERSION(G_TYPE_INT, int, -12345)
 237   CHECK_ULONG_CONVERSION(G_TYPE_INT, int, 12345)
 238   CHECK_ULONG_CONVERSION(G_TYPE_UINT, uint, 0)
 239   CHECK_ULONG_CONVERSION(G_TYPE_UINT, uint, 12345)
 240   CHECK_ULONG_CONVERSION(G_TYPE_LONG, long, 12345678)
 241   CHECK_ULONG_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
 242   CHECK_ULONG_CONVERSION(G_TYPE_INT64, int64, 12345678)
 243   CHECK_ULONG_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
 244   CHECK_ULONG_CONVERSION(G_TYPE_FLOAT, float, 12345678)
 245   CHECK_ULONG_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 246
 247 #define CHECK_INT64_CONVERSION(type, getter, value)                     \
 248   g_assert (g_value_type_transformable (G_TYPE_INT64, type));           \
 249   g_value_init (&src, G_TYPE_INT64);                                    \
 250   g_value_init (&dest, type);                                           \
 251   g_value_set_int64 (&src, value);                                      \
 252   g_assert (g_value_transform (&src, &dest));                           \
 253   g_assert_cmpint (g_value_get_##getter (&dest), ==, value);            \
 254   g_value_unset (&src);                                                 \
 255   g_value_unset (&dest);
 256
 257   CHECK_INT64_CONVERSION(G_TYPE_CHAR, schar, -124)
 258   CHECK_INT64_CONVERSION(G_TYPE_CHAR, schar, 124)
 259   CHECK_INT64_CONVERSION(G_TYPE_UCHAR, uchar, 0)
 260   CHECK_INT64_CONVERSION(G_TYPE_UCHAR, uchar, 255)
 261   CHECK_INT64_CONVERSION(G_TYPE_INT, int, -12345)
 262   CHECK_INT64_CONVERSION(G_TYPE_INT, int, 12345)
 263   CHECK_INT64_CONVERSION(G_TYPE_UINT, uint, 0)
 264   CHECK_INT64_CONVERSION(G_TYPE_UINT, uint, 12345)
 265   CHECK_INT64_CONVERSION(G_TYPE_LONG, long, -12345678)
 266   CHECK_INT64_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
 267   CHECK_INT64_CONVERSION(G_TYPE_INT64, int64, -12345678)
 268   CHECK_INT64_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
 269   CHECK_INT64_CONVERSION(G_TYPE_FLOAT, float, 12345678)
 270   CHECK_INT64_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 271
 272 #define CHECK_UINT64_CONVERSION(type, getter, value)                    \
 273   g_assert (g_value_type_transformable (G_TYPE_UINT64, type));          \
 274   g_value_init (&src, G_TYPE_UINT64);                                   \
 275   g_value_init (&dest, type);                                           \
 276   g_value_set_uint64 (&src, value);                                     \
 277   g_assert (g_value_transform (&src, &dest));                           \
 278   g_assert_cmpuint (g_value_get_##getter (&dest), ==, value);           \
 279   g_value_unset (&src);                                                 \
 280   g_value_unset (&dest);
 281
 282   CHECK_UINT64_CONVERSION(G_TYPE_CHAR, schar, -124)
 283   CHECK_UINT64_CONVERSION(G_TYPE_CHAR, schar, 124)
 284   CHECK_UINT64_CONVERSION(G_TYPE_UCHAR, uchar, 0)
 285   CHECK_UINT64_CONVERSION(G_TYPE_UCHAR, uchar, 255)
 286   CHECK_UINT64_CONVERSION(G_TYPE_INT, int, -12345)
 287   CHECK_UINT64_CONVERSION(G_TYPE_INT, int, 12345)
 288   CHECK_UINT64_CONVERSION(G_TYPE_UINT, uint, 0)
 289   CHECK_UINT64_CONVERSION(G_TYPE_UINT, uint, 12345)
 290   CHECK_UINT64_CONVERSION(G_TYPE_LONG, long, -12345678)
 291   CHECK_UINT64_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
 292   CHECK_UINT64_CONVERSION(G_TYPE_INT64, int64, -12345678)
 293   CHECK_UINT64_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
 294   CHECK_UINT64_CONVERSION(G_TYPE_FLOAT, float, 12345678)
 295   CHECK_UINT64_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 296
 297 #define CHECK_FLOAT_CONVERSION(type, getter, value)                    \
 298   g_assert (g_value_type_transformable (G_TYPE_FLOAT, type));          \
 299   g_value_init (&src, G_TYPE_FLOAT);                                   \
 300   g_value_init (&dest, type);                                          \
 301   g_value_set_float (&src, value);                                     \
 302   g_assert (g_value_transform (&src, &dest));                          \
 303   g_assert_cmpfloat (g_value_get_##getter (&dest), ==, value);         \
 304   g_value_unset (&src);                                                \
 305   g_value_unset (&dest);
 306
 307   CHECK_FLOAT_CONVERSION(G_TYPE_CHAR, schar, -124)
 308   CHECK_FLOAT_CONVERSION(G_TYPE_CHAR, schar, 124)
 309   CHECK_FLOAT_CONVERSION(G_TYPE_UCHAR, uchar, 0)
 310   CHECK_FLOAT_CONVERSION(G_TYPE_UCHAR, uchar, 255)
 311   CHECK_FLOAT_CONVERSION(G_TYPE_INT, int, -12345)
 312   CHECK_FLOAT_CONVERSION(G_TYPE_INT, int, 12345)
 313   CHECK_FLOAT_CONVERSION(G_TYPE_UINT, uint, 0)
 314   CHECK_FLOAT_CONVERSION(G_TYPE_UINT, uint, 12345)
 315   CHECK_FLOAT_CONVERSION(G_TYPE_LONG, long, -12345678)
 316   CHECK_FLOAT_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
 317   CHECK_FLOAT_CONVERSION(G_TYPE_INT64, int64, -12345678)
 318   CHECK_FLOAT_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
 319   CHECK_FLOAT_CONVERSION(G_TYPE_FLOAT, float, 12345678)
 320   CHECK_FLOAT_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 321
 322 #define CHECK_DOUBLE_CONVERSION(type, getter, value)                    \
 323   g_assert (g_value_type_transformable (G_TYPE_DOUBLE, type));          \
 324   g_value_init (&src, G_TYPE_DOUBLE);                                   \
 325   g_value_init (&dest, type);                                           \
 326   g_value_set_double (&src, value);                                     \
 327   g_assert (g_value_transform (&src, &dest));                           \
 328   g_assert_cmpfloat (g_value_get_##getter (&dest), ==, value);          \
 329   g_value_unset (&src);                                                 \
 330   g_value_unset (&dest);
 331
 332   CHECK_DOUBLE_CONVERSION(G_TYPE_CHAR, schar, -124)
 333   CHECK_DOUBLE_CONVERSION(G_TYPE_CHAR, schar, 124)
 334   CHECK_DOUBLE_CONVERSION(G_TYPE_UCHAR, uchar, 0)
 335   CHECK_DOUBLE_CONVERSION(G_TYPE_UCHAR, uchar, 255)
 336   CHECK_DOUBLE_CONVERSION(G_TYPE_INT, int, -12345)
 337   CHECK_DOUBLE_CONVERSION(G_TYPE_INT, int, 12345)
 338   CHECK_DOUBLE_CONVERSION(G_TYPE_UINT, uint, 0)
 339   CHECK_DOUBLE_CONVERSION(G_TYPE_UINT, uint, 12345)
 340   CHECK_DOUBLE_CONVERSION(G_TYPE_LONG, long, -12345678)
 341   CHECK_DOUBLE_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
 342   CHECK_DOUBLE_CONVERSION(G_TYPE_INT64, int64, -12345678)
 343   CHECK_DOUBLE_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
 344   CHECK_DOUBLE_CONVERSION(G_TYPE_FLOAT, float, 12345678)
 345   CHECK_DOUBLE_CONVERSION(G_TYPE_DOUBLE, double, 12345678)
 346
 347 #define CHECK_BOOLEAN_CONVERSION(type, setter, value)                   \
 348   g_assert (g_value_type_transformable (type, G_TYPE_BOOLEAN));         \
 349   g_value_init (&src, type);                                            \
 350   g_value_init (&dest, G_TYPE_BOOLEAN);                                 \
 351   g_value_set_##setter (&src, value);                                   \
 352   g_assert (g_value_transform (&src, &dest));                           \
 353   g_assert_cmpint (g_value_get_boolean (&dest), ==, TRUE);              \
 354   g_value_set_##setter (&src, 0);                                       \
 355   g_assert (g_value_transform (&src, &dest));                           \
 356   g_assert_cmpint (g_value_get_boolean (&dest), ==, FALSE);             \
 357   g_value_unset (&src);                                                 \
 358   g_value_unset (&dest);
 359
 360   CHECK_BOOLEAN_CONVERSION(G_TYPE_INT, int, -12345)
 361   CHECK_BOOLEAN_CONVERSION(G_TYPE_UINT, uint, 12345)
 362   CHECK_BOOLEAN_CONVERSION(G_TYPE_LONG, long, -12345678)
 363   CHECK_BOOLEAN_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
 364   CHECK_BOOLEAN_CONVERSION(G_TYPE_INT64, int64, -12345678)
 365   CHECK_BOOLEAN_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
 366
 367 #define CHECK_STRING_CONVERSION(int_type, setter, int_value)            \
 368   g_assert (g_value_type_transformable (int_type, G_TYPE_STRING));      \
 369   g_value_init (&src, int_type);                                        \
 370   g_value_init (&dest, G_TYPE_STRING);                                  \
 371   g_value_set_##setter (&src, int_value);                               \
 372   g_assert (g_value_transform (&src, &dest));                           \
 373   g_assert_cmpstr (g_value_get_string (&dest), ==, #int_value);         \
 374   g_value_unset (&src);                                                 \
 375   g_value_unset (&dest);
 376
 377   CHECK_STRING_CONVERSION(G_TYPE_INT, int, -12345)
 378   CHECK_STRING_CONVERSION(G_TYPE_UINT, uint, 12345)
 379   CHECK_STRING_CONVERSION(G_TYPE_LONG, long, -12345678)
 380   CHECK_STRING_CONVERSION(G_TYPE_ULONG, ulong, 12345678)
 381   CHECK_STRING_CONVERSION(G_TYPE_INT64, int64, -12345678)
 382   CHECK_STRING_CONVERSION(G_TYPE_UINT64, uint64, 12345678)
 383   CHECK_STRING_CONVERSION(G_TYPE_FLOAT, float, 0.500000)
 384   CHECK_STRING_CONVERSION(G_TYPE_DOUBLE, double, -1.234567)
 385
 386   g_assert (!g_value_type_transformable (G_TYPE_STRING, G_TYPE_CHAR));
 387   g_value_init (&src, G_TYPE_STRING);
 388   g_value_init (&dest, G_TYPE_CHAR);
 389   g_value_set_static_string (&src, "bla");
 390   g_value_set_schar (&dest, 'c');
 391   g_assert (!g_value_transform (&src, &dest));
 392   g_assert_cmpint (g_value_get_schar (&dest), ==, 'c');
 393   g_value_unset (&src);
 394   g_value_unset (&dest);
 395 }
 396
 397 int
 398 main (int argc, char *argv[])
 399 {
 400   g_type_init ();
 401   g_test_init (&argc, &argv, NULL);
 402
 403   g_test_add_func ("/param/value", test_param_value);
 404   g_test_add_func ("/param/strings", test_param_strings);
 405   g_test_add_func ("/param/qdata", test_param_qdata);
 406   g_test_add_func ("/param/validate", test_param_validate);
 407   g_test_add_func ("/param/convert", test_param_convert);
 408   g_test_add_func ("/value/transform", test_value_transform);
 409
 410   return g_test_run ();
 411 }