tests/check/gst/gstvalue.c

   1 /* GStreamer
   2  * Copyright (C) <2004> David Schleef <david at schleef dot org>
   3  * Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
   4  *
   5  * gstvalue.c: Unit tests for GstValue
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23
  24 #include <gst/check/gstcheck.h>
  25
  26
  27 GST_START_TEST (test_deserialize_buffer)
  28 {
  29   GValue value = { 0 };
  30   GstBuffer *buf;
  31
  32   g_value_init (&value, GST_TYPE_BUFFER);
  33   fail_unless (gst_value_deserialize (&value, "1234567890abcdef"));
  34   buf = GST_BUFFER (gst_value_get_mini_object (&value));
  35
  36   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
  37
  38   /* cleanup */
  39   gst_buffer_unref (buf);
  40 }
  41
  42 GST_END_TEST;
  43
  44 GST_START_TEST (test_deserialize_gint64)
  45 {
  46   GValue value = { 0 };
  47   const char *strings[] = {
  48     "12345678901",
  49     "-12345678901",
  50   };
  51   gint64 results[] = {
  52     12345678901LL,
  53     -12345678901LL,
  54   };
  55   int i;
  56
  57   g_value_init (&value, G_TYPE_INT64);
  58
  59   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
  60     fail_unless (gst_value_deserialize (&value, strings[i]),
  61         "could not deserialize %s (%d)", strings[i], i);
  62     fail_unless (g_value_get_int64 (&value) == results[i],
  63         "resulting value is %" G_GINT64_FORMAT ", not %" G_GINT64_FORMAT
  64         ", for string %s (%d)", value, results[i], strings[i], i);
  65   }
  66 }
  67
  68 GST_END_TEST;
  69
  70 GST_START_TEST (test_deserialize_gint)
  71 {
  72   GValue value = { 0 };
  73   const char *strings[] = {
  74     "123456",
  75     "-123456",
  76     "0xFFFF",
  77     "0x0000FFFF",
  78     /* a positive long long, serializing to highest possible positive sint */
  79     "0x7FFFFFFF",
  80     /* a positive long long, serializing to lowest possible negative sint */
  81     "0x80000000",
  82     /* a negative long long, serializing to lowest possible negative sint */
  83     "0xFFFFFFFF80000000",
  84     "0xFF000000",
  85     /* a positive long long serializing to -1 */
  86     "0xFFFFFFFF",
  87     "0xFFFFFFFF",
  88     /* a negative long long serializing to -1 */
  89     "0xFFFFFFFFFFFFFFFF",
  90     "0xFFFFFFFFFFFFFFFF",
  91     "0xEFFFFFFF",
  92   };
  93   gint results[] = {
  94     123456,
  95     -123456,
  96     0xFFFF,
  97     0xFFFF,
  98     0x7FFFFFFF,
  99     0x80000000,
 100     0x80000000,
 101     0xFF000000,
 102     -1,
 103     0xFFFFFFFF,
 104     -1,
 105     /* cast needs to be explicit because of unsigned -> signed */
 106     (gint) 0xFFFFFFFFFFFFFFFFLL,
 107     0xEFFFFFFF,
 108   };
 109   int i;
 110
 111   g_value_init (&value, G_TYPE_INT);
 112
 113   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 114     fail_unless (gst_value_deserialize (&value, strings[i]),
 115         "could not deserialize %s (%d)", strings[i], i);
 116     fail_unless (g_value_get_int (&value) == results[i],
 117         "resulting value is %d, not %d, for string %s (%d)",
 118         g_value_get_int (&value), results[i], strings[i], i);
 119   }
 120 }
 121
 122 GST_END_TEST;
 123
 124 GST_START_TEST (test_deserialize_gint_failures)
 125 {
 126   GValue value = { 0 };
 127   const char *strings[] = {
 128     "-",                        /* not a complete number */
 129     "- TEST",                   /* not a complete number */
 130     "0x0000000100000000",       /* lowest long long that cannot fit in 32 bits */
 131     "0xF000000000000000",
 132     "0xFFFFFFF000000000",
 133     "0xFFFFFFFF00000000",
 134     "0x10000000000000000",      /* first number too long to fit into a long long */
 135     /* invent a new processor first before trying to make this one pass */
 136     "0x10000000000000000000000000000000000000000000",
 137   };
 138   int i;
 139
 140   g_value_init (&value, G_TYPE_INT);
 141
 142   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 143     fail_if (gst_value_deserialize (&value, strings[i]),
 144         "deserialized %s (%d), while it should have failed", strings[i], i);
 145   }
 146 }
 147
 148 GST_END_TEST;
 149
 150 GST_START_TEST (test_deserialize_guint)
 151 {
 152   GValue value = { 0 };
 153   const char *strings[] = {
 154     "123456",
 155     "-123456",
 156     "0xFFFF",
 157     "0x0000FFFF",
 158     /* a positive long long, serializing to highest possible positive sint */
 159     "0x7FFFFFFF",
 160     /* a positive long long, serializing to lowest possible negative sint */
 161     "0x80000000",
 162     "2147483648",
 163     /* a negative long long, serializing to lowest possible negative sint */
 164     "0xFFFFFFFF80000000",
 165     /* a value typically used for rgb masks */
 166     "0xFF000000",
 167     /* a positive long long serializing to highest possible positive uint */
 168     "0xFFFFFFFF",
 169     "0xFFFFFFFF",
 170     /* a negative long long serializing to highest possible positive uint */
 171     "0xFFFFFFFFFFFFFFFF",
 172     "0xEFFFFFFF",
 173   };
 174   guint results[] = {
 175     123456,
 176     -123456,
 177     0xFFFF,
 178     0xFFFF,
 179     0x7FFFFFFF,
 180     0x80000000,
 181     (guint) 2147483648LL,
 182     0x80000000,
 183     0xFF000000,
 184     0xFFFFFFFF,
 185     G_MAXUINT,
 186     (guint) 0xFFFFFFFFFFFFFFFFLL,
 187     0xEFFFFFFF,
 188   };
 189   int i;
 190
 191   g_value_init (&value, G_TYPE_UINT);
 192
 193   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 194     fail_unless (gst_value_deserialize (&value, strings[i]),
 195         "could not deserialize %s (%d)", strings[i], i);
 196     fail_unless (g_value_get_uint (&value) == results[i],
 197         "resulting value is %d, not %d, for string %s (%d)",
 198         g_value_get_uint (&value), results[i], strings[i], i);
 199   }
 200 }
 201
 202 GST_END_TEST;
 203
 204 GST_START_TEST (test_deserialize_guint_failures)
 205 {
 206   GValue value = { 0 };
 207   const char *strings[] = {
 208     "-",                        /* not a complete number */
 209     "- TEST",                   /* not a complete number */
 210 #if 0
 211 /* FIXME: these values should not be deserializable, since they overflow
 212  * the target format */
 213     "0x0000000100000000",       /* lowest long long that cannot fit in 32 bits */
 214     "0xF000000000000000",
 215     "0xFFFFFFF000000000",
 216     "0xFFFFFFFF00000000",
 217     "0x10000000000000000",      /* first number too long to fit into a long long */
 218     /* invent a new processor first before trying to make this one pass */
 219     "0x10000000000000000000000000000000000000000000",
 220 #endif
 221   };
 222   int i;
 223
 224   g_value_init (&value, G_TYPE_UINT);
 225
 226   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 227     fail_if (gst_value_deserialize (&value, strings[i]),
 228         "deserialized %s (%d), while it should have failed", strings[i], i);
 229   }
 230 }
 231
 232 GST_END_TEST;
 233
 234
 235 GST_START_TEST (test_string)
 236 {
 237   gchar *try[] = {
 238     "Dude",
 239     "Hi, I'm a string",
 240     "tüüüt!"
 241   };
 242   gchar *tmp;
 243   GValue v = { 0, };
 244   guint i;
 245
 246   g_value_init (&v, G_TYPE_STRING);
 247   for (i = 0; i < G_N_ELEMENTS (try); i++) {
 248     g_value_set_string (&v, try[i]);
 249     tmp = gst_value_serialize (&v);
 250     fail_if (tmp == NULL, "couldn't serialize: %s\n", try[i]);
 251     fail_unless (gst_value_deserialize (&v, tmp),
 252         "couldn't deserialize: %s\n", tmp);
 253     g_free (tmp);
 254
 255     fail_unless (g_str_equal (g_value_get_string (&v), try[i]),
 256         "\nserialized  : %s\ndeserialized: %s", try[i],
 257         g_value_get_string (&v));
 258   }
 259   g_value_unset (&v);
 260 }
 261
 262 GST_END_TEST;
 263
 264 GST_START_TEST (test_deserialize_string)
 265 {
 266   struct
 267   {
 268     gchar *from;
 269     gchar *to;
 270   } tests[] = {
 271     {
 272     "", ""},                    /* empty strings */
 273     {
 274     "\"\"", ""},                /* FAILURES */
 275     {
 276     "\"", NULL},                /* missing second quote */
 277     {
 278     "\"Hello\\ World", NULL},   /* missing second quote */
 279     {
 280     "\"\\", NULL},              /* quote at end, missing second quote */
 281     {
 282     "\"\\0", NULL},             /* missing second quote */
 283     {
 284     "\"\\0\"", NULL},           /* unfinished escaped character */
 285     {
 286     "\" \"", NULL},             /* spaces must be escaped */
 287 #if 0
 288         /* FIXME 0.9: this test should fail, but it doesn't */
 289     {
 290     "tüüt", NULL}             /* string with special chars must be escaped */
 291 #endif
 292   };
 293   guint i;
 294   GValue v = { 0, };
 295   gboolean ret = TRUE;
 296
 297   g_value_init (&v, G_TYPE_STRING);
 298   for (i = 0; i < G_N_ELEMENTS (tests); i++) {
 299     if (gst_value_deserialize (&v, tests[i].from)) {
 300       fail_if (tests[i].to == NULL,
 301           "I got %s instead of a failure", g_value_get_string (&v));
 302       fail_unless (g_str_equal (g_value_get_string (&v), tests[i].to),
 303           "\nwanted: %s\ngot    : %s", tests[i].to, g_value_get_string (&v));
 304     } else {
 305       fail_if (tests[i].to != NULL, "failed, but wanted: %s", tests[i].to);
 306       ret = FALSE;
 307     }
 308   }
 309   g_value_unset (&v);
 310 }
 311
 312 GST_END_TEST;
 313
 314 GST_START_TEST (test_value_compare)
 315 {
 316   GValue value1 = { 0 };
 317   GValue value2 = { 0 };
 318
 319   g_value_init (&value1, G_TYPE_INT);
 320   g_value_set_int (&value1, 10);
 321   g_value_init (&value2, G_TYPE_INT);
 322   g_value_set_int (&value2, 20);
 323   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 324   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 325   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 326   g_value_unset (&value1);
 327   g_value_unset (&value2);
 328
 329   g_value_init (&value1, G_TYPE_DOUBLE);
 330   g_value_set_double (&value1, 10);
 331   g_value_init (&value2, G_TYPE_DOUBLE);
 332   g_value_set_double (&value2, 20);
 333   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 334   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 335   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 336   g_value_unset (&value1);
 337   g_value_unset (&value2);
 338
 339   g_value_init (&value1, G_TYPE_STRING);
 340   g_value_set_string (&value1, "a");
 341   g_value_init (&value2, G_TYPE_STRING);
 342   g_value_set_string (&value2, "b");
 343   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 344   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 345   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 346   g_value_unset (&value1);
 347   g_value_unset (&value2);
 348
 349   g_value_init (&value1, GST_TYPE_FOURCC);
 350   gst_value_set_fourcc (&value1, GST_MAKE_FOURCC ('a', 'b', 'c', 'd'));
 351   g_value_init (&value2, GST_TYPE_FOURCC);
 352   gst_value_set_fourcc (&value2, GST_MAKE_FOURCC ('1', '2', '3', '4'));
 353   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
 354   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 355   g_value_unset (&value1);
 356   g_value_unset (&value2);
 357
 358   /* comparing 2/3 with 3/4 */
 359   g_value_init (&value1, GST_TYPE_FRACTION);
 360   gst_value_set_fraction (&value1, 2, 3);
 361   g_value_init (&value2, GST_TYPE_FRACTION);
 362   gst_value_set_fraction (&value2, 3, 4);
 363   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 364   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 365   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 366   g_value_unset (&value1);
 367   g_value_unset (&value2);
 368
 369   /* comparing -4/5 with 2/-3 */
 370   g_value_init (&value1, GST_TYPE_FRACTION);
 371   gst_value_set_fraction (&value1, -4, 5);
 372   g_value_init (&value2, GST_TYPE_FRACTION);
 373   gst_value_set_fraction (&value2, 2, -3);
 374   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 375   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 376   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 377   g_value_unset (&value1);
 378   g_value_unset (&value2);
 379
 380   /* comparing 10/100 with 200/2000 */
 381   g_value_init (&value1, GST_TYPE_FRACTION);
 382   gst_value_set_fraction (&value1, 10, 100);
 383   g_value_init (&value2, GST_TYPE_FRACTION);
 384   gst_value_set_fraction (&value2, 200, 2000);
 385   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL);
 386   g_value_unset (&value1);
 387   g_value_unset (&value2);
 388
 389   /* comparing -4/5 with 2/-3 */
 390   g_value_init (&value1, GST_TYPE_FRACTION);
 391   gst_value_set_fraction (&value1, -4, 5);
 392   g_value_init (&value2, GST_TYPE_FRACTION);
 393   gst_value_set_fraction (&value2, 2, -3);
 394   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 395   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 396   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 397   g_value_unset (&value1);
 398   g_value_unset (&value2);
 399 }
 400
 401 GST_END_TEST;
 402
 403 GST_START_TEST (test_value_intersect)
 404 {
 405   GValue dest = { 0 };
 406   GValue src1 = { 0 };
 407   GValue src2 = { 0 };
 408   GValue item = { 0 };
 409   gboolean ret;
 410
 411   g_value_init (&src1, G_TYPE_INT);
 412   g_value_set_int (&src1, 10);
 413   g_value_init (&src2, G_TYPE_INT);
 414   g_value_set_int (&src2, 20);
 415   ret = gst_value_intersect (&dest, &src1, &src2);
 416   fail_unless (ret == FALSE);
 417   g_value_unset (&src1);
 418   g_value_unset (&src2);
 419
 420   g_value_init (&src1, GST_TYPE_FOURCC);
 421   gst_value_set_fourcc (&src1, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 422   g_value_init (&src2, GST_TYPE_LIST);
 423   g_value_init (&item, GST_TYPE_FOURCC);
 424   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 425   gst_value_list_append_value (&src2, &item);
 426   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('I', '4', '2', '0'));
 427   gst_value_list_append_value (&src2, &item);
 428   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('A', 'B', 'C', 'D'));
 429   gst_value_list_append_value (&src2, &item);
 430
 431   fail_unless (gst_value_intersect (&dest, &src1, &src2));
 432   fail_unless (GST_VALUE_HOLDS_FOURCC (&dest));
 433   fail_unless (gst_value_get_fourcc (&dest) ==
 434       GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 435 }
 436
 437 GST_END_TEST;
 438
 439
 440 GST_START_TEST (test_value_subtract_int)
 441 {
 442   GValue dest = { 0 };
 443   GValue src1 = { 0 };
 444   GValue src2 = { 0 };
 445   const GValue *tmp;
 446   gboolean ret;
 447
 448   /*  int <-> int
 449    */
 450   g_value_init (&src1, G_TYPE_INT);
 451   g_value_set_int (&src1, 10);
 452   g_value_init (&src2, G_TYPE_INT);
 453   g_value_set_int (&src2, 20);
 454   /* subtract as in sets, result is 10 */
 455   ret = gst_value_subtract (&dest, &src1, &src2);
 456   fail_unless (ret == TRUE);
 457   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 458   g_value_unset (&dest);
 459
 460   /* same values, yields empty set */
 461   ret = gst_value_subtract (&dest, &src1, &src1);
 462   fail_unless (ret == FALSE);
 463   g_value_unset (&src1);
 464   g_value_unset (&src2);
 465
 466   /*  int <-> int_range
 467    */
 468
 469   /* would yield an empty set */
 470   g_value_init (&src1, G_TYPE_INT);
 471   g_value_set_int (&src1, 10);
 472   g_value_init (&src2, GST_TYPE_INT_RANGE);
 473   gst_value_set_int_range (&src2, 0, 20);
 474   ret = gst_value_subtract (&dest, &src1, &src2);
 475   fail_unless (ret == FALSE);
 476
 477   /* and the other way around, should create a list of two ranges. */
 478   ret = gst_value_subtract (&dest, &src2, &src1);
 479   fail_unless (ret == TRUE);
 480   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 481   tmp = gst_value_list_get_value (&dest, 0);
 482   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 483   fail_unless (gst_value_get_int_range_min (tmp) == 0);
 484   fail_unless (gst_value_get_int_range_max (tmp) == 9);
 485   tmp = gst_value_list_get_value (&dest, 1);
 486   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 487   fail_unless (gst_value_get_int_range_min (tmp) == 11);
 488   fail_unless (gst_value_get_int_range_max (tmp) == 20);
 489   g_value_unset (&dest);
 490   g_value_unset (&src1);
 491   g_value_unset (&src2);
 492
 493   /* border case 1, empty set */
 494   g_value_init (&src1, G_TYPE_INT);
 495   g_value_set_int (&src1, 10);
 496   g_value_init (&src2, GST_TYPE_INT_RANGE);
 497   gst_value_set_int_range (&src2, 10, 20);
 498   ret = gst_value_subtract (&dest, &src1, &src2);
 499   fail_unless (ret == FALSE);
 500
 501   /* and the other way around, should create a new range. */
 502   ret = gst_value_subtract (&dest, &src2, &src1);
 503   fail_unless (ret == TRUE);
 504   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 505   fail_unless (gst_value_get_int_range_min (&dest) == 11);
 506   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 507   g_value_unset (&dest);
 508   g_value_unset (&src1);
 509   g_value_unset (&src2);
 510
 511   /* border case 2, empty set */
 512   g_value_init (&src1, G_TYPE_INT);
 513   g_value_set_int (&src1, 20);
 514   g_value_init (&src2, GST_TYPE_INT_RANGE);
 515   gst_value_set_int_range (&src2, 10, 20);
 516   ret = gst_value_subtract (&dest, &src1, &src2);
 517   fail_unless (ret == FALSE);
 518
 519   /* and the other way around, should create a new range. */
 520   ret = gst_value_subtract (&dest, &src2, &src1);
 521   fail_unless (ret == TRUE);
 522   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 523   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 524   fail_unless (gst_value_get_int_range_max (&dest) == 19);
 525   g_value_unset (&dest);
 526   g_value_unset (&src1);
 527   g_value_unset (&src2);
 528
 529   /* case 3, valid set */
 530   g_value_init (&src1, G_TYPE_INT);
 531   g_value_set_int (&src1, 0);
 532   g_value_init (&src2, GST_TYPE_INT_RANGE);
 533   gst_value_set_int_range (&src2, 10, 20);
 534   ret = gst_value_subtract (&dest, &src1, &src2);
 535   fail_unless (ret == TRUE);
 536   fail_unless (G_VALUE_HOLDS_INT (&dest) == TRUE);
 537   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 538   g_value_unset (&dest);
 539
 540   /* and the other way around, should keep the range. */
 541   ret = gst_value_subtract (&dest, &src2, &src1);
 542   fail_unless (ret == TRUE);
 543   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 544   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 545   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 546   g_value_unset (&dest);
 547   g_value_unset (&src1);
 548   g_value_unset (&src2);
 549
 550   /*  int_range <-> int_range
 551    */
 552
 553   /* same range, empty set */
 554   g_value_init (&src1, GST_TYPE_INT_RANGE);
 555   gst_value_set_int_range (&src1, 10, 20);
 556   g_value_init (&src2, GST_TYPE_INT_RANGE);
 557   gst_value_set_int_range (&src2, 10, 20);
 558   ret = gst_value_subtract (&dest, &src1, &src2);
 559   fail_unless (ret == FALSE);
 560   ret = gst_value_subtract (&dest, &src2, &src1);
 561   fail_unless (ret == FALSE);
 562   g_value_unset (&src1);
 563   g_value_unset (&src2);
 564
 565   /* non overlapping ranges */
 566   g_value_init (&src1, GST_TYPE_INT_RANGE);
 567   gst_value_set_int_range (&src1, 10, 20);
 568   g_value_init (&src2, GST_TYPE_INT_RANGE);
 569   gst_value_set_int_range (&src2, 30, 40);
 570   ret = gst_value_subtract (&dest, &src1, &src2);
 571   fail_unless (ret == TRUE);
 572   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 573   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 574   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 575   g_value_unset (&dest);
 576   /* the other way */
 577   ret = gst_value_subtract (&dest, &src2, &src1);
 578   fail_unless (ret == TRUE);
 579   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 580   fail_unless (gst_value_get_int_range_min (&dest) == 30);
 581   fail_unless (gst_value_get_int_range_max (&dest) == 40);
 582   g_value_unset (&dest);
 583   g_value_unset (&src1);
 584   g_value_unset (&src2);
 585
 586   /* completely overlapping ranges */
 587   g_value_init (&src1, GST_TYPE_INT_RANGE);
 588   gst_value_set_int_range (&src1, 10, 20);
 589   g_value_init (&src2, GST_TYPE_INT_RANGE);
 590   gst_value_set_int_range (&src2, 10, 30);
 591   ret = gst_value_subtract (&dest, &src1, &src2);
 592   fail_unless (ret == FALSE);
 593   /* the other way */
 594   ret = gst_value_subtract (&dest, &src2, &src1);
 595   fail_unless (ret == TRUE);
 596   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 597   fail_unless (gst_value_get_int_range_min (&dest) == 21);
 598   fail_unless (gst_value_get_int_range_max (&dest) == 30);
 599   g_value_unset (&dest);
 600   g_value_unset (&src1);
 601   g_value_unset (&src2);
 602
 603   /* partially overlapping ranges */
 604   g_value_init (&src1, GST_TYPE_INT_RANGE);
 605   gst_value_set_int_range (&src1, 10, 20);
 606   g_value_init (&src2, GST_TYPE_INT_RANGE);
 607   gst_value_set_int_range (&src2, 15, 30);
 608   ret = gst_value_subtract (&dest, &src1, &src2);
 609   fail_unless (ret == TRUE);
 610   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 611   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 612   fail_unless (gst_value_get_int_range_max (&dest) == 14);
 613   g_value_unset (&dest);
 614   /* the other way */
 615   ret = gst_value_subtract (&dest, &src2, &src1);
 616   fail_unless (ret == TRUE);
 617   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 618   fail_unless (gst_value_get_int_range_min (&dest) == 21);
 619   fail_unless (gst_value_get_int_range_max (&dest) == 30);
 620   g_value_unset (&dest);
 621   g_value_unset (&src1);
 622   g_value_unset (&src2);
 623
 624   /* create a hole { int_range, int_range } */
 625   g_value_init (&src1, GST_TYPE_INT_RANGE);
 626   gst_value_set_int_range (&src1, 10, 30);
 627   g_value_init (&src2, GST_TYPE_INT_RANGE);
 628   gst_value_set_int_range (&src2, 15, 20);
 629   ret = gst_value_subtract (&dest, &src1, &src2);
 630   fail_unless (ret == TRUE);
 631   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 632   tmp = gst_value_list_get_value (&dest, 0);
 633   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 634   fail_unless (gst_value_get_int_range_min (tmp) == 10);
 635   fail_unless (gst_value_get_int_range_max (tmp) == 14);
 636   tmp = gst_value_list_get_value (&dest, 1);
 637   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 638   fail_unless (gst_value_get_int_range_min (tmp) == 21);
 639   fail_unless (gst_value_get_int_range_max (tmp) == 30);
 640   g_value_unset (&dest);
 641   /* the other way */
 642   ret = gst_value_subtract (&dest, &src2, &src1);
 643   fail_unless (ret == FALSE);
 644   g_value_unset (&src1);
 645   g_value_unset (&src2);
 646
 647   /* create a hole, { int, int } */
 648   g_value_init (&src1, GST_TYPE_INT_RANGE);
 649   gst_value_set_int_range (&src1, 10, 30);
 650   g_value_init (&src2, GST_TYPE_INT_RANGE);
 651   gst_value_set_int_range (&src2, 11, 29);
 652   ret = gst_value_subtract (&dest, &src1, &src2);
 653   fail_unless (ret == TRUE);
 654   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 655   tmp = gst_value_list_get_value (&dest, 0);
 656   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
 657   fail_unless (g_value_get_int (tmp) == 10);
 658   tmp = gst_value_list_get_value (&dest, 1);
 659   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
 660   fail_unless (g_value_get_int (tmp) == 30);
 661   g_value_unset (&dest);
 662   /* the other way */
 663   ret = gst_value_subtract (&dest, &src2, &src1);
 664   fail_unless (ret == FALSE);
 665   g_value_unset (&src1);
 666   g_value_unset (&src2);
 667
 668   /* create a hole, { int, int_range } */
 669   g_value_init (&src1, GST_TYPE_INT_RANGE);
 670   gst_value_set_int_range (&src1, 10, 30);
 671   g_value_init (&src2, GST_TYPE_INT_RANGE);
 672   gst_value_set_int_range (&src2, 11, 28);
 673   ret = gst_value_subtract (&dest, &src1, &src2);
 674   fail_unless (ret == TRUE);
 675   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 676   tmp = gst_value_list_get_value (&dest, 0);
 677   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
 678   fail_unless (g_value_get_int (tmp) == 10);
 679   tmp = gst_value_list_get_value (&dest, 1);
 680   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 681   fail_unless (gst_value_get_int_range_min (tmp) == 29);
 682   fail_unless (gst_value_get_int_range_max (tmp) == 30);
 683   g_value_unset (&dest);
 684   /* the other way */
 685   ret = gst_value_subtract (&dest, &src2, &src1);
 686   fail_unless (ret == FALSE);
 687   g_value_unset (&src1);
 688   g_value_unset (&src2);
 689
 690   /* create a hole, { int_range, int } */
 691   g_value_init (&src1, GST_TYPE_INT_RANGE);
 692   gst_value_set_int_range (&src1, 10, 30);
 693   g_value_init (&src2, GST_TYPE_INT_RANGE);
 694   gst_value_set_int_range (&src2, 12, 29);
 695   ret = gst_value_subtract (&dest, &src1, &src2);
 696   fail_unless (ret == TRUE);
 697   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 698   tmp = gst_value_list_get_value (&dest, 0);
 699   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 700   fail_unless (gst_value_get_int_range_min (tmp) == 10);
 701   fail_unless (gst_value_get_int_range_max (tmp) == 11);
 702   tmp = gst_value_list_get_value (&dest, 1);
 703   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
 704   fail_unless (g_value_get_int (tmp) == 30);
 705   g_value_unset (&dest);
 706   /* the other way */
 707   ret = gst_value_subtract (&dest, &src2, &src1);
 708   fail_unless (ret == FALSE);
 709   g_value_unset (&src1);
 710   g_value_unset (&src2);
 711 }
 712
 713 GST_END_TEST;
 714
 715 GST_START_TEST (test_value_subtract_double)
 716 {
 717   GValue dest = { 0 };
 718   GValue src1 = { 0 };
 719   GValue src2 = { 0 };
 720   const GValue *tmp;
 721   gboolean ret;
 722
 723   /*  double <-> double
 724    */
 725   g_value_init (&src1, G_TYPE_DOUBLE);
 726   g_value_set_double (&src1, 10.0);
 727   g_value_init (&src2, G_TYPE_DOUBLE);
 728   g_value_set_double (&src2, 20.0);
 729   /* subtract as in sets, result is 10 */
 730   ret = gst_value_subtract (&dest, &src1, &src2);
 731   fail_unless (ret == TRUE);
 732   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 733   g_value_unset (&dest);
 734
 735   /* same values, yields empty set */
 736   ret = gst_value_subtract (&dest, &src1, &src1);
 737   fail_unless (ret == FALSE);
 738   g_value_unset (&src1);
 739   g_value_unset (&src2);
 740
 741   /*  double <-> double_range
 742    */
 743
 744   /* would yield an empty set */
 745   g_value_init (&src1, G_TYPE_DOUBLE);
 746   g_value_set_double (&src1, 10.0);
 747   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 748   gst_value_set_double_range (&src2, 0.0, 20.0);
 749   ret = gst_value_subtract (&dest, &src1, &src2);
 750   fail_unless (ret == FALSE);
 751
 752   /* and the other way around, we cannot create open ranges
 753    * so the result is the range again */
 754   ret = gst_value_subtract (&dest, &src2, &src1);
 755   fail_unless (ret == TRUE);
 756   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 757   fail_unless (gst_value_get_double_range_min (&dest) == 0.0);
 758   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
 759   g_value_unset (&dest);
 760   g_value_unset (&src1);
 761   g_value_unset (&src2);
 762
 763   /* border case 1, empty set */
 764   g_value_init (&src1, G_TYPE_DOUBLE);
 765   g_value_set_double (&src1, 10.0);
 766   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 767   gst_value_set_double_range (&src2, 10.0, 20.0);
 768   ret = gst_value_subtract (&dest, &src1, &src2);
 769   fail_unless (ret == FALSE);
 770
 771   /* and the other way around, should keep same range as
 772    * we don't have open ranges. */
 773   ret = gst_value_subtract (&dest, &src2, &src1);
 774   fail_unless (ret == TRUE);
 775   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 776   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
 777   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
 778   g_value_unset (&dest);
 779   g_value_unset (&src1);
 780   g_value_unset (&src2);
 781
 782   /* border case 2, empty set */
 783   g_value_init (&src1, G_TYPE_DOUBLE);
 784   g_value_set_double (&src1, 20.0);
 785   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 786   gst_value_set_double_range (&src2, 10.0, 20.0);
 787   ret = gst_value_subtract (&dest, &src1, &src2);
 788   fail_unless (ret == FALSE);
 789
 790   /* and the other way around, should keep same range as
 791    * we don't have open ranges. */
 792   ret = gst_value_subtract (&dest, &src2, &src1);
 793   fail_unless (ret == TRUE);
 794   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 795   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
 796   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
 797   g_value_unset (&dest);
 798   g_value_unset (&src1);
 799   g_value_unset (&src2);
 800
 801   /* case 3, valid set */
 802   g_value_init (&src1, G_TYPE_DOUBLE);
 803   g_value_set_double (&src1, 0.0);
 804   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 805   gst_value_set_double_range (&src2, 10.0, 20.0);
 806   ret = gst_value_subtract (&dest, &src1, &src2);
 807   fail_unless (ret == TRUE);
 808   fail_unless (G_VALUE_HOLDS_DOUBLE (&dest) == TRUE);
 809   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 810   g_value_unset (&dest);
 811
 812   /* and the other way around, should keep the range. */
 813   ret = gst_value_subtract (&dest, &src2, &src1);
 814   fail_unless (ret == TRUE);
 815   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 816   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
 817   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
 818   g_value_unset (&dest);
 819   g_value_unset (&src1);
 820   g_value_unset (&src2);
 821
 822   /*  double_range <-> double_range
 823    */
 824
 825   /* same range, empty set */
 826   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
 827   gst_value_set_double_range (&src1, 10.0, 20.0);
 828   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 829   gst_value_set_double_range (&src2, 10.0, 20.0);
 830   ret = gst_value_subtract (&dest, &src1, &src2);
 831   fail_unless (ret == FALSE);
 832   ret = gst_value_subtract (&dest, &src2, &src1);
 833   fail_unless (ret == FALSE);
 834   g_value_unset (&src1);
 835   g_value_unset (&src2);
 836
 837   /* non overlapping ranges */
 838   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
 839   gst_value_set_double_range (&src1, 10.0, 20.0);
 840   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 841   gst_value_set_double_range (&src2, 30.0, 40.0);
 842   ret = gst_value_subtract (&dest, &src1, &src2);
 843   fail_unless (ret == TRUE);
 844   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 845   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
 846   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
 847   g_value_unset (&dest);
 848   /* the other way */
 849   ret = gst_value_subtract (&dest, &src2, &src1);
 850   fail_unless (ret == TRUE);
 851   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 852   fail_unless (gst_value_get_double_range_min (&dest) == 30.0);
 853   fail_unless (gst_value_get_double_range_max (&dest) == 40.0);
 854   g_value_unset (&dest);
 855   g_value_unset (&src1);
 856   g_value_unset (&src2);
 857
 858   /* completely overlapping ranges */
 859   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
 860   gst_value_set_double_range (&src1, 10.0, 20.0);
 861   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 862   gst_value_set_double_range (&src2, 10.0, 30.0);
 863   ret = gst_value_subtract (&dest, &src1, &src2);
 864   fail_unless (ret == FALSE);
 865   /* the other way */
 866   ret = gst_value_subtract (&dest, &src2, &src1);
 867   fail_unless (ret == TRUE);
 868   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 869   fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
 870   fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
 871   g_value_unset (&dest);
 872   g_value_unset (&src1);
 873   g_value_unset (&src2);
 874
 875   /* partially overlapping ranges */
 876   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
 877   gst_value_set_double_range (&src1, 10.0, 20.0);
 878   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 879   gst_value_set_double_range (&src2, 15.0, 30.0);
 880   ret = gst_value_subtract (&dest, &src1, &src2);
 881   fail_unless (ret == TRUE);
 882   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 883   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
 884   fail_unless (gst_value_get_double_range_max (&dest) == 15.0);
 885   g_value_unset (&dest);
 886   /* the other way */
 887   ret = gst_value_subtract (&dest, &src2, &src1);
 888   fail_unless (ret == TRUE);
 889   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 890   fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
 891   fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
 892   g_value_unset (&dest);
 893   g_value_unset (&src1);
 894   g_value_unset (&src2);
 895
 896   /* create a hole { double_range, double_range } */
 897   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
 898   gst_value_set_double_range (&src1, 10.0, 30.0);
 899   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 900   gst_value_set_double_range (&src2, 15.0, 20.0);
 901   ret = gst_value_subtract (&dest, &src1, &src2);
 902   fail_unless (ret == TRUE);
 903   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 904   tmp = gst_value_list_get_value (&dest, 0);
 905   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
 906   fail_unless (gst_value_get_double_range_min (tmp) == 10.0);
 907   fail_unless (gst_value_get_double_range_max (tmp) == 15.0);
 908   tmp = gst_value_list_get_value (&dest, 1);
 909   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
 910   fail_unless (gst_value_get_double_range_min (tmp) == 20.0);
 911   fail_unless (gst_value_get_double_range_max (tmp) == 30.0);
 912   g_value_unset (&dest);
 913   /* the other way */
 914   ret = gst_value_subtract (&dest, &src2, &src1);
 915   fail_unless (ret == FALSE);
 916   g_value_unset (&src1);
 917   g_value_unset (&src2);
 918 }
 919
 920 GST_END_TEST;
 921
 922 GST_START_TEST (test_date)
 923 {
 924   GstStructure *s;
 925   GDate *date, *date2;
 926   gchar *str;
 927
 928   date = g_date_new_dmy (22, 9, 2005);
 929
 930   s = gst_structure_new ("media/x-type", "SOME_DATE_TAG", GST_TYPE_DATE,
 931       date, NULL);
 932
 933   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
 934           GST_TYPE_DATE));
 935   fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date2));
 936   fail_unless (date2 != NULL);
 937   fail_unless (g_date_valid (date2));
 938   fail_unless (g_date_compare (date, date2) == 0);
 939
 940   g_date_free (date);
 941   g_date_free (date2);
 942   date = NULL;
 943   date2 = NULL;
 944
 945   str = gst_structure_to_string (s);
 946   gst_structure_free (s);
 947   s = NULL;
 948
 949   fail_unless (g_str_equal (str,
 950           "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22"));
 951
 952   s = gst_structure_from_string (str, NULL);
 953   g_free (str);
 954   str = NULL;
 955
 956   fail_unless (s != NULL);
 957   fail_unless (gst_structure_has_name (s, "media/x-type"));
 958   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
 959           GST_TYPE_DATE));
 960   fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date));
 961   fail_unless (date != NULL);
 962   fail_unless (g_date_valid (date));
 963   fail_unless (g_date_get_day (date) == 22);
 964   fail_unless (g_date_get_month (date) == 9);
 965   fail_unless (g_date_get_year (date) == 2005);
 966   g_date_free (date);
 967   date = NULL;
 968
 969   str = gst_structure_to_string (s);
 970   gst_structure_free (s);
 971   s = NULL;
 972
 973   fail_unless (g_str_equal (str,
 974           "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22"));
 975   g_free (str);
 976   str = NULL;
 977 }
 978
 979 GST_END_TEST;
 980
 981 Suite *
 982 gst_value_suite (void)
 983 {
 984   Suite *s = suite_create ("GstValue");
 985   TCase *tc_chain = tcase_create ("general");
 986
 987   suite_add_tcase (s, tc_chain);
 988   tcase_add_test (tc_chain, test_deserialize_buffer);
 989   tcase_add_test (tc_chain, test_deserialize_gint);
 990   tcase_add_test (tc_chain, test_deserialize_gint_failures);
 991   tcase_add_test (tc_chain, test_deserialize_guint);
 992   tcase_add_test (tc_chain, test_deserialize_guint_failures);
 993   tcase_add_test (tc_chain, test_deserialize_gint64);
 994   tcase_add_test (tc_chain, test_string);
 995   tcase_add_test (tc_chain, test_deserialize_string);
 996   tcase_add_test (tc_chain, test_value_compare);
 997   tcase_add_test (tc_chain, test_value_intersect);
 998   tcase_add_test (tc_chain, test_value_subtract_int);
 999   tcase_add_test (tc_chain, test_value_subtract_double);
1000   tcase_add_test (tc_chain, test_date);
1001
1002   return s;
1003 }
1004
1005 int
1006 main (int argc, char **argv)
1007 {
1008   int nf;
1009
1010   Suite *s = gst_value_suite ();
1011   SRunner *sr = srunner_create (s);
1012
1013   gst_check_init (&argc, &argv);
1014
1015   srunner_run_all (sr, CK_NORMAL);
1016   nf = srunner_ntests_failed (sr);
1017   srunner_free (sr);
1018
1019   return nf;
1020 }