gobject/tests/param.c

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