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_serialize_fourcc)
  28 {
  29   int i;
  30
  31   guint32 fourccs[] = {
  32     GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'),
  33     GST_MAKE_FOURCC ('Y', '8', '0', '0'),
  34     GST_MAKE_FOURCC ('Y', '8', ' ', ' '),
  35     GST_MAKE_FOURCC ('Y', '1', '6', ' '),
  36     GST_MAKE_FOURCC ('Y', 'U', 'Y', '_'),
  37     GST_MAKE_FOURCC ('Y', 'U', 'Y', '#'),
  38   };
  39   gint fourccs_size = sizeof (fourccs) / sizeof (fourccs[0]);
  40   const gchar *fourcc_strings[] = {
  41     "YUY2",
  42     "Y800",
  43     "Y8  ",
  44     "Y16 ",
  45     "0x5f595559",               /* Ascii values of YUY_ */
  46     "0x23595559",               /* Ascii values of YUY# */
  47   };
  48   gint fourcc_strings_size =
  49       sizeof (fourcc_strings) / sizeof (fourcc_strings[0]);
  50
  51   fail_unless (fourccs_size == fourcc_strings_size);
  52
  53   for (i = 0; i < fourccs_size; ++i) {
  54     gchar *str;
  55     GValue value = { 0 };
  56     g_value_init (&value, GST_TYPE_FOURCC);
  57
  58     gst_value_set_fourcc (&value, fourccs[i]);
  59     str = gst_value_serialize (&value);
  60
  61     fail_unless (strcmp (str, fourcc_strings[i]) == 0);
  62
  63     g_free (str);
  64   }
  65 }
  66
  67 GST_END_TEST;
  68
  69 GST_START_TEST (test_deserialize_fourcc)
  70 {
  71   int i;
  72
  73   guint32 fourccs[] = {
  74     GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'),
  75     GST_MAKE_FOURCC ('Y', '8', '0', '0'),
  76     GST_MAKE_FOURCC ('Y', '8', ' ', ' '),
  77     GST_MAKE_FOURCC ('Y', '8', ' ', ' '),
  78     GST_MAKE_FOURCC ('Y', '8', ' ', ' '),
  79     GST_MAKE_FOURCC ('Y', '1', '6', ' '),
  80     GST_MAKE_FOURCC ('Y', 'U', 'Y', '_'),
  81     GST_MAKE_FOURCC ('Y', 'U', 'Y', '#'),
  82   };
  83   gint fourccs_size = sizeof (fourccs) / sizeof (fourccs[0]);
  84   const gchar *fourcc_strings[] = {
  85     "YUY2",
  86     "Y800",
  87     "Y8  ",
  88     "Y8 ",
  89     "Y8",
  90     "Y16 ",
  91     "0x5f595559",               /* Ascii values of YUY_ */
  92     "0x23595559",               /* Ascii values of YUY# */
  93   };
  94   gint fourcc_strings_size =
  95       sizeof (fourcc_strings) / sizeof (fourcc_strings[0]);
  96
  97   fail_unless (fourccs_size == fourcc_strings_size);
  98
  99   for (i = 0; i < fourccs_size; ++i) {
 100     GValue value = { 0 };
 101
 102     g_value_init (&value, GST_TYPE_FOURCC);
 103
 104     fail_unless (gst_value_deserialize (&value, fourcc_strings[i]));
 105     fail_unless_equals_int (gst_value_get_fourcc (&value), fourccs[i]);
 106
 107     g_value_unset (&value);
 108   }
 109 }
 110
 111 GST_END_TEST;
 112
 113 GST_START_TEST (test_deserialize_buffer)
 114 {
 115   GValue value = { 0 };
 116   GstBuffer *buf;
 117
 118   g_value_init (&value, GST_TYPE_BUFFER);
 119   fail_unless (gst_value_deserialize (&value, "1234567890abcdef"));
 120   /* does not increase the refcount */
 121   buf = GST_BUFFER (gst_value_get_mini_object (&value));
 122   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
 123
 124   /* does not increase the refcount */
 125   buf = gst_value_get_buffer (&value);
 126   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
 127
 128   /* cleanup */
 129   g_value_unset (&value);
 130 }
 131
 132 GST_END_TEST;
 133
 134 /* create and serialize a buffer */
 135 GST_START_TEST (test_serialize_buffer)
 136 {
 137   GValue value = { 0 };
 138   GstBuffer *buf;
 139   gchar *serialized;
 140   static const char *buf_data = "1234567890abcdef";
 141   gint len;
 142
 143   len = strlen (buf_data);
 144   buf = gst_buffer_new_and_alloc (len);
 145   memcpy (GST_BUFFER_DATA (buf), buf_data, len);
 146   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
 147
 148   /* and assign buffer to mini object */
 149   g_value_init (&value, GST_TYPE_BUFFER);
 150   gst_value_take_buffer (&value, buf);
 151   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
 152
 153   /* now serialize it */
 154   serialized = gst_value_serialize (&value);
 155   GST_DEBUG ("serialized buffer to %s", serialized);
 156   fail_unless (serialized != NULL);
 157
 158   /* refcount should not change */
 159   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
 160
 161   /* cleanup */
 162   g_free (serialized);
 163   g_value_unset (&value);
 164
 165   /* take NULL buffer */
 166   g_value_init (&value, GST_TYPE_BUFFER);
 167   GST_DEBUG ("setting NULL buffer");
 168   gst_value_take_buffer (&value, NULL);
 169
 170   /* now serialize it */
 171   GST_DEBUG ("serializing NULL buffer");
 172   serialized = gst_value_serialize (&value);
 173   /* should return NULL */
 174   fail_unless (serialized == NULL);
 175
 176   g_free (serialized);
 177   g_value_unset (&value);
 178 }
 179
 180 GST_END_TEST;
 181
 182 GST_START_TEST (test_deserialize_gint64)
 183 {
 184   GValue value = { 0 };
 185   const char *strings[] = {
 186     "12345678901",
 187     "-12345678901",
 188     "1152921504606846976",
 189     "-1152921504606846976",
 190   };
 191   gint64 results[] = {
 192     12345678901LL,
 193     -12345678901LL,
 194     1152921504606846976LL,
 195     -1152921504606846976LL,
 196   };
 197   int i;
 198
 199   g_value_init (&value, G_TYPE_INT64);
 200
 201   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 202     fail_unless (gst_value_deserialize (&value, strings[i]),
 203         "could not deserialize %s (%d)", strings[i], i);
 204     fail_unless (g_value_get_int64 (&value) == results[i],
 205         "resulting value is %" G_GINT64_FORMAT ", not %" G_GINT64_FORMAT
 206         ", for string %s (%d)", g_value_get_int64 (&value),
 207         results[i], strings[i], i);
 208   }
 209 }
 210
 211 GST_END_TEST;
 212
 213 GST_START_TEST (test_deserialize_guint64)
 214 {
 215   GValue value = { 0 };
 216   const char *strings[] = {
 217     "0xffffffffffffffff",
 218     "9223372036854775810",
 219     "-9223372036854775810",
 220     "-1",
 221     "1",
 222     "-0",
 223   };
 224   guint64 results[] = {
 225     0xffffffffffffffffULL,
 226     9223372036854775810ULL,
 227     9223372036854775806ULL,
 228     (guint64) - 1,
 229     1,
 230     0,
 231   };
 232   int i;
 233
 234   g_value_init (&value, G_TYPE_UINT64);
 235
 236   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 237     fail_unless (gst_value_deserialize (&value, strings[i]),
 238         "could not deserialize %s (%d)", strings[i], i);
 239     fail_unless (g_value_get_uint64 (&value) == results[i],
 240         "resulting value is %" G_GUINT64_FORMAT ", not %" G_GUINT64_FORMAT
 241         ", for string %s (%d)", g_value_get_uint64 (&value),
 242         results[i], strings[i], i);
 243   }
 244 }
 245
 246 GST_END_TEST;
 247
 248 GST_START_TEST (test_deserialize_guchar)
 249 {
 250   GValue value = { 0 };
 251   const char *strings[] = {
 252     "0xff",
 253     "255",
 254     "-1",
 255     "1",
 256     "-0",
 257   };
 258   guchar results[] = {
 259     0xff,
 260     255,
 261     (guchar) - 1,
 262     1,
 263     0,
 264   };
 265   int i;
 266
 267   g_value_init (&value, G_TYPE_UCHAR);
 268
 269   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 270     fail_unless (gst_value_deserialize (&value, strings[i]),
 271         "could not deserialize %s (%d)", strings[i], i);
 272     fail_unless (g_value_get_uchar (&value) == results[i],
 273         "resulting value is %u not %u, for string %s (%d)",
 274         g_value_get_uchar (&value), results[i], strings[i], i);
 275   }
 276
 277   /* test serialisation as well while we're at it */
 278   {
 279     gchar *str;
 280     GValue value = { 0 };
 281     g_value_init (&value, G_TYPE_UCHAR);
 282
 283     g_value_set_uchar (&value, 255);
 284     str = gst_value_serialize (&value);
 285
 286     fail_unless_equals_string (str, "255");
 287     g_free (str);
 288   }
 289 }
 290
 291 GST_END_TEST;
 292
 293 GST_START_TEST (test_deserialize_gstfraction)
 294 {
 295   GValue value = { 0 };
 296   const char *strings[] = {
 297     "4/5",
 298     "-8/9"
 299   };
 300   gint64 result_numers[] = {
 301     4,
 302     -8
 303   };
 304   gint64 result_denoms[] = {
 305     5,
 306     9
 307   };
 308
 309   int i;
 310
 311   g_value_init (&value, GST_TYPE_FRACTION);
 312   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 313     fail_unless (gst_value_deserialize (&value, strings[i]),
 314         "could not deserialize %s (%d)", strings[i], i);
 315     fail_unless (gst_value_get_fraction_numerator (&value) == result_numers[i],
 316         "resulting numerator value is %d, not %d"
 317         ", for string %s (%d)", gst_value_get_fraction_numerator (&value),
 318         result_numers[i], strings[i], i);
 319     fail_unless (gst_value_get_fraction_denominator (&value) ==
 320         result_denoms[i], "resulting denominator value is %d, not %d"
 321         ", for string %s (%d)", gst_value_get_fraction_denominator (&value),
 322         result_denoms[i], strings[i], i);
 323   }
 324 }
 325
 326 GST_END_TEST;
 327
 328 GST_START_TEST (test_deserialize_gint)
 329 {
 330   GValue value = { 0 };
 331   const char *strings[] = {
 332     "123456",
 333     "-123456",
 334     "0xFFFF",
 335     "0x0000FFFF",
 336     /* a positive long long, serializing to highest possible positive sint */
 337     "0x7FFFFFFF",
 338     /* a positive long long, serializing to lowest possible negative sint */
 339     "0x80000000",
 340     /* a negative long long, serializing to lowest possible negative sint */
 341     "0xFFFFFFFF80000000",
 342     "0xFF000000",
 343     /* a positive long long serializing to -1 */
 344     "0xFFFFFFFF",
 345     "0xFFFFFFFF",
 346     /* a negative long long serializing to -1 */
 347     "0xFFFFFFFFFFFFFFFF",
 348     "0xFFFFFFFFFFFFFFFF",
 349     "0xEFFFFFFF",
 350   };
 351   /* some casts need to be explicit because of unsigned -> signed */
 352   gint results[] = {
 353     123456,
 354     -123456,
 355     0xFFFF,
 356     0xFFFF,
 357     0x7FFFFFFF,
 358     (gint) 0x80000000,
 359     (gint) 0x80000000,
 360     (gint) 0xFF000000,
 361     -1,
 362     (gint) 0xFFFFFFFF,
 363     -1,
 364     (gint) 0xFFFFFFFFFFFFFFFFLL,
 365     (gint) 0xEFFFFFFF,
 366   };
 367   int i;
 368
 369   g_value_init (&value, G_TYPE_INT);
 370
 371   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 372     fail_unless (gst_value_deserialize (&value, strings[i]),
 373         "could not deserialize %s (%d)", strings[i], i);
 374     fail_unless (g_value_get_int (&value) == results[i],
 375         "resulting value is %d, not %d, for string %s (%d)",
 376         g_value_get_int (&value), results[i], strings[i], i);
 377   }
 378 }
 379
 380 GST_END_TEST;
 381
 382 GST_START_TEST (test_deserialize_gint_failures)
 383 {
 384   GValue value = { 0 };
 385   const char *strings[] = {
 386     "-",                        /* not a complete number */
 387     "- TEST",                   /* not a complete number */
 388     "0x0000000100000000",       /* lowest long long that cannot fit in 32 bits */
 389     "0xF000000000000000",
 390     "0xFFFFFFF000000000",
 391     "0xFFFFFFFF00000000",
 392     "0x10000000000000000",      /* first number too long to fit into a long long */
 393     /* invent a new processor first before trying to make this one pass */
 394     "0x10000000000000000000000000000000000000000000",
 395   };
 396   int i;
 397
 398   g_value_init (&value, G_TYPE_INT);
 399
 400   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 401     fail_if (gst_value_deserialize (&value, strings[i]),
 402         "deserialized %s (%d), while it should have failed", strings[i], i);
 403   }
 404 }
 405
 406 GST_END_TEST;
 407
 408 GST_START_TEST (test_deserialize_guint)
 409 {
 410   GValue value = { 0 };
 411   const char *strings[] = {
 412     "123456",
 413     "-123456",
 414     "0xFFFF",
 415     "0x0000FFFF",
 416     /* a positive long long, serializing to highest possible positive sint */
 417     "0x7FFFFFFF",
 418     /* a positive long long, serializing to lowest possible negative sint */
 419     "0x80000000",
 420     "2147483648",
 421     /* a negative long long, serializing to lowest possible negative sint */
 422     "0xFFFFFFFF80000000",
 423     /* a value typically used for rgb masks */
 424     "0xFF000000",
 425     /* a positive long long serializing to highest possible positive uint */
 426     "0xFFFFFFFF",
 427     "0xFFFFFFFF",
 428     /* a negative long long serializing to highest possible positive uint */
 429     "0xFFFFFFFFFFFFFFFF",
 430     "0xEFFFFFFF",
 431   };
 432   guint results[] = {
 433     123456,
 434     (guint) - 123456,
 435     0xFFFF,
 436     0xFFFF,
 437     0x7FFFFFFF,
 438     0x80000000,
 439     (guint) 2147483648LL,
 440     0x80000000,
 441     0xFF000000,
 442     0xFFFFFFFF,
 443     G_MAXUINT,
 444     (guint) 0xFFFFFFFFFFFFFFFFLL,
 445     0xEFFFFFFF,
 446   };
 447   int i;
 448
 449   g_value_init (&value, G_TYPE_UINT);
 450
 451   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 452     fail_unless (gst_value_deserialize (&value, strings[i]),
 453         "could not deserialize %s (%d)", strings[i], i);
 454     fail_unless (g_value_get_uint (&value) == results[i],
 455         "resulting value is %d, not %d, for string %s (%d)",
 456         g_value_get_uint (&value), results[i], strings[i], i);
 457   }
 458 }
 459
 460 GST_END_TEST;
 461
 462 GST_START_TEST (test_deserialize_guint_failures)
 463 {
 464   GValue value = { 0 };
 465   const char *strings[] = {
 466     "-",                        /* not a complete number */
 467     "- TEST",                   /* not a complete number */
 468 #if 0
 469 /* FIXME: these values should not be deserializable, since they overflow
 470  * the target format */
 471     "0x0000000100000000",       /* lowest long long that cannot fit in 32 bits */
 472     "0xF000000000000000",
 473     "0xFFFFFFF000000000",
 474     "0xFFFFFFFF00000000",
 475     "0x10000000000000000",      /* first number too long to fit into a long long */
 476     /* invent a new processor first before trying to make this one pass */
 477     "0x10000000000000000000000000000000000000000000",
 478 #endif
 479   };
 480   int i;
 481
 482   g_value_init (&value, G_TYPE_UINT);
 483
 484   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 485     fail_if (gst_value_deserialize (&value, strings[i]),
 486         "deserialized %s (%d), while it should have failed", strings[i], i);
 487   }
 488 }
 489
 490 GST_END_TEST;
 491
 492 GST_START_TEST (test_serialize_flags)
 493 {
 494   GValue value = { 0 };
 495   gchar *string;
 496   GstSeekFlags flags[] = {
 497     0,
 498     GST_SEEK_FLAG_NONE,
 499     GST_SEEK_FLAG_FLUSH,
 500     GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
 501   };
 502   const char *results[] = {
 503     "GST_SEEK_FLAG_NONE",
 504     "GST_SEEK_FLAG_NONE",
 505     "GST_SEEK_FLAG_FLUSH",
 506     "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",
 507   };
 508   int i;
 509
 510   g_value_init (&value, GST_TYPE_SEEK_FLAGS);
 511
 512   for (i = 0; i < G_N_ELEMENTS (flags); ++i) {
 513     g_value_set_flags (&value, flags[i]);
 514     string = gst_value_serialize (&value);
 515     fail_if (string == NULL, "could not serialize flags %d", i);
 516     fail_unless (strcmp (string, results[i]) == 0,
 517         "resulting value is %s, not %s, for flags #%d", string, results[i], i);
 518     g_free (string);
 519   }
 520 }
 521
 522 GST_END_TEST;
 523
 524
 525 GST_START_TEST (test_deserialize_flags)
 526 {
 527   GValue value = { 0 };
 528   const char *strings[] = {
 529     "",
 530     "0",
 531     "GST_SEEK_FLAG_NONE",
 532     "GST_SEEK_FLAG_FLUSH",
 533     "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",
 534   };
 535   GstSeekFlags results[] = {
 536     GST_SEEK_FLAG_NONE,
 537     GST_SEEK_FLAG_NONE,
 538     GST_SEEK_FLAG_NONE,
 539     GST_SEEK_FLAG_FLUSH,
 540     GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
 541   };
 542   int i;
 543
 544   g_value_init (&value, GST_TYPE_SEEK_FLAGS);
 545
 546   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 547     fail_unless (gst_value_deserialize (&value, strings[i]),
 548         "could not deserialize %s (%d)", strings[i], i);
 549     fail_unless (g_value_get_flags (&value) == results[i],
 550         "resulting value is %d, not %d, for string %s (%d)",
 551         g_value_get_flags (&value), results[i], strings[i], i);
 552   }
 553 }
 554
 555 GST_END_TEST;
 556
 557 GST_START_TEST (test_string)
 558 {
 559   const gchar *try[] = {
 560     "Dude",
 561     "Hi, I'm a string",
 562     "tüüüt!",
 563     "\"\""                      /* Empty string */
 564   };
 565   gchar *tmp;
 566   GValue v = { 0, };
 567   guint i;
 568
 569   g_value_init (&v, G_TYPE_STRING);
 570   for (i = 0; i < G_N_ELEMENTS (try); i++) {
 571     g_value_set_string (&v, try[i]);
 572     tmp = gst_value_serialize (&v);
 573     fail_if (tmp == NULL, "couldn't serialize: %s\n", try[i]);
 574     fail_unless (gst_value_deserialize (&v, tmp),
 575         "couldn't deserialize: %s\n", tmp);
 576     g_free (tmp);
 577
 578     fail_unless (g_str_equal (g_value_get_string (&v), try[i]),
 579         "\nserialized  : %s\ndeserialized: %s", try[i],
 580         g_value_get_string (&v));
 581   }
 582   /* NULL strings should not be serializable */
 583   g_value_set_string (&v, NULL);
 584   fail_unless (gst_value_serialize (&v) == NULL);
 585   g_value_unset (&v);
 586 }
 587
 588 GST_END_TEST;
 589
 590 GST_START_TEST (test_deserialize_string)
 591 {
 592   struct
 593   {
 594     const gchar *from;
 595     const gchar *to;
 596   } tests[] = {
 597     {
 598     "", ""},                    /* empty strings */
 599     {
 600     "\"\"", ""},                /* quoted empty string -> empty string */
 601         /* Expected FAILURES: */
 602     {
 603     "\"", NULL},                /* missing second quote */
 604     {
 605     "\"Hello\\ World", NULL},   /* missing second quote */
 606     {
 607     "\"\\", NULL},              /* quote at end, missing second quote */
 608     {
 609     "\"\\0", NULL},             /* missing second quote */
 610     {
 611     "\"\\0\"", NULL},           /* unfinished escaped character */
 612     {
 613     "\" \"", NULL},             /* spaces must be escaped */
 614 #if 0
 615         /* FIXME 0.9: this test should fail, but it doesn't */
 616     {
 617     "tüüt", NULL}             /* string with special chars must be escaped */
 618 #endif
 619   };
 620   guint i;
 621   GValue v = { 0, };
 622
 623   g_value_init (&v, G_TYPE_STRING);
 624   for (i = 0; i < G_N_ELEMENTS (tests); i++) {
 625     if (gst_value_deserialize (&v, tests[i].from)) {
 626       fail_if (tests[i].to == NULL,
 627           "I got %s instead of a failure", g_value_get_string (&v));
 628       fail_unless (g_str_equal (g_value_get_string (&v), tests[i].to),
 629           "\nwanted: %s\ngot    : %s", tests[i].to, g_value_get_string (&v));
 630     } else {
 631       fail_if (tests[i].to != NULL, "failed, but wanted: %s", tests[i].to);
 632     }
 633   }
 634   g_value_unset (&v);
 635 }
 636
 637 GST_END_TEST;
 638
 639 GST_START_TEST (test_value_compare)
 640 {
 641   GValue value1 = { 0 };
 642   GValue value2 = { 0 };
 643   GValue tmp = { 0 };
 644
 645   g_value_init (&value1, G_TYPE_INT);
 646   g_value_set_int (&value1, 10);
 647   g_value_init (&value2, G_TYPE_INT);
 648   g_value_set_int (&value2, 20);
 649   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 650   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 651   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 652   g_value_unset (&value1);
 653   g_value_unset (&value2);
 654
 655   g_value_init (&value1, G_TYPE_DOUBLE);
 656   g_value_set_double (&value1, 10);
 657   g_value_init (&value2, G_TYPE_DOUBLE);
 658   g_value_set_double (&value2, 20);
 659   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 660   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 661   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 662   g_value_unset (&value1);
 663   g_value_unset (&value2);
 664
 665   g_value_init (&value1, G_TYPE_STRING);
 666   g_value_set_string (&value1, "a");
 667   g_value_init (&value2, G_TYPE_STRING);
 668   g_value_set_string (&value2, "b");
 669   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 670   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 671   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 672   /* Test some NULL string comparisons */
 673   g_value_set_string (&value2, NULL);
 674   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
 675   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_UNORDERED);
 676   fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL);
 677
 678   g_value_unset (&value1);
 679   g_value_unset (&value2);
 680
 681   g_value_init (&value1, GST_TYPE_FOURCC);
 682   gst_value_set_fourcc (&value1, GST_MAKE_FOURCC ('a', 'b', 'c', 'd'));
 683   g_value_init (&value2, GST_TYPE_FOURCC);
 684   gst_value_set_fourcc (&value2, GST_MAKE_FOURCC ('1', '2', '3', '4'));
 685   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
 686   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 687   g_value_unset (&value1);
 688   g_value_unset (&value2);
 689
 690   /* comparing 2/3 with 3/4 */
 691   g_value_init (&value1, GST_TYPE_FRACTION);
 692   gst_value_set_fraction (&value1, 2, 3);
 693   g_value_init (&value2, GST_TYPE_FRACTION);
 694   gst_value_set_fraction (&value2, 3, 4);
 695   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 696   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 697   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 698   g_value_unset (&value1);
 699   g_value_unset (&value2);
 700
 701   /* comparing -4/5 with 2/-3 */
 702   g_value_init (&value1, GST_TYPE_FRACTION);
 703   gst_value_set_fraction (&value1, -4, 5);
 704   g_value_init (&value2, GST_TYPE_FRACTION);
 705   gst_value_set_fraction (&value2, 2, -3);
 706   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 707   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 708   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 709   g_value_unset (&value1);
 710   g_value_unset (&value2);
 711
 712   /* comparing 10/100 with 200/2000 */
 713   g_value_init (&value1, GST_TYPE_FRACTION);
 714   gst_value_set_fraction (&value1, 10, 100);
 715   g_value_init (&value2, GST_TYPE_FRACTION);
 716   gst_value_set_fraction (&value2, 200, 2000);
 717   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL);
 718   g_value_unset (&value1);
 719   g_value_unset (&value2);
 720
 721   /* comparing -4/5 with 2/-3 */
 722   g_value_init (&value1, GST_TYPE_FRACTION);
 723   gst_value_set_fraction (&value1, -4, 5);
 724   g_value_init (&value2, GST_TYPE_FRACTION);
 725   gst_value_set_fraction (&value2, 2, -3);
 726   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 727   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 728   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 729   g_value_unset (&value1);
 730   g_value_unset (&value2);
 731
 732   /* Check that lists are equal regardless of order */
 733   g_value_init (&value1, GST_TYPE_LIST);
 734   g_value_init (&tmp, G_TYPE_INT);
 735   g_value_set_int (&tmp, 1);
 736   gst_value_list_append_value (&value1, &tmp);
 737   g_value_set_int (&tmp, 2);
 738   gst_value_list_append_value (&value1, &tmp);
 739   g_value_set_int (&tmp, 3);
 740   gst_value_list_append_value (&value1, &tmp);
 741   g_value_set_int (&tmp, 4);
 742   gst_value_list_append_value (&value1, &tmp);
 743
 744   g_value_init (&value2, GST_TYPE_LIST);
 745   g_value_set_int (&tmp, 4);
 746   gst_value_list_append_value (&value2, &tmp);
 747   g_value_set_int (&tmp, 3);
 748   gst_value_list_append_value (&value2, &tmp);
 749   g_value_set_int (&tmp, 2);
 750   gst_value_list_append_value (&value2, &tmp);
 751   g_value_set_int (&tmp, 1);
 752   gst_value_list_append_value (&value2, &tmp);
 753
 754   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 755       "value lists with different order were not equal when they should be");
 756   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL,
 757       "value lists with same order were not equal when they should be");
 758   fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL,
 759       "value lists with same order were not equal when they should be");
 760
 761   /* Carry over the lists to this next check: */
 762   /* Lists with different sizes are unequal */
 763   g_value_set_int (&tmp, 1);
 764   gst_value_list_append_value (&value2, &tmp);
 765
 766   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 767       "Value lists with different size were equal when they shouldn't be");
 768
 769   /* Carry over the lists to this next check: */
 770   /* Lists with same size but list1 contains one more element not in list2 */
 771   g_value_set_int (&tmp, 5);
 772   gst_value_list_append_value (&value1, &tmp);
 773
 774   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 775       "Value lists with different elements were equal when they shouldn't be");
 776   fail_if (gst_value_compare (&value2, &value1) == GST_VALUE_EQUAL,
 777       "Value lists with different elements were equal when they shouldn't be");
 778
 779   g_value_unset (&value1);
 780   g_value_unset (&value2);
 781   g_value_unset (&tmp);
 782
 783   /* Arrays are only equal when in the same order */
 784   g_value_init (&value1, GST_TYPE_ARRAY);
 785   g_value_init (&tmp, G_TYPE_INT);
 786   g_value_set_int (&tmp, 1);
 787   gst_value_array_append_value (&value1, &tmp);
 788   g_value_set_int (&tmp, 2);
 789   gst_value_array_append_value (&value1, &tmp);
 790   g_value_set_int (&tmp, 3);
 791   gst_value_array_append_value (&value1, &tmp);
 792   g_value_set_int (&tmp, 4);
 793   gst_value_array_append_value (&value1, &tmp);
 794
 795   g_value_init (&value2, GST_TYPE_ARRAY);
 796   g_value_set_int (&tmp, 4);
 797   gst_value_array_append_value (&value2, &tmp);
 798   g_value_set_int (&tmp, 3);
 799   gst_value_array_append_value (&value2, &tmp);
 800   g_value_set_int (&tmp, 2);
 801   gst_value_array_append_value (&value2, &tmp);
 802   g_value_set_int (&tmp, 1);
 803   gst_value_array_append_value (&value2, &tmp);
 804
 805   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 806       "Value arrays with different order were equal when they shouldn't be");
 807   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL,
 808       "Identical value arrays were not equal when they should be");
 809   fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL,
 810       "Identical value arrays were not equal when they should be");
 811
 812   /* Carry over the arrays to this next check: */
 813   /* Arrays with different sizes are unequal */
 814   g_value_unset (&value2);
 815   g_value_init (&value2, GST_TYPE_ARRAY);
 816   g_value_copy (&value1, &value2);
 817
 818   g_value_set_int (&tmp, 1);
 819   gst_value_array_append_value (&value2, &tmp);
 820
 821   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 822       "Value arrays with different size were equal when they shouldn't be");
 823   /* order should not matter */
 824   fail_if (gst_value_compare (&value2, &value1) == GST_VALUE_EQUAL,
 825       "Value arrays with different size were equal when they shouldn't be");
 826
 827   g_value_unset (&value1);
 828   g_value_unset (&value2);
 829   g_value_unset (&tmp);
 830 }
 831
 832 GST_END_TEST;
 833
 834 GST_START_TEST (test_value_intersect)
 835 {
 836   GValue dest = { 0 };
 837   GValue src1 = { 0 };
 838   GValue src2 = { 0 };
 839   GValue item = { 0 };
 840   gboolean ret;
 841
 842   g_value_init (&src1, G_TYPE_INT);
 843   g_value_set_int (&src1, 10);
 844   g_value_init (&src2, G_TYPE_INT);
 845   g_value_set_int (&src2, 20);
 846   ret = gst_value_intersect (&dest, &src1, &src2);
 847   fail_unless (ret == FALSE);
 848   g_value_unset (&src1);
 849   g_value_unset (&src2);
 850
 851   g_value_init (&src1, GST_TYPE_FOURCC);
 852   gst_value_set_fourcc (&src1, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 853   g_value_init (&src2, GST_TYPE_LIST);
 854   g_value_init (&item, GST_TYPE_FOURCC);
 855   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 856   gst_value_list_append_value (&src2, &item);
 857   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('I', '4', '2', '0'));
 858   gst_value_list_append_value (&src2, &item);
 859   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('A', 'B', 'C', 'D'));
 860   gst_value_list_append_value (&src2, &item);
 861
 862   fail_unless (gst_value_intersect (&dest, &src1, &src2));
 863   fail_unless (GST_VALUE_HOLDS_FOURCC (&dest));
 864   fail_unless (gst_value_get_fourcc (&dest) ==
 865       GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 866
 867   g_value_unset (&src1);
 868   g_value_unset (&src2);
 869 }
 870
 871 GST_END_TEST;
 872
 873
 874 GST_START_TEST (test_value_subtract_int)
 875 {
 876   GValue dest = { 0 };
 877   GValue src1 = { 0 };
 878   GValue src2 = { 0 };
 879   const GValue *tmp;
 880   gboolean ret;
 881
 882   /*  int <-> int
 883    */
 884   g_value_init (&src1, G_TYPE_INT);
 885   g_value_set_int (&src1, 10);
 886   g_value_init (&src2, G_TYPE_INT);
 887   g_value_set_int (&src2, 20);
 888   /* subtract as in sets, result is 10 */
 889   ret = gst_value_subtract (&dest, &src1, &src2);
 890   fail_unless (ret == TRUE);
 891   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 892   g_value_unset (&dest);
 893
 894   /* same values, yields empty set */
 895   ret = gst_value_subtract (&dest, &src1, &src1);
 896   fail_unless (ret == FALSE);
 897   g_value_unset (&src1);
 898   g_value_unset (&src2);
 899
 900   /*  int <-> int_range
 901    */
 902
 903   /* would yield an empty set */
 904   g_value_init (&src1, G_TYPE_INT);
 905   g_value_set_int (&src1, 10);
 906   g_value_init (&src2, GST_TYPE_INT_RANGE);
 907   gst_value_set_int_range (&src2, 0, 20);
 908   ret = gst_value_subtract (&dest, &src1, &src2);
 909   fail_unless (ret == FALSE);
 910
 911   /* and the other way around, should create a list of two ranges. */
 912   ret = gst_value_subtract (&dest, &src2, &src1);
 913   fail_unless (ret == TRUE);
 914   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 915   tmp = gst_value_list_get_value (&dest, 0);
 916   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 917   fail_unless (gst_value_get_int_range_min (tmp) == 0);
 918   fail_unless (gst_value_get_int_range_max (tmp) == 9);
 919   tmp = gst_value_list_get_value (&dest, 1);
 920   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 921   fail_unless (gst_value_get_int_range_min (tmp) == 11);
 922   fail_unless (gst_value_get_int_range_max (tmp) == 20);
 923   g_value_unset (&dest);
 924   g_value_unset (&src1);
 925   g_value_unset (&src2);
 926
 927   /* border case 1, empty set */
 928   g_value_init (&src1, G_TYPE_INT);
 929   g_value_set_int (&src1, 10);
 930   g_value_init (&src2, GST_TYPE_INT_RANGE);
 931   gst_value_set_int_range (&src2, 10, 20);
 932   ret = gst_value_subtract (&dest, &src1, &src2);
 933   fail_unless (ret == FALSE);
 934
 935   /* and the other way around, should create a new range. */
 936   ret = gst_value_subtract (&dest, &src2, &src1);
 937   fail_unless (ret == TRUE);
 938   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 939   fail_unless (gst_value_get_int_range_min (&dest) == 11);
 940   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 941   g_value_unset (&dest);
 942   g_value_unset (&src1);
 943   g_value_unset (&src2);
 944
 945   /* border case 2, empty set */
 946   g_value_init (&src1, G_TYPE_INT);
 947   g_value_set_int (&src1, 20);
 948   g_value_init (&src2, GST_TYPE_INT_RANGE);
 949   gst_value_set_int_range (&src2, 10, 20);
 950   ret = gst_value_subtract (&dest, &src1, &src2);
 951   fail_unless (ret == FALSE);
 952
 953   /* and the other way around, should create a new range. */
 954   ret = gst_value_subtract (&dest, &src2, &src1);
 955   fail_unless (ret == TRUE);
 956   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 957   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 958   fail_unless (gst_value_get_int_range_max (&dest) == 19);
 959   g_value_unset (&dest);
 960   g_value_unset (&src1);
 961   g_value_unset (&src2);
 962
 963   /* case 3, valid set */
 964   g_value_init (&src1, G_TYPE_INT);
 965   g_value_set_int (&src1, 0);
 966   g_value_init (&src2, GST_TYPE_INT_RANGE);
 967   gst_value_set_int_range (&src2, 10, 20);
 968   ret = gst_value_subtract (&dest, &src1, &src2);
 969   fail_unless (ret == TRUE);
 970   fail_unless (G_VALUE_HOLDS_INT (&dest) == TRUE);
 971   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 972   g_value_unset (&dest);
 973
 974   /* and the other way around, should keep the range. */
 975   ret = gst_value_subtract (&dest, &src2, &src1);
 976   fail_unless (ret == TRUE);
 977   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 978   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 979   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 980   g_value_unset (&dest);
 981   g_value_unset (&src1);
 982   g_value_unset (&src2);
 983
 984   /*  int_range <-> int_range
 985    */
 986
 987   /* same range, empty set */
 988   g_value_init (&src1, GST_TYPE_INT_RANGE);
 989   gst_value_set_int_range (&src1, 10, 20);
 990   g_value_init (&src2, GST_TYPE_INT_RANGE);
 991   gst_value_set_int_range (&src2, 10, 20);
 992   ret = gst_value_subtract (&dest, &src1, &src2);
 993   fail_unless (ret == FALSE);
 994   ret = gst_value_subtract (&dest, &src2, &src1);
 995   fail_unless (ret == FALSE);
 996   g_value_unset (&src1);
 997   g_value_unset (&src2);
 998
 999   /* non overlapping ranges */
1000   g_value_init (&src1, GST_TYPE_INT_RANGE);
1001   gst_value_set_int_range (&src1, 10, 20);
1002   g_value_init (&src2, GST_TYPE_INT_RANGE);
1003   gst_value_set_int_range (&src2, 30, 40);
1004   ret = gst_value_subtract (&dest, &src1, &src2);
1005   fail_unless (ret == TRUE);
1006   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1007   fail_unless (gst_value_get_int_range_min (&dest) == 10);
1008   fail_unless (gst_value_get_int_range_max (&dest) == 20);
1009   g_value_unset (&dest);
1010   /* the other way */
1011   ret = gst_value_subtract (&dest, &src2, &src1);
1012   fail_unless (ret == TRUE);
1013   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1014   fail_unless (gst_value_get_int_range_min (&dest) == 30);
1015   fail_unless (gst_value_get_int_range_max (&dest) == 40);
1016   g_value_unset (&dest);
1017   g_value_unset (&src1);
1018   g_value_unset (&src2);
1019
1020   /* completely overlapping ranges */
1021   g_value_init (&src1, GST_TYPE_INT_RANGE);
1022   gst_value_set_int_range (&src1, 10, 20);
1023   g_value_init (&src2, GST_TYPE_INT_RANGE);
1024   gst_value_set_int_range (&src2, 10, 30);
1025   ret = gst_value_subtract (&dest, &src1, &src2);
1026   fail_unless (ret == FALSE);
1027   /* the other way */
1028   ret = gst_value_subtract (&dest, &src2, &src1);
1029   fail_unless (ret == TRUE);
1030   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1031   fail_unless (gst_value_get_int_range_min (&dest) == 21);
1032   fail_unless (gst_value_get_int_range_max (&dest) == 30);
1033   g_value_unset (&dest);
1034   g_value_unset (&src1);
1035   g_value_unset (&src2);
1036
1037   /* partially overlapping ranges */
1038   g_value_init (&src1, GST_TYPE_INT_RANGE);
1039   gst_value_set_int_range (&src1, 10, 20);
1040   g_value_init (&src2, GST_TYPE_INT_RANGE);
1041   gst_value_set_int_range (&src2, 15, 30);
1042   ret = gst_value_subtract (&dest, &src1, &src2);
1043   fail_unless (ret == TRUE);
1044   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1045   fail_unless (gst_value_get_int_range_min (&dest) == 10);
1046   fail_unless (gst_value_get_int_range_max (&dest) == 14);
1047   g_value_unset (&dest);
1048   /* the other way */
1049   ret = gst_value_subtract (&dest, &src2, &src1);
1050   fail_unless (ret == TRUE);
1051   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1052   fail_unless (gst_value_get_int_range_min (&dest) == 21);
1053   fail_unless (gst_value_get_int_range_max (&dest) == 30);
1054   g_value_unset (&dest);
1055   g_value_unset (&src1);
1056   g_value_unset (&src2);
1057
1058   /* create a hole { int_range, int_range } */
1059   g_value_init (&src1, GST_TYPE_INT_RANGE);
1060   gst_value_set_int_range (&src1, 10, 30);
1061   g_value_init (&src2, GST_TYPE_INT_RANGE);
1062   gst_value_set_int_range (&src2, 15, 20);
1063   ret = gst_value_subtract (&dest, &src1, &src2);
1064   fail_unless (ret == TRUE);
1065   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1066   tmp = gst_value_list_get_value (&dest, 0);
1067   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1068   fail_unless (gst_value_get_int_range_min (tmp) == 10);
1069   fail_unless (gst_value_get_int_range_max (tmp) == 14);
1070   tmp = gst_value_list_get_value (&dest, 1);
1071   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1072   fail_unless (gst_value_get_int_range_min (tmp) == 21);
1073   fail_unless (gst_value_get_int_range_max (tmp) == 30);
1074   g_value_unset (&dest);
1075   /* the other way */
1076   ret = gst_value_subtract (&dest, &src2, &src1);
1077   fail_unless (ret == FALSE);
1078   g_value_unset (&src1);
1079   g_value_unset (&src2);
1080
1081   /* create a hole, { int, int } */
1082   g_value_init (&src1, GST_TYPE_INT_RANGE);
1083   gst_value_set_int_range (&src1, 10, 30);
1084   g_value_init (&src2, GST_TYPE_INT_RANGE);
1085   gst_value_set_int_range (&src2, 11, 29);
1086   ret = gst_value_subtract (&dest, &src1, &src2);
1087   fail_unless (ret == TRUE);
1088   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1089   tmp = gst_value_list_get_value (&dest, 0);
1090   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1091   fail_unless (g_value_get_int (tmp) == 10);
1092   tmp = gst_value_list_get_value (&dest, 1);
1093   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1094   fail_unless (g_value_get_int (tmp) == 30);
1095   g_value_unset (&dest);
1096   /* the other way */
1097   ret = gst_value_subtract (&dest, &src2, &src1);
1098   fail_unless (ret == FALSE);
1099   g_value_unset (&src1);
1100   g_value_unset (&src2);
1101
1102   /* create a hole, { int, int_range } */
1103   g_value_init (&src1, GST_TYPE_INT_RANGE);
1104   gst_value_set_int_range (&src1, 10, 30);
1105   g_value_init (&src2, GST_TYPE_INT_RANGE);
1106   gst_value_set_int_range (&src2, 11, 28);
1107   ret = gst_value_subtract (&dest, &src1, &src2);
1108   fail_unless (ret == TRUE);
1109   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1110   tmp = gst_value_list_get_value (&dest, 0);
1111   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1112   fail_unless (g_value_get_int (tmp) == 10);
1113   tmp = gst_value_list_get_value (&dest, 1);
1114   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1115   fail_unless (gst_value_get_int_range_min (tmp) == 29);
1116   fail_unless (gst_value_get_int_range_max (tmp) == 30);
1117   g_value_unset (&dest);
1118   /* the other way */
1119   ret = gst_value_subtract (&dest, &src2, &src1);
1120   fail_unless (ret == FALSE);
1121   g_value_unset (&src1);
1122   g_value_unset (&src2);
1123
1124   /* create a hole, { int_range, int } */
1125   g_value_init (&src1, GST_TYPE_INT_RANGE);
1126   gst_value_set_int_range (&src1, 10, 30);
1127   g_value_init (&src2, GST_TYPE_INT_RANGE);
1128   gst_value_set_int_range (&src2, 12, 29);
1129   ret = gst_value_subtract (&dest, &src1, &src2);
1130   fail_unless (ret == TRUE);
1131   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1132   tmp = gst_value_list_get_value (&dest, 0);
1133   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1134   fail_unless (gst_value_get_int_range_min (tmp) == 10);
1135   fail_unless (gst_value_get_int_range_max (tmp) == 11);
1136   tmp = gst_value_list_get_value (&dest, 1);
1137   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1138   fail_unless (g_value_get_int (tmp) == 30);
1139   g_value_unset (&dest);
1140   /* the other way */
1141   ret = gst_value_subtract (&dest, &src2, &src1);
1142   fail_unless (ret == FALSE);
1143   g_value_unset (&src1);
1144   g_value_unset (&src2);
1145 }
1146
1147 GST_END_TEST;
1148
1149 GST_START_TEST (test_value_subtract_int64)
1150 {
1151   GValue dest = { 0 };
1152   GValue src1 = { 0 };
1153   GValue src2 = { 0 };
1154   const GValue *tmp;
1155   gboolean ret;
1156
1157   /*  int64 <-> int64
1158    */
1159   g_value_init (&src1, G_TYPE_INT64);
1160   g_value_set_int64 (&src1, 10);
1161   g_value_init (&src2, G_TYPE_INT64);
1162   g_value_set_int64 (&src2, 20);
1163   /* subtract as in sets, result is 10 */
1164   ret = gst_value_subtract (&dest, &src1, &src2);
1165   fail_unless (ret == TRUE);
1166   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1167   g_value_unset (&dest);
1168
1169   /* same values, yields empty set */
1170   ret = gst_value_subtract (&dest, &src1, &src1);
1171   fail_unless (ret == FALSE);
1172   g_value_unset (&src1);
1173   g_value_unset (&src2);
1174
1175   /*  int64 <-> int64_range
1176    */
1177
1178   /* would yield an empty set */
1179   g_value_init (&src1, G_TYPE_INT64);
1180   g_value_set_int64 (&src1, 10);
1181   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1182   gst_value_set_int64_range (&src2, 0, 20);
1183   ret = gst_value_subtract (&dest, &src1, &src2);
1184   fail_unless (ret == FALSE);
1185
1186   /* and the other way around, should create a list of two ranges. */
1187   ret = gst_value_subtract (&dest, &src2, &src1);
1188   fail_unless (ret == TRUE);
1189   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1190   tmp = gst_value_list_get_value (&dest, 0);
1191   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1192   fail_unless (gst_value_get_int64_range_min (tmp) == 0);
1193   fail_unless (gst_value_get_int64_range_max (tmp) == 9);
1194   tmp = gst_value_list_get_value (&dest, 1);
1195   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1196   fail_unless (gst_value_get_int64_range_min (tmp) == 11);
1197   fail_unless (gst_value_get_int64_range_max (tmp) == 20);
1198   g_value_unset (&dest);
1199   g_value_unset (&src1);
1200   g_value_unset (&src2);
1201
1202   /* border case 1, empty set */
1203   g_value_init (&src1, G_TYPE_INT64);
1204   g_value_set_int64 (&src1, 10);
1205   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1206   gst_value_set_int64_range (&src2, 10, 20);
1207   ret = gst_value_subtract (&dest, &src1, &src2);
1208   fail_unless (ret == FALSE);
1209
1210   /* and the other way around, should create a new range. */
1211   ret = gst_value_subtract (&dest, &src2, &src1);
1212   fail_unless (ret == TRUE);
1213   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1214   fail_unless (gst_value_get_int64_range_min (&dest) == 11);
1215   fail_unless (gst_value_get_int64_range_max (&dest) == 20);
1216   g_value_unset (&dest);
1217   g_value_unset (&src1);
1218   g_value_unset (&src2);
1219
1220   /* border case 2, empty set */
1221   g_value_init (&src1, G_TYPE_INT64);
1222   g_value_set_int64 (&src1, 20);
1223   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1224   gst_value_set_int64_range (&src2, 10, 20);
1225   ret = gst_value_subtract (&dest, &src1, &src2);
1226   fail_unless (ret == FALSE);
1227
1228   /* and the other way around, should create a new range. */
1229   ret = gst_value_subtract (&dest, &src2, &src1);
1230   fail_unless (ret == TRUE);
1231   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1232   fail_unless (gst_value_get_int64_range_min (&dest) == 10);
1233   fail_unless (gst_value_get_int64_range_max (&dest) == 19);
1234   g_value_unset (&dest);
1235   g_value_unset (&src1);
1236   g_value_unset (&src2);
1237
1238   /* case 3, valid set */
1239   g_value_init (&src1, G_TYPE_INT64);
1240   g_value_set_int64 (&src1, 0);
1241   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1242   gst_value_set_int64_range (&src2, 10, 20);
1243   ret = gst_value_subtract (&dest, &src1, &src2);
1244   fail_unless (ret == TRUE);
1245   fail_unless (G_VALUE_HOLDS_INT64 (&dest) == TRUE);
1246   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1247   g_value_unset (&dest);
1248
1249   /* and the other way around, should keep the range. */
1250   ret = gst_value_subtract (&dest, &src2, &src1);
1251   fail_unless (ret == TRUE);
1252   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1253   fail_unless (gst_value_get_int64_range_min (&dest) == 10);
1254   fail_unless (gst_value_get_int64_range_max (&dest) == 20);
1255   g_value_unset (&dest);
1256   g_value_unset (&src1);
1257   g_value_unset (&src2);
1258
1259   /*  int64_range <-> int64_range
1260    */
1261
1262   /* same range, empty set */
1263   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1264   gst_value_set_int64_range (&src1, 10, 20);
1265   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1266   gst_value_set_int64_range (&src2, 10, 20);
1267   ret = gst_value_subtract (&dest, &src1, &src2);
1268   fail_unless (ret == FALSE);
1269   ret = gst_value_subtract (&dest, &src2, &src1);
1270   fail_unless (ret == FALSE);
1271   g_value_unset (&src1);
1272   g_value_unset (&src2);
1273
1274   /* non overlapping ranges */
1275   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1276   gst_value_set_int64_range (&src1, 10, 20);
1277   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1278   gst_value_set_int64_range (&src2, 30, 40);
1279   ret = gst_value_subtract (&dest, &src1, &src2);
1280   fail_unless (ret == TRUE);
1281   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1282   fail_unless (gst_value_get_int64_range_min (&dest) == 10);
1283   fail_unless (gst_value_get_int64_range_max (&dest) == 20);
1284   g_value_unset (&dest);
1285   /* the other way */
1286   ret = gst_value_subtract (&dest, &src2, &src1);
1287   fail_unless (ret == TRUE);
1288   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1289   fail_unless (gst_value_get_int64_range_min (&dest) == 30);
1290   fail_unless (gst_value_get_int64_range_max (&dest) == 40);
1291   g_value_unset (&dest);
1292   g_value_unset (&src1);
1293   g_value_unset (&src2);
1294
1295   /* completely overlapping ranges */
1296   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1297   gst_value_set_int64_range (&src1, 10, 20);
1298   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1299   gst_value_set_int64_range (&src2, 10, 30);
1300   ret = gst_value_subtract (&dest, &src1, &src2);
1301   fail_unless (ret == FALSE);
1302   /* the other way */
1303   ret = gst_value_subtract (&dest, &src2, &src1);
1304   fail_unless (ret == TRUE);
1305   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1306   fail_unless (gst_value_get_int64_range_min (&dest) == 21);
1307   fail_unless (gst_value_get_int64_range_max (&dest) == 30);
1308   g_value_unset (&dest);
1309   g_value_unset (&src1);
1310   g_value_unset (&src2);
1311
1312   /* partially overlapping ranges */
1313   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1314   gst_value_set_int64_range (&src1, 10, 20);
1315   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1316   gst_value_set_int64_range (&src2, 15, 30);
1317   ret = gst_value_subtract (&dest, &src1, &src2);
1318   fail_unless (ret == TRUE);
1319   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1320   fail_unless (gst_value_get_int64_range_min (&dest) == 10);
1321   fail_unless (gst_value_get_int64_range_max (&dest) == 14);
1322   g_value_unset (&dest);
1323   /* the other way */
1324   ret = gst_value_subtract (&dest, &src2, &src1);
1325   fail_unless (ret == TRUE);
1326   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1327   fail_unless (gst_value_get_int64_range_min (&dest) == 21);
1328   fail_unless (gst_value_get_int64_range_max (&dest) == 30);
1329   g_value_unset (&dest);
1330   g_value_unset (&src1);
1331   g_value_unset (&src2);
1332
1333   /* create a hole { int64_range, int64_range } */
1334   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1335   gst_value_set_int64_range (&src1, 10, 30);
1336   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1337   gst_value_set_int64_range (&src2, 15, 20);
1338   ret = gst_value_subtract (&dest, &src1, &src2);
1339   fail_unless (ret == TRUE);
1340   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1341   tmp = gst_value_list_get_value (&dest, 0);
1342   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1343   fail_unless (gst_value_get_int64_range_min (tmp) == 10);
1344   fail_unless (gst_value_get_int64_range_max (tmp) == 14);
1345   tmp = gst_value_list_get_value (&dest, 1);
1346   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1347   fail_unless (gst_value_get_int64_range_min (tmp) == 21);
1348   fail_unless (gst_value_get_int64_range_max (tmp) == 30);
1349   g_value_unset (&dest);
1350   /* the other way */
1351   ret = gst_value_subtract (&dest, &src2, &src1);
1352   fail_unless (ret == FALSE);
1353   g_value_unset (&src1);
1354   g_value_unset (&src2);
1355
1356   /* create a hole, { int64, int64 } */
1357   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1358   gst_value_set_int64_range (&src1, 10, 30);
1359   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1360   gst_value_set_int64_range (&src2, 11, 29);
1361   ret = gst_value_subtract (&dest, &src1, &src2);
1362   fail_unless (ret == TRUE);
1363   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1364   tmp = gst_value_list_get_value (&dest, 0);
1365   fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
1366   fail_unless (g_value_get_int64 (tmp) == 10);
1367   tmp = gst_value_list_get_value (&dest, 1);
1368   fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
1369   fail_unless (g_value_get_int64 (tmp) == 30);
1370   g_value_unset (&dest);
1371   /* the other way */
1372   ret = gst_value_subtract (&dest, &src2, &src1);
1373   fail_unless (ret == FALSE);
1374   g_value_unset (&src1);
1375   g_value_unset (&src2);
1376
1377   /* create a hole, { int64, int64_range } */
1378   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1379   gst_value_set_int64_range (&src1, 10, 30);
1380   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1381   gst_value_set_int64_range (&src2, 11, 28);
1382   ret = gst_value_subtract (&dest, &src1, &src2);
1383   fail_unless (ret == TRUE);
1384   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1385   tmp = gst_value_list_get_value (&dest, 0);
1386   fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
1387   fail_unless (g_value_get_int64 (tmp) == 10);
1388   tmp = gst_value_list_get_value (&dest, 1);
1389   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1390   fail_unless (gst_value_get_int64_range_min (tmp) == 29);
1391   fail_unless (gst_value_get_int64_range_max (tmp) == 30);
1392   g_value_unset (&dest);
1393   /* the other way */
1394   ret = gst_value_subtract (&dest, &src2, &src1);
1395   fail_unless (ret == FALSE);
1396   g_value_unset (&src1);
1397   g_value_unset (&src2);
1398
1399   /* create a hole, { int64_range, int64 } */
1400   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1401   gst_value_set_int64_range (&src1, 10, 30);
1402   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1403   gst_value_set_int64_range (&src2, 12, 29);
1404   ret = gst_value_subtract (&dest, &src1, &src2);
1405   fail_unless (ret == TRUE);
1406   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1407   tmp = gst_value_list_get_value (&dest, 0);
1408   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1409   fail_unless (gst_value_get_int64_range_min (tmp) == 10);
1410   fail_unless (gst_value_get_int64_range_max (tmp) == 11);
1411   tmp = gst_value_list_get_value (&dest, 1);
1412   fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
1413   fail_unless (g_value_get_int64 (tmp) == 30);
1414   g_value_unset (&dest);
1415   /* the other way */
1416   ret = gst_value_subtract (&dest, &src2, &src1);
1417   fail_unless (ret == FALSE);
1418   g_value_unset (&src1);
1419   g_value_unset (&src2);
1420 }
1421
1422 GST_END_TEST;
1423
1424 GST_START_TEST (test_value_subtract_double)
1425 {
1426   GValue dest = { 0 };
1427   GValue src1 = { 0 };
1428   GValue src2 = { 0 };
1429   const GValue *tmp;
1430   gboolean ret;
1431
1432   /*  double <-> double
1433    */
1434   g_value_init (&src1, G_TYPE_DOUBLE);
1435   g_value_set_double (&src1, 10.0);
1436   g_value_init (&src2, G_TYPE_DOUBLE);
1437   g_value_set_double (&src2, 20.0);
1438   /* subtract as in sets, result is 10 */
1439   ret = gst_value_subtract (&dest, &src1, &src2);
1440   fail_unless (ret == TRUE);
1441   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1442   g_value_unset (&dest);
1443
1444   /* same values, yields empty set */
1445   ret = gst_value_subtract (&dest, &src1, &src1);
1446   fail_unless (ret == FALSE);
1447   g_value_unset (&src1);
1448   g_value_unset (&src2);
1449
1450   /*  double <-> double_range
1451    */
1452
1453   /* would yield an empty set */
1454   g_value_init (&src1, G_TYPE_DOUBLE);
1455   g_value_set_double (&src1, 10.0);
1456   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1457   gst_value_set_double_range (&src2, 0.0, 20.0);
1458   ret = gst_value_subtract (&dest, &src1, &src2);
1459   fail_unless (ret == FALSE);
1460
1461   /* and the other way around, we cannot create open ranges
1462    * so the result is the range again */
1463   ret = gst_value_subtract (&dest, &src2, &src1);
1464   fail_unless (ret == TRUE);
1465   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1466   fail_unless (gst_value_get_double_range_min (&dest) == 0.0);
1467   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1468   g_value_unset (&dest);
1469   g_value_unset (&src1);
1470   g_value_unset (&src2);
1471
1472   /* border case 1, empty set */
1473   g_value_init (&src1, G_TYPE_DOUBLE);
1474   g_value_set_double (&src1, 10.0);
1475   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1476   gst_value_set_double_range (&src2, 10.0, 20.0);
1477   ret = gst_value_subtract (&dest, &src1, &src2);
1478   fail_unless (ret == FALSE);
1479
1480   /* and the other way around, should keep same range as
1481    * we don't have open ranges. */
1482   ret = gst_value_subtract (&dest, &src2, &src1);
1483   fail_unless (ret == TRUE);
1484   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1485   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1486   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1487   g_value_unset (&dest);
1488   g_value_unset (&src1);
1489   g_value_unset (&src2);
1490
1491   /* border case 2, empty set */
1492   g_value_init (&src1, G_TYPE_DOUBLE);
1493   g_value_set_double (&src1, 20.0);
1494   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1495   gst_value_set_double_range (&src2, 10.0, 20.0);
1496   ret = gst_value_subtract (&dest, &src1, &src2);
1497   fail_unless (ret == FALSE);
1498
1499   /* and the other way around, should keep same range as
1500    * we don't have open ranges. */
1501   ret = gst_value_subtract (&dest, &src2, &src1);
1502   fail_unless (ret == TRUE);
1503   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1504   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1505   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1506   g_value_unset (&dest);
1507   g_value_unset (&src1);
1508   g_value_unset (&src2);
1509
1510   /* case 3, valid set */
1511   g_value_init (&src1, G_TYPE_DOUBLE);
1512   g_value_set_double (&src1, 0.0);
1513   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1514   gst_value_set_double_range (&src2, 10.0, 20.0);
1515   ret = gst_value_subtract (&dest, &src1, &src2);
1516   fail_unless (ret == TRUE);
1517   fail_unless (G_VALUE_HOLDS_DOUBLE (&dest) == TRUE);
1518   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1519   g_value_unset (&dest);
1520
1521   /* and the other way around, should keep the range. */
1522   ret = gst_value_subtract (&dest, &src2, &src1);
1523   fail_unless (ret == TRUE);
1524   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1525   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1526   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1527   g_value_unset (&dest);
1528   g_value_unset (&src1);
1529   g_value_unset (&src2);
1530
1531   /*  double_range <-> double_range
1532    */
1533
1534   /* same range, empty set */
1535   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1536   gst_value_set_double_range (&src1, 10.0, 20.0);
1537   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1538   gst_value_set_double_range (&src2, 10.0, 20.0);
1539   ret = gst_value_subtract (&dest, &src1, &src2);
1540   fail_unless (ret == FALSE);
1541   ret = gst_value_subtract (&dest, &src2, &src1);
1542   fail_unless (ret == FALSE);
1543   g_value_unset (&src1);
1544   g_value_unset (&src2);
1545
1546   /* non overlapping ranges */
1547   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1548   gst_value_set_double_range (&src1, 10.0, 20.0);
1549   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1550   gst_value_set_double_range (&src2, 30.0, 40.0);
1551   ret = gst_value_subtract (&dest, &src1, &src2);
1552   fail_unless (ret == TRUE);
1553   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1554   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1555   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1556   g_value_unset (&dest);
1557   /* the other way */
1558   ret = gst_value_subtract (&dest, &src2, &src1);
1559   fail_unless (ret == TRUE);
1560   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1561   fail_unless (gst_value_get_double_range_min (&dest) == 30.0);
1562   fail_unless (gst_value_get_double_range_max (&dest) == 40.0);
1563   g_value_unset (&dest);
1564   g_value_unset (&src1);
1565   g_value_unset (&src2);
1566
1567   /* completely overlapping ranges */
1568   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1569   gst_value_set_double_range (&src1, 10.0, 20.0);
1570   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1571   gst_value_set_double_range (&src2, 10.0, 30.0);
1572   ret = gst_value_subtract (&dest, &src1, &src2);
1573   fail_unless (ret == FALSE);
1574   /* the other way */
1575   ret = gst_value_subtract (&dest, &src2, &src1);
1576   fail_unless (ret == TRUE);
1577   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1578   fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
1579   fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
1580   g_value_unset (&dest);
1581   g_value_unset (&src1);
1582   g_value_unset (&src2);
1583
1584   /* partially overlapping ranges */
1585   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1586   gst_value_set_double_range (&src1, 10.0, 20.0);
1587   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1588   gst_value_set_double_range (&src2, 15.0, 30.0);
1589   ret = gst_value_subtract (&dest, &src1, &src2);
1590   fail_unless (ret == TRUE);
1591   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1592   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1593   fail_unless (gst_value_get_double_range_max (&dest) == 15.0);
1594   g_value_unset (&dest);
1595   /* the other way */
1596   ret = gst_value_subtract (&dest, &src2, &src1);
1597   fail_unless (ret == TRUE);
1598   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1599   fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
1600   fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
1601   g_value_unset (&dest);
1602   g_value_unset (&src1);
1603   g_value_unset (&src2);
1604
1605   /* create a hole { double_range, double_range } */
1606   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1607   gst_value_set_double_range (&src1, 10.0, 30.0);
1608   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1609   gst_value_set_double_range (&src2, 15.0, 20.0);
1610   ret = gst_value_subtract (&dest, &src1, &src2);
1611   fail_unless (ret == TRUE);
1612   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1613   tmp = gst_value_list_get_value (&dest, 0);
1614   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
1615   fail_unless (gst_value_get_double_range_min (tmp) == 10.0);
1616   fail_unless (gst_value_get_double_range_max (tmp) == 15.0);
1617   tmp = gst_value_list_get_value (&dest, 1);
1618   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
1619   fail_unless (gst_value_get_double_range_min (tmp) == 20.0);
1620   fail_unless (gst_value_get_double_range_max (tmp) == 30.0);
1621   g_value_unset (&dest);
1622   /* the other way */
1623   ret = gst_value_subtract (&dest, &src2, &src1);
1624   fail_unless (ret == FALSE);
1625   g_value_unset (&src1);
1626   g_value_unset (&src2);
1627 }
1628
1629 GST_END_TEST;
1630
1631 /* Test arithmetic subtraction of fractions */
1632 GST_START_TEST (test_value_subtract_fraction)
1633 {
1634   GValue result = { 0 };
1635   GValue src1 = { 0 };
1636   GValue src2 = { 0 };
1637
1638   /* Subtract 1/4 from 1/2 */
1639   g_value_init (&src1, GST_TYPE_FRACTION);
1640   g_value_init (&src2, GST_TYPE_FRACTION);
1641   g_value_init (&result, GST_TYPE_FRACTION);
1642   gst_value_set_fraction (&src1, 1, 2);
1643   gst_value_set_fraction (&src2, 1, 4);
1644   fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1645   fail_unless (gst_value_get_fraction_numerator (&result) == 1);
1646   fail_unless (gst_value_get_fraction_denominator (&result) == 4);
1647
1648   g_value_unset (&src1);
1649   g_value_unset (&src2);
1650   g_value_unset (&result);
1651
1652   /* Subtract 1/12 from 7/8 */
1653   g_value_init (&src1, GST_TYPE_FRACTION);
1654   g_value_init (&src2, GST_TYPE_FRACTION);
1655   g_value_init (&result, GST_TYPE_FRACTION);
1656   gst_value_set_fraction (&src1, 7, 8);
1657   gst_value_set_fraction (&src2, 1, 12);
1658   fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1659   fail_unless (gst_value_get_fraction_numerator (&result) == 19);
1660   fail_unless (gst_value_get_fraction_denominator (&result) == 24);
1661
1662   g_value_unset (&src1);
1663   g_value_unset (&src2);
1664   g_value_unset (&result);
1665
1666   /* Subtract 12/13 from 4/3 */
1667   g_value_init (&src1, GST_TYPE_FRACTION);
1668   g_value_init (&src2, GST_TYPE_FRACTION);
1669   g_value_init (&result, GST_TYPE_FRACTION);
1670   gst_value_set_fraction (&src1, 4, 3);
1671   gst_value_set_fraction (&src2, 12, 13);
1672   fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1673   fail_unless (gst_value_get_fraction_numerator (&result) == 16);
1674   fail_unless (gst_value_get_fraction_denominator (&result) == 39);
1675
1676   g_value_unset (&src1);
1677   g_value_unset (&src2);
1678   g_value_unset (&result);
1679
1680   /* Subtract 1/12 from 7/8 */
1681 }
1682
1683 GST_END_TEST;
1684
1685 /* Test set subtraction operations on fraction ranges */
1686 GST_START_TEST (test_value_subtract_fraction_range)
1687 {
1688   GValue dest = { 0 };
1689   GValue src1 = { 0 };
1690   GValue src2 = { 0 };
1691   GValue cmp = { 0 };
1692   const GValue *tmp;
1693   gboolean ret;
1694
1695   /* Value for tests */
1696   g_value_init (&cmp, GST_TYPE_FRACTION);
1697
1698   /*  fraction <-> fraction
1699    */
1700   g_value_init (&src1, GST_TYPE_FRACTION);
1701   gst_value_set_fraction (&src1, 10, 1);
1702   g_value_init (&src2, GST_TYPE_FRACTION);
1703   gst_value_set_fraction (&src2, 20, 1);
1704   gst_value_set_fraction (&src1, 10, 1);
1705
1706   /* subtract as in sets, result is 10 */
1707   ret = gst_value_subtract (&dest, &src1, &src2);
1708   fail_unless (ret == TRUE);
1709   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1710   g_value_unset (&dest);
1711
1712   /* same values, yields empty set */
1713   ret = gst_value_subtract (&dest, &src1, &src1);
1714   fail_unless (ret == FALSE);
1715   g_value_unset (&src1);
1716   g_value_unset (&src2);
1717
1718   /*  fraction <-> fraction_range
1719    */
1720
1721   /* would yield an empty set */
1722   g_value_init (&src1, GST_TYPE_FRACTION);
1723   gst_value_set_fraction (&src1, 10, 1);
1724   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1725   gst_value_set_fraction_range_full (&src2, 0, 1, 20, 1);
1726   ret = gst_value_subtract (&dest, &src1, &src2);
1727   fail_unless (ret == FALSE);
1728
1729   /* and the other way around, we cannot create open ranges
1730    * so the result is the range again */
1731   ret = gst_value_subtract (&dest, &src2, &src1);
1732   fail_unless (ret == TRUE);
1733   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1734   gst_value_set_fraction (&cmp, 0, 1);
1735   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1736           &cmp) == GST_VALUE_EQUAL);
1737   gst_value_set_fraction (&cmp, 20, 1);
1738   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1739           &cmp) == GST_VALUE_EQUAL);
1740   g_value_unset (&dest);
1741   g_value_unset (&src1);
1742   g_value_unset (&src2);
1743
1744   /* border case 1, empty set */
1745   g_value_init (&src1, GST_TYPE_FRACTION);
1746   gst_value_set_fraction (&src1, 10, 1);
1747   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1748   gst_value_set_fraction_range_full (&src2, 10, 1, 20, 1);
1749   ret = gst_value_subtract (&dest, &src1, &src2);
1750   fail_unless (ret == FALSE);
1751
1752   /* and the other way around, should keep same range as
1753    * we don't have open ranges. */
1754   ret = gst_value_subtract (&dest, &src2, &src1);
1755   fail_unless (ret == TRUE);
1756   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1757   gst_value_set_fraction (&cmp, 10, 1);
1758   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1759           &cmp) == GST_VALUE_EQUAL);
1760   gst_value_set_fraction (&cmp, 20, 1);
1761   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1762           &cmp) == GST_VALUE_EQUAL);
1763   g_value_unset (&dest);
1764   g_value_unset (&src1);
1765   g_value_unset (&src2);
1766
1767   /* case 2, valid set */
1768   g_value_init (&src1, GST_TYPE_FRACTION);
1769   gst_value_set_fraction (&src1, 0, 1);
1770   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1771   gst_value_set_fraction_range_full (&src2, 10, 1, 20, 1);
1772   ret = gst_value_subtract (&dest, &src1, &src2);
1773   fail_unless (ret == TRUE);
1774   fail_unless (GST_VALUE_HOLDS_FRACTION (&dest) == TRUE);
1775   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1776   g_value_unset (&dest);
1777
1778   /* and the other way around, should keep the range. */
1779   ret = gst_value_subtract (&dest, &src2, &src1);
1780   fail_unless (ret == TRUE);
1781   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1782   fail_unless (gst_value_compare (&dest, &src2) == GST_VALUE_EQUAL);
1783   g_value_unset (&dest);
1784   g_value_unset (&src1);
1785   g_value_unset (&src2);
1786
1787   /*  fraction_range <-> fraction_range
1788    */
1789
1790   /* same range, empty set */
1791   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1792   gst_value_set_fraction_range_full (&src1, 10, 2, 20, 2);
1793   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1794   gst_value_set_fraction_range_full (&src2, 10, 2, 20, 2);
1795   ret = gst_value_subtract (&dest, &src1, &src2);
1796   fail_unless (ret == FALSE);
1797   ret = gst_value_subtract (&dest, &src2, &src1);
1798   fail_unless (ret == FALSE);
1799   g_value_unset (&src1);
1800   g_value_unset (&src2);
1801
1802   /* non overlapping ranges */
1803   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1804   gst_value_set_fraction_range_full (&src1, 10, 2, 10, 1);
1805   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1806   gst_value_set_fraction_range_full (&src2, 30, 2, 40, 2);
1807   ret = gst_value_subtract (&dest, &src1, &src2);
1808   fail_unless (ret == TRUE);
1809   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1810   gst_value_set_fraction (&cmp, 5, 1);
1811   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1812           &cmp) == GST_VALUE_EQUAL);
1813   gst_value_set_fraction (&cmp, 10, 1);
1814   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1815           &cmp) == GST_VALUE_EQUAL);
1816
1817   g_value_unset (&dest);
1818   /* the other way */
1819   ret = gst_value_subtract (&dest, &src2, &src1);
1820   fail_unless (ret == TRUE);
1821   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1822   gst_value_set_fraction (&cmp, 15, 1);
1823   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1824           &cmp) == GST_VALUE_EQUAL);
1825   gst_value_set_fraction (&cmp, 20, 1);
1826   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1827           &cmp) == GST_VALUE_EQUAL);
1828   g_value_unset (&dest);
1829   g_value_unset (&src1);
1830   g_value_unset (&src2);
1831
1832   /* completely overlapping ranges */
1833   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1834   gst_value_set_fraction_range_full (&src1, 10, 1, 20, 1);
1835   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1836   gst_value_set_fraction_range_full (&src2, 10, 1, 30, 1);
1837   ret = gst_value_subtract (&dest, &src1, &src2);
1838   fail_unless (ret == FALSE);
1839   /* the other way */
1840   ret = gst_value_subtract (&dest, &src2, &src1);
1841   fail_unless (ret == TRUE);
1842   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1843   gst_value_set_fraction (&cmp, 20, 1);
1844   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1845           &cmp) == GST_VALUE_EQUAL);
1846   gst_value_set_fraction (&cmp, 30, 1);
1847   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1848           &cmp) == GST_VALUE_EQUAL);
1849   g_value_unset (&dest);
1850   g_value_unset (&src1);
1851   g_value_unset (&src2);
1852
1853   /* partially overlapping ranges */
1854   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1855   gst_value_set_fraction_range_full (&src1, 10, 1, 20, 1);
1856   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1857   gst_value_set_fraction_range_full (&src2, 15, 1, 30, 1);
1858   ret = gst_value_subtract (&dest, &src1, &src2);
1859   fail_unless (ret == TRUE);
1860   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1861   gst_value_set_fraction (&cmp, 10, 1);
1862   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1863           &cmp) == GST_VALUE_EQUAL);
1864   gst_value_set_fraction (&cmp, 15, 1);
1865   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1866           &cmp) == GST_VALUE_EQUAL);
1867   g_value_unset (&dest);
1868
1869   /* the other way */
1870   ret = gst_value_subtract (&dest, &src2, &src1);
1871   fail_unless (ret == TRUE);
1872   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1873   gst_value_set_fraction (&cmp, 20, 1);
1874   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1875           &cmp) == GST_VALUE_EQUAL);
1876   gst_value_set_fraction (&cmp, 30, 1);
1877   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1878           &cmp) == GST_VALUE_EQUAL);
1879   g_value_unset (&dest);
1880   g_value_unset (&src1);
1881   g_value_unset (&src2);
1882
1883   /* create a hole { double_range, double_range } */
1884   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1885   gst_value_set_fraction_range_full (&src1, 10, 1, 30, 1);
1886   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1887   gst_value_set_fraction_range_full (&src2, 15, 1, 20, 1);
1888   ret = gst_value_subtract (&dest, &src1, &src2);
1889   fail_unless (ret == TRUE);
1890   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1891   /* 1st list entry */
1892   tmp = gst_value_list_get_value (&dest, 0);
1893   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (tmp) == TRUE);
1894   gst_value_set_fraction (&cmp, 10, 1);
1895   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (tmp),
1896           &cmp) == GST_VALUE_EQUAL);
1897   gst_value_set_fraction (&cmp, 15, 1);
1898   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (tmp),
1899           &cmp) == GST_VALUE_EQUAL);
1900   /* 2nd list entry */
1901   tmp = gst_value_list_get_value (&dest, 1);
1902   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (tmp) == TRUE);
1903   gst_value_set_fraction (&cmp, 20, 1);
1904   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (tmp),
1905           &cmp) == GST_VALUE_EQUAL);
1906   gst_value_set_fraction (&cmp, 30, 1);
1907   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (tmp),
1908           &cmp) == GST_VALUE_EQUAL);
1909   g_value_unset (&dest);
1910   /* the other way */
1911   ret = gst_value_subtract (&dest, &src2, &src1);
1912   fail_unless (ret == FALSE);
1913   g_value_unset (&src1);
1914   g_value_unset (&src2);
1915
1916   g_value_unset (&cmp);
1917 }
1918
1919 GST_END_TEST;
1920
1921 /* Test set subtraction operations on fraction lists */
1922 GST_START_TEST (test_value_subtract_fraction_list)
1923 {
1924   GValue list1 = { 0 };
1925   GValue list2 = { 0 };
1926   GValue val1 = { 0 };
1927   GValue val2 = { 0 };
1928   GValue tmp = { 0 };
1929   gboolean ret;
1930
1931   g_value_init (&list1, GST_TYPE_LIST);
1932   g_value_init (&val1, GST_TYPE_FRACTION);
1933   gst_value_set_fraction (&val1, 15, 2);
1934   gst_value_list_append_value (&list1, &val1);
1935   g_value_init (&tmp, GST_TYPE_FRACTION);
1936   gst_value_set_fraction (&tmp, 5, 1);
1937   gst_value_list_append_value (&list1, &tmp);
1938   g_value_unset (&tmp);
1939
1940   g_value_init (&list2, GST_TYPE_LIST);
1941   g_value_init (&val2, GST_TYPE_FRACTION);
1942   gst_value_set_fraction (&val2, 15, 1);
1943   gst_value_list_append_value (&list2, &val2);
1944   g_value_init (&tmp, GST_TYPE_FRACTION);
1945   gst_value_set_fraction (&tmp, 5, 1);
1946   gst_value_list_append_value (&list2, &tmp);
1947   g_value_unset (&tmp);
1948
1949   /* should subtract all common elements */
1950   ret = gst_value_subtract (&tmp, &list1, &list2);
1951   fail_unless (ret == TRUE);
1952   fail_unless (gst_value_compare (&tmp, &val1) == GST_VALUE_EQUAL);
1953   g_value_unset (&val1);
1954   g_value_unset (&tmp);
1955
1956   ret = gst_value_subtract (&tmp, &list2, &list1);
1957   fail_unless (ret == TRUE);
1958   fail_unless (gst_value_compare (&tmp, &val2) == GST_VALUE_EQUAL);
1959   g_value_unset (&val2);
1960   g_value_unset (&tmp);
1961
1962   g_value_unset (&list1);
1963   g_value_unset (&list2);
1964 }
1965
1966 GST_END_TEST;
1967
1968
1969 GST_START_TEST (test_date)
1970 {
1971   GstStructure *s;
1972   GDate *date, *date2;
1973   gchar *str;
1974
1975   date = g_date_new_dmy (22, 9, 2005);
1976
1977   s = gst_structure_new ("media/x-type", "SOME_DATE_TAG", GST_TYPE_DATE,
1978       date, NULL);
1979
1980   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
1981           GST_TYPE_DATE));
1982   fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date2));
1983   fail_unless (date2 != NULL);
1984   fail_unless (g_date_valid (date2));
1985   fail_unless (g_date_compare (date, date2) == 0);
1986
1987   g_date_free (date);
1988   g_date_free (date2);
1989   date = NULL;
1990   date2 = NULL;
1991
1992   str = gst_structure_to_string (s);
1993   gst_structure_free (s);
1994   s = NULL;
1995
1996   fail_unless (g_str_equal (str,
1997           "media/x-type, SOME_DATE_TAG=(date)2005-09-22;"));
1998
1999   s = gst_structure_from_string (str, NULL);
2000   g_free (str);
2001   str = NULL;
2002
2003   fail_unless (s != NULL);
2004   fail_unless (gst_structure_has_name (s, "media/x-type"));
2005   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
2006           GST_TYPE_DATE));
2007   fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date));
2008   fail_unless (date != NULL);
2009   fail_unless (g_date_valid (date));
2010   fail_unless (g_date_get_day (date) == 22);
2011   fail_unless (g_date_get_month (date) == 9);
2012   fail_unless (g_date_get_year (date) == 2005);
2013   g_date_free (date);
2014   date = NULL;
2015
2016   str = gst_structure_to_string (s);
2017   gst_structure_free (s);
2018   s = NULL;
2019
2020   fail_unless (g_str_equal (str,
2021           "media/x-type, SOME_DATE_TAG=(date)2005-09-22;"));
2022   g_free (str);
2023   str = NULL;
2024 }
2025
2026 GST_END_TEST;
2027
2028 static gboolean
2029 date_time_equal (GstDateTime * a, GstDateTime * b)
2030 {
2031   if (gst_date_time_get_year (a) != gst_date_time_get_year (b) ||
2032       gst_date_time_get_month (a) != gst_date_time_get_month (b) ||
2033       gst_date_time_get_day (a) != gst_date_time_get_day (b))
2034     return FALSE;
2035
2036   if (gst_date_time_get_hour (a) != gst_date_time_get_hour (b) ||
2037       gst_date_time_get_minute (a) != gst_date_time_get_minute (b) ||
2038       gst_date_time_get_second (a) != gst_date_time_get_second (b) ||
2039       gst_date_time_get_microsecond (a) != gst_date_time_get_microsecond (b))
2040     return FALSE;
2041
2042   if (gst_date_time_get_time_zone_offset (a) !=
2043       gst_date_time_get_time_zone_offset (b))
2044     return FALSE;
2045
2046   return TRUE;
2047 }
2048
2049 GST_START_TEST (test_date_time)
2050 {
2051   GstStructure *s;
2052   GstDateTime *datetime, *datetime2;
2053   gchar *str;
2054
2055   /* utc timezone */
2056   datetime = gst_date_time_new (0, 2010, 6, 23, 7, 40, 10);
2057
2058   s = gst_structure_new ("media/x-type", "SOME_DATE_TIME_TAG",
2059       GST_TYPE_DATE_TIME, datetime, NULL);
2060
2061   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2062           GST_TYPE_DATE_TIME));
2063   fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2064           &datetime2));
2065   fail_unless (datetime2 != NULL);
2066   fail_unless (date_time_equal (datetime, datetime2));
2067
2068   gst_date_time_unref (datetime);
2069   gst_date_time_unref (datetime2);
2070   datetime = NULL;
2071   datetime2 = NULL;
2072
2073   str = gst_structure_to_string (s);
2074   gst_structure_free (s);
2075   s = NULL;
2076
2077   fail_unless (g_str_equal (str,
2078           "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000000+0000\";"));
2079
2080   s = gst_structure_from_string (str, NULL);
2081   g_free (str);
2082   str = NULL;
2083
2084   fail_unless (s != NULL);
2085   fail_unless (gst_structure_has_name (s, "media/x-type"));
2086   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2087           GST_TYPE_DATE_TIME));
2088   fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2089           &datetime));
2090   fail_unless (datetime != NULL);
2091   fail_unless (gst_date_time_get_year (datetime) == 2010);
2092   fail_unless (gst_date_time_get_month (datetime) == 6);
2093   fail_unless (gst_date_time_get_day (datetime) == 23);
2094   fail_unless (gst_date_time_get_hour (datetime) == 7);
2095   fail_unless (gst_date_time_get_minute (datetime) == 40);
2096   fail_unless (gst_date_time_get_second (datetime) == 10);
2097   fail_unless (gst_date_time_get_microsecond (datetime) == 0);
2098   fail_unless (gst_date_time_get_time_zone_offset (datetime) == 0);
2099   gst_date_time_unref (datetime);
2100   datetime = NULL;
2101
2102   str = gst_structure_to_string (s);
2103   gst_structure_free (s);
2104   s = NULL;
2105
2106   fail_unless (g_str_equal (str,
2107           "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000000+0000\";"));
2108   g_free (str);
2109   str = NULL;
2110
2111   /* with timezone */
2112   datetime = gst_date_time_new (-3.0, 2010, 6, 23, 7, 40, 10.000001);
2113
2114   s = gst_structure_new ("media/x-type", "SOME_DATE_TIME_TAG",
2115       GST_TYPE_DATE_TIME, datetime, NULL);
2116
2117   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2118           GST_TYPE_DATE_TIME));
2119   fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2120           &datetime2));
2121   fail_unless (datetime2 != NULL);
2122   fail_unless (date_time_equal (datetime, datetime2));
2123
2124   gst_date_time_unref (datetime);
2125   gst_date_time_unref (datetime2);
2126   datetime = NULL;
2127   datetime2 = NULL;
2128
2129   str = gst_structure_to_string (s);
2130   gst_structure_free (s);
2131   s = NULL;
2132
2133   fail_unless (g_str_equal (str,
2134           "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000001-0300\";"));
2135
2136   s = gst_structure_from_string (str, NULL);
2137   g_free (str);
2138   str = NULL;
2139
2140   fail_unless (s != NULL);
2141   fail_unless (gst_structure_has_name (s, "media/x-type"));
2142   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2143           GST_TYPE_DATE_TIME));
2144   fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2145           &datetime));
2146   fail_unless (datetime != NULL);
2147   fail_unless (gst_date_time_get_year (datetime) == 2010);
2148   fail_unless (gst_date_time_get_month (datetime) == 6);
2149   fail_unless (gst_date_time_get_day (datetime) == 23);
2150   fail_unless (gst_date_time_get_hour (datetime) == 7);
2151   fail_unless (gst_date_time_get_minute (datetime) == 40);
2152   fail_unless (gst_date_time_get_second (datetime) == 10);
2153   fail_unless (gst_date_time_get_microsecond (datetime) == 1);
2154   fail_unless (gst_date_time_get_time_zone_offset (datetime) == -3);
2155   gst_date_time_unref (datetime);
2156   datetime = NULL;
2157
2158   str = gst_structure_to_string (s);
2159   gst_structure_free (s);
2160   s = NULL;
2161   fail_unless (g_str_equal (str,
2162           "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000001-0300\";"));
2163
2164   g_free (str);
2165   str = NULL;
2166
2167   /* with positive timezone */
2168   datetime = gst_date_time_new (2.0, 2010, 6, 23, 7, 40, 10.000001);
2169
2170   s = gst_structure_new ("media/x-type", "SOME_DATE_TIME_TAG",
2171       GST_TYPE_DATE_TIME, datetime, NULL);
2172
2173   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2174           GST_TYPE_DATE_TIME));
2175   fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2176           &datetime2));
2177   fail_unless (datetime2 != NULL);
2178   fail_unless (date_time_equal (datetime, datetime2));
2179
2180   gst_date_time_unref (datetime);
2181   gst_date_time_unref (datetime2);
2182   datetime = NULL;
2183   datetime2 = NULL;
2184
2185   str = gst_structure_to_string (s);
2186   gst_structure_free (s);
2187   s = NULL;
2188
2189   fail_unless (g_str_equal (str,
2190           "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000001+0200\";"));
2191
2192   s = gst_structure_from_string (str, NULL);
2193   g_free (str);
2194   str = NULL;
2195
2196   fail_unless (s != NULL);
2197   fail_unless (gst_structure_has_name (s, "media/x-type"));
2198   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2199           GST_TYPE_DATE_TIME));
2200   fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2201           &datetime));
2202   fail_unless (datetime != NULL);
2203   fail_unless (gst_date_time_get_year (datetime) == 2010);
2204   fail_unless (gst_date_time_get_month (datetime) == 6);
2205   fail_unless (gst_date_time_get_day (datetime) == 23);
2206   fail_unless (gst_date_time_get_hour (datetime) == 7);
2207   fail_unless (gst_date_time_get_minute (datetime) == 40);
2208   fail_unless (gst_date_time_get_second (datetime) == 10);
2209   fail_unless (gst_date_time_get_microsecond (datetime) == 1);
2210   fail_unless (gst_date_time_get_time_zone_offset (datetime) == 2);
2211   gst_date_time_unref (datetime);
2212   datetime = NULL;
2213
2214   str = gst_structure_to_string (s);
2215   gst_structure_free (s);
2216   s = NULL;
2217   fail_unless (g_str_equal (str,
2218           "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000001+0200\";"));
2219
2220   g_free (str);
2221   str = NULL;
2222
2223 }
2224
2225 GST_END_TEST;
2226
2227 GST_START_TEST (test_fraction_range)
2228 {
2229   GValue range = { 0, };
2230   GValue start = { 0, };
2231   GValue end = { 0, };
2232   GValue src = { 0, };
2233   GValue dest = { 0, };
2234   GValue range2 = { 0, };
2235
2236   g_value_init (&range, GST_TYPE_FRACTION_RANGE);
2237   g_value_init (&range2, GST_TYPE_FRACTION_RANGE);
2238   g_value_init (&start, GST_TYPE_FRACTION);
2239   g_value_init (&end, GST_TYPE_FRACTION);
2240   g_value_init (&src, GST_TYPE_FRACTION);
2241
2242   gst_value_set_fraction (&src, 1, 2);
2243
2244   /* Check that a intersection of fraction & range = fraction */
2245   gst_value_set_fraction (&start, 1, 4);
2246   gst_value_set_fraction (&end, 2, 3);
2247   gst_value_set_fraction_range (&range, &start, &end);
2248
2249   fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
2250   fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION);
2251   fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
2252
2253   /* Check that a intersection selects the overlapping range */
2254   gst_value_set_fraction (&start, 1, 3);
2255   gst_value_set_fraction (&end, 2, 3);
2256   gst_value_set_fraction_range (&range2, &start, &end);
2257   g_value_unset (&dest);
2258   fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
2259   fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
2260
2261   gst_value_set_fraction_range (&range2, &start, &end);
2262   fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
2263
2264   /* Check that non intersection ranges don't intersect */
2265   gst_value_set_fraction (&start, 4, 2);
2266   gst_value_set_fraction (&end, 5, 2);
2267   gst_value_set_fraction_range (&range2, &start, &end);
2268   g_value_unset (&dest);
2269   fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
2270
2271   g_value_unset (&start);
2272   g_value_unset (&end);
2273   g_value_unset (&range);
2274   g_value_unset (&range2);
2275   g_value_unset (&src);
2276 }
2277
2278 GST_END_TEST;
2279
2280 GST_START_TEST (test_serialize_deserialize_format_enum)
2281 {
2282   GstStructure *s, *s2;
2283   GstFormat foobar_fmt;
2284   gchar *str, *str2, *end = NULL;
2285
2286   /* make sure custom formats are serialised properly as well */
2287   foobar_fmt = gst_format_register ("foobar", "GST_FORMAT_FOOBAR");
2288   fail_unless (foobar_fmt != GST_FORMAT_UNDEFINED);
2289
2290   s = gst_structure_new ("foo/bar", "format1", GST_TYPE_FORMAT,
2291       GST_FORMAT_BYTES, "format2", GST_TYPE_FORMAT, GST_FORMAT_TIME,
2292       "format3", GST_TYPE_FORMAT, GST_FORMAT_DEFAULT, "format4",
2293       GST_TYPE_FORMAT, foobar_fmt, NULL);
2294
2295   str = gst_structure_to_string (s);
2296   GST_LOG ("Got structure string '%s'", GST_STR_NULL (str));
2297   fail_unless (str != NULL);
2298   fail_unless (strstr (str, "TIME") != NULL);
2299   fail_unless (strstr (str, "BYTE") != NULL);
2300   fail_unless (strstr (str, "DEFAULT") != NULL);
2301   fail_unless (strstr (str, "FOOBAR") != NULL);
2302
2303   s2 = gst_structure_from_string (str, &end);
2304   fail_unless (s2 != NULL);
2305
2306   str2 = gst_structure_to_string (s2);
2307   fail_unless (str2 != NULL);
2308
2309   fail_unless (g_str_equal (str, str2));
2310
2311   g_free (str);
2312   g_free (str2);
2313   gst_structure_free (s);
2314   gst_structure_free (s2);
2315 }
2316
2317 GST_END_TEST;
2318
2319 GST_START_TEST (test_serialize_deserialize_caps)
2320 {
2321   GValue value = { 0 }
2322   , value2 = {
2323   0};
2324   GstCaps *caps, *caps2;
2325   gchar *serialized;
2326
2327   caps = gst_caps_new_simple ("test/caps",
2328       "foo", G_TYPE_INT, 10, "bar", G_TYPE_STRING, "test", NULL);
2329   fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
2330
2331   /* and assign caps to gvalue */
2332   g_value_init (&value, GST_TYPE_CAPS);
2333   g_value_take_boxed (&value, caps);
2334   fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
2335
2336   /* now serialize it */
2337   serialized = gst_value_serialize (&value);
2338   GST_DEBUG ("serialized caps to %s", serialized);
2339   fail_unless (serialized != NULL);
2340
2341   /* refcount should not change */
2342   fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
2343
2344   /* now deserialize again */
2345   g_value_init (&value2, GST_TYPE_CAPS);
2346   gst_value_deserialize (&value2, serialized);
2347
2348   caps2 = g_value_get_boxed (&value2);
2349   fail_if (GST_CAPS_REFCOUNT_VALUE (caps2) != 1);
2350
2351   /* they should be equal */
2352   fail_unless (gst_caps_is_equal (caps, caps2));
2353
2354   /* cleanup */
2355   g_value_unset (&value);
2356   g_value_unset (&value2);
2357   g_free (serialized);
2358 }
2359
2360 GST_END_TEST;
2361
2362 GST_START_TEST (test_int_range)
2363 {
2364   GValue range = { 0, };
2365   GValue start = { 0, };
2366   GValue end = { 0, };
2367   GValue src = { 0, };
2368   GValue dest = { 0, };
2369   GValue range2 = { 0, };
2370
2371   g_value_init (&range, GST_TYPE_INT_RANGE);
2372   g_value_init (&range2, GST_TYPE_INT_RANGE);
2373   g_value_init (&start, G_TYPE_INT);
2374   g_value_init (&end, G_TYPE_INT);
2375   g_value_init (&src, G_TYPE_INT);
2376
2377   g_value_set_int (&src, 2);
2378
2379   /* Check that a intersection of int & range = int */
2380   gst_value_set_int_range (&range, 1, 5);
2381
2382   fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
2383   fail_unless (G_VALUE_TYPE (&dest) == G_TYPE_INT);
2384   fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
2385
2386   /* Check that a intersection selects the overlapping range */
2387   gst_value_set_int_range (&range2, 2, 3);
2388   g_value_unset (&dest);
2389   fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
2390   fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
2391
2392   fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
2393
2394   /* Check that non intersection ranges don't intersect */
2395   gst_value_set_int_range (&range2, 6, 7);
2396   g_value_unset (&dest);
2397   fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
2398
2399   g_value_unset (&start);
2400   g_value_unset (&end);
2401   g_value_unset (&range);
2402   g_value_unset (&range2);
2403   g_value_unset (&src);
2404 }
2405
2406 GST_END_TEST;
2407
2408 GST_START_TEST (test_int64_range)
2409 {
2410   GValue range = { 0, };
2411   GValue start = { 0, };
2412   GValue end = { 0, };
2413   GValue src = { 0, };
2414   GValue dest = { 0, };
2415   GValue range2 = { 0, };
2416
2417   g_value_init (&range, GST_TYPE_INT64_RANGE);
2418   g_value_init (&range2, GST_TYPE_INT64_RANGE);
2419   g_value_init (&start, G_TYPE_INT64);
2420   g_value_init (&end, G_TYPE_INT64);
2421   g_value_init (&src, G_TYPE_INT64);
2422
2423   g_value_set_int64 (&src, 2);
2424
2425   /* Check that a intersection of int64 & range = int64 */
2426   gst_value_set_int64_range (&range, 1, 5);
2427
2428   fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
2429   fail_unless (G_VALUE_TYPE (&dest) == G_TYPE_INT64);
2430   fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
2431
2432   /* Check that a intersection selects the overlapping range */
2433   gst_value_set_int64_range (&range2, 2, 3);
2434   g_value_unset (&dest);
2435   fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
2436   fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
2437
2438   fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
2439
2440   /* Check that non intersection ranges don't intersect */
2441   gst_value_set_int64_range (&range2, 6, 7);
2442   g_value_unset (&dest);
2443   fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
2444
2445   g_value_unset (&start);
2446   g_value_unset (&end);
2447   g_value_unset (&range);
2448   g_value_unset (&range2);
2449   g_value_unset (&src);
2450 }
2451
2452 GST_END_TEST;
2453
2454 GST_START_TEST (test_serialize_int64_range)
2455 {
2456   int i = 0;
2457
2458   gint64 int64_ranges[] = {
2459     0, 5,
2460     0, G_MAXINT,
2461     5, G_MAXINT32,
2462     5, G_MAXINT64,
2463   };
2464   gint int64_ranges_size = sizeof (int64_ranges) / sizeof (int64_ranges[0]) / 2;
2465
2466   gchar *int64_range_strings[] = {
2467     g_strdup ("[ 0, 5 ]"),
2468     g_strdup_printf ("[ 0, %" G_GINT64_FORMAT " ]", (gint64) G_MAXINT),
2469     g_strdup_printf ("[ 5, %" G_GINT64_FORMAT " ]", (gint64) G_MAXINT32),
2470     g_strdup_printf ("[ 5, %" G_GINT64_FORMAT " ]", G_MAXINT64),
2471   };
2472   gint int64_range_strings_size =
2473       sizeof (int64_range_strings) / sizeof (int64_range_strings[0]);
2474
2475   fail_unless (int64_ranges_size == int64_range_strings_size);
2476
2477   while (i + 1 < (int64_ranges_size * 2)) {
2478     if ((i + 1) % 2) {
2479       gchar *str;
2480       gchar *str2;
2481       GValue value = { 0 };
2482       const GValue *deserialized_value;
2483       int idx = i / 2;
2484       GstStructure *s;
2485
2486       g_value_init (&value, GST_TYPE_INT64_RANGE);
2487
2488       /* check serialization */
2489       gst_value_set_int64_range (&value, int64_ranges[i], int64_ranges[i + 1]);
2490       str = gst_value_serialize (&value);
2491       fail_unless (strcmp (str, int64_range_strings[idx]) == 0);
2492       g_free (int64_range_strings[idx]);
2493
2494       /* now deserialize again to an int64 range */
2495       s = gst_structure_new ("foo/bar", "range", GST_TYPE_INT64_RANGE,
2496           int64_ranges[i], int64_ranges[i + 1], NULL);
2497       deserialized_value = gst_structure_get_value (s, "range");
2498       fail_unless (GST_VALUE_HOLDS_INT64_RANGE (deserialized_value) == TRUE);
2499       str2 = gst_value_serialize (deserialized_value);
2500
2501       fail_unless (gst_value_get_int64_range_min (deserialized_value) ==
2502           int64_ranges[i]);
2503       fail_unless (gst_value_get_int64_range_max (deserialized_value) ==
2504           int64_ranges[i + 1]);
2505
2506       gst_structure_free (s);
2507       g_free (str);
2508       g_free (str2);
2509     }
2510     i++;
2511   }
2512 }
2513
2514 GST_END_TEST;
2515
2516 GST_START_TEST (test_deserialize_int_range)
2517 {
2518   GstStructure *s;
2519   gchar *str, *str2;
2520   gchar *end = NULL;
2521   const GValue *deserialized_value;
2522
2523   /* check a valid int_range deserialization */
2524   str = g_strdup_printf ("foo/bar, range=[ 1, %d ];", G_MAXINT);
2525   s = gst_structure_from_string (str, &end);
2526   fail_unless (*end == '\0');
2527   deserialized_value = gst_structure_get_value (s, "range");
2528   fail_unless (GST_VALUE_HOLDS_INT_RANGE (deserialized_value) == TRUE);
2529   fail_unless (gst_value_get_int_range_min (deserialized_value) == 1);
2530   fail_unless (gst_value_get_int_range_max (deserialized_value) == G_MAXINT);
2531   gst_structure_free (s);
2532   end = NULL;
2533   g_free (str);
2534
2535   /* check invalid int_range deserialization */
2536   str =
2537       g_strdup_printf ("foo/bar, range=[ 1, %" G_GINT64_FORMAT " ];",
2538       (gint64) G_MAXINT + 1);
2539   ASSERT_CRITICAL (s = gst_structure_from_string (str, &end));
2540   g_free (str);
2541   gst_structure_free (s);
2542   str =
2543       g_strdup_printf ("foo/bar, range=[ %" G_GINT64_FORMAT ", %"
2544       G_GINT64_FORMAT " ];", (gint64) G_MAXINT, (gint64) G_MAXINT + 1);
2545   ASSERT_CRITICAL (s = gst_structure_from_string (str, NULL));
2546   end = NULL;
2547   g_free (str);
2548   gst_structure_free (s);
2549
2550   /* check a valid int64_range deserialization. Those ranges need to
2551    * be explicit about their storage type. */
2552   str = g_strdup_printf ("foo/bar, range=(gint64)[ 1, %d ];", G_MAXINT);
2553   s = gst_structure_from_string (str, &end);
2554   fail_unless (*end == '\0');
2555   deserialized_value = gst_structure_get_value (s, "range");
2556   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (deserialized_value) == TRUE);
2557   fail_unless (gst_value_get_int64_range_min (deserialized_value) == 1);
2558   fail_unless (gst_value_get_int64_range_max (deserialized_value) == G_MAXINT);
2559   str2 = gst_structure_to_string (s);
2560   fail_unless (strcmp (str, str2) == 0);
2561   gst_structure_free (s);
2562   end = NULL;
2563   g_free (str);
2564   g_free (str2);
2565
2566   /* check invalid int64_range (starting with a gint) deserialization */
2567   str =
2568       g_strdup_printf ("foo/bar, range=(gint64)[ 1, %" G_GUINT64_FORMAT " ];",
2569       (guint64) G_MAXINT64 + 1);
2570   ASSERT_CRITICAL (s = gst_structure_from_string (str, &end));
2571   fail_unless (*end == '\0');
2572   gst_structure_free (s);
2573   end = NULL;
2574   g_free (str);
2575
2576   /* check invalid int64_range deserialization into a int64_range */
2577   str =
2578       g_strdup_printf ("foo/bar, range=(gint64)[ %" G_GINT64_FORMAT ", %"
2579       G_GUINT64_FORMAT " ];", (gint64) G_MAXINT, (guint64) G_MAXINT64 + 1);
2580   ASSERT_CRITICAL (s = gst_structure_from_string (str, NULL));
2581   g_free (str);
2582   gst_structure_free (s);
2583
2584   /* check invalid int64_range deserialization into a int_range */
2585   str =
2586       g_strdup_printf ("foo/bar, range=[ %" G_GINT64_FORMAT ", %"
2587       G_GUINT64_FORMAT " ];", (gint64) G_MAXINT, (guint64) G_MAXINT64 + 1);
2588   s = gst_structure_from_string (str, &end);
2589   fail_unless (s == NULL);
2590   fail_unless (end == NULL);
2591   g_free (str);
2592 }
2593
2594 GST_END_TEST static Suite *
2595 gst_value_suite (void)
2596 {
2597   Suite *s = suite_create ("GstValue");
2598   TCase *tc_chain = tcase_create ("general");
2599
2600   suite_add_tcase (s, tc_chain);
2601   tcase_add_test (tc_chain, test_serialize_fourcc);
2602   tcase_add_test (tc_chain, test_deserialize_fourcc);
2603   tcase_add_test (tc_chain, test_deserialize_buffer);
2604   tcase_add_test (tc_chain, test_serialize_buffer);
2605   tcase_add_test (tc_chain, test_deserialize_gint);
2606   tcase_add_test (tc_chain, test_deserialize_gint_failures);
2607   tcase_add_test (tc_chain, test_deserialize_guint);
2608   tcase_add_test (tc_chain, test_deserialize_guint_failures);
2609   tcase_add_test (tc_chain, test_deserialize_gint64);
2610   tcase_add_test (tc_chain, test_deserialize_guint64);
2611   tcase_add_test (tc_chain, test_deserialize_guchar);
2612   tcase_add_test (tc_chain, test_deserialize_gstfraction);
2613   tcase_add_test (tc_chain, test_serialize_flags);
2614   tcase_add_test (tc_chain, test_deserialize_flags);
2615   tcase_add_test (tc_chain, test_serialize_deserialize_format_enum);
2616   tcase_add_test (tc_chain, test_string);
2617   tcase_add_test (tc_chain, test_deserialize_string);
2618   tcase_add_test (tc_chain, test_value_compare);
2619   tcase_add_test (tc_chain, test_value_intersect);
2620   tcase_add_test (tc_chain, test_value_subtract_int);
2621   tcase_add_test (tc_chain, test_value_subtract_int64);
2622   tcase_add_test (tc_chain, test_value_subtract_double);
2623   tcase_add_test (tc_chain, test_value_subtract_fraction);
2624   tcase_add_test (tc_chain, test_value_subtract_fraction_range);
2625   tcase_add_test (tc_chain, test_value_subtract_fraction_list);
2626   tcase_add_test (tc_chain, test_date);
2627   tcase_add_test (tc_chain, test_date_time);
2628   tcase_add_test (tc_chain, test_fraction_range);
2629   tcase_add_test (tc_chain, test_serialize_deserialize_caps);
2630   tcase_add_test (tc_chain, test_int_range);
2631   tcase_add_test (tc_chain, test_int64_range);
2632   tcase_add_test (tc_chain, test_serialize_int64_range);
2633   tcase_add_test (tc_chain, test_deserialize_int_range);
2634
2635   return s;
2636 }
2637
2638 GST_CHECK_MAIN (gst_value);