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 (g_value_get_boxed (&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   gboolean ret = TRUE;
 623
 624   g_value_init (&v, G_TYPE_STRING);
 625   for (i = 0; i < G_N_ELEMENTS (tests); i++) {
 626     if (gst_value_deserialize (&v, tests[i].from)) {
 627       fail_if (tests[i].to == NULL,
 628           "I got %s instead of a failure", g_value_get_string (&v));
 629       fail_unless (g_str_equal (g_value_get_string (&v), tests[i].to),
 630           "\nwanted: %s\ngot    : %s", tests[i].to, g_value_get_string (&v));
 631     } else {
 632       fail_if (tests[i].to != NULL, "failed, but wanted: %s", tests[i].to);
 633       ret = FALSE;
 634     }
 635   }
 636   g_value_unset (&v);
 637 }
 638
 639 GST_END_TEST;
 640
 641 GST_START_TEST (test_value_compare)
 642 {
 643   GValue value1 = { 0 };
 644   GValue value2 = { 0 };
 645   GValue tmp = { 0 };
 646
 647   g_value_init (&value1, G_TYPE_INT);
 648   g_value_set_int (&value1, 10);
 649   g_value_init (&value2, G_TYPE_INT);
 650   g_value_set_int (&value2, 20);
 651   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 652   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 653   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 654   g_value_unset (&value1);
 655   g_value_unset (&value2);
 656
 657   g_value_init (&value1, G_TYPE_DOUBLE);
 658   g_value_set_double (&value1, 10);
 659   g_value_init (&value2, G_TYPE_DOUBLE);
 660   g_value_set_double (&value2, 20);
 661   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 662   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 663   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 664   g_value_unset (&value1);
 665   g_value_unset (&value2);
 666
 667   g_value_init (&value1, G_TYPE_STRING);
 668   g_value_set_string (&value1, "a");
 669   g_value_init (&value2, G_TYPE_STRING);
 670   g_value_set_string (&value2, "b");
 671   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 672   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 673   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 674   /* Test some NULL string comparisons */
 675   g_value_set_string (&value2, NULL);
 676   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
 677   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_UNORDERED);
 678   fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL);
 679
 680   g_value_unset (&value1);
 681   g_value_unset (&value2);
 682
 683   g_value_init (&value1, GST_TYPE_FOURCC);
 684   gst_value_set_fourcc (&value1, GST_MAKE_FOURCC ('a', 'b', 'c', 'd'));
 685   g_value_init (&value2, GST_TYPE_FOURCC);
 686   gst_value_set_fourcc (&value2, GST_MAKE_FOURCC ('1', '2', '3', '4'));
 687   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
 688   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 689   g_value_unset (&value1);
 690   g_value_unset (&value2);
 691
 692   /* comparing 2/3 with 3/4 */
 693   g_value_init (&value1, GST_TYPE_FRACTION);
 694   gst_value_set_fraction (&value1, 2, 3);
 695   g_value_init (&value2, GST_TYPE_FRACTION);
 696   gst_value_set_fraction (&value2, 3, 4);
 697   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 698   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 699   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 700   g_value_unset (&value1);
 701   g_value_unset (&value2);
 702
 703   /* comparing -4/5 with 2/-3 */
 704   g_value_init (&value1, GST_TYPE_FRACTION);
 705   gst_value_set_fraction (&value1, -4, 5);
 706   g_value_init (&value2, GST_TYPE_FRACTION);
 707   gst_value_set_fraction (&value2, 2, -3);
 708   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 709   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 710   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 711   g_value_unset (&value1);
 712   g_value_unset (&value2);
 713
 714   /* comparing 10/100 with 200/2000 */
 715   g_value_init (&value1, GST_TYPE_FRACTION);
 716   gst_value_set_fraction (&value1, 10, 100);
 717   g_value_init (&value2, GST_TYPE_FRACTION);
 718   gst_value_set_fraction (&value2, 200, 2000);
 719   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL);
 720   g_value_unset (&value1);
 721   g_value_unset (&value2);
 722
 723   /* comparing -4/5 with 2/-3 */
 724   g_value_init (&value1, GST_TYPE_FRACTION);
 725   gst_value_set_fraction (&value1, -4, 5);
 726   g_value_init (&value2, GST_TYPE_FRACTION);
 727   gst_value_set_fraction (&value2, 2, -3);
 728   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 729   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 730   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 731   g_value_unset (&value1);
 732   g_value_unset (&value2);
 733
 734   /* Check that lists are equal regardless of order */
 735   g_value_init (&value1, GST_TYPE_LIST);
 736   g_value_init (&tmp, G_TYPE_INT);
 737   g_value_set_int (&tmp, 1);
 738   gst_value_list_append_value (&value1, &tmp);
 739   g_value_set_int (&tmp, 2);
 740   gst_value_list_append_value (&value1, &tmp);
 741   g_value_set_int (&tmp, 3);
 742   gst_value_list_append_value (&value1, &tmp);
 743   g_value_set_int (&tmp, 4);
 744   gst_value_list_append_value (&value1, &tmp);
 745
 746   g_value_init (&value2, GST_TYPE_LIST);
 747   g_value_set_int (&tmp, 4);
 748   gst_value_list_append_value (&value2, &tmp);
 749   g_value_set_int (&tmp, 3);
 750   gst_value_list_append_value (&value2, &tmp);
 751   g_value_set_int (&tmp, 2);
 752   gst_value_list_append_value (&value2, &tmp);
 753   g_value_set_int (&tmp, 1);
 754   gst_value_list_append_value (&value2, &tmp);
 755
 756   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 757       "value lists with different order were not equal when they should be");
 758   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL,
 759       "value lists with same order were not equal when they should be");
 760   fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL,
 761       "value lists with same order were not equal when they should be");
 762
 763   /* Carry over the lists to this next check: */
 764   /* Lists with different sizes are unequal */
 765   g_value_set_int (&tmp, 1);
 766   gst_value_list_append_value (&value2, &tmp);
 767
 768   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 769       "Value lists with different size were equal when they shouldn't be");
 770
 771   /* Carry over the lists to this next check: */
 772   /* Lists with same size but list1 contains one more element not in list2 */
 773   g_value_set_int (&tmp, 5);
 774   gst_value_list_append_value (&value1, &tmp);
 775
 776   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 777       "Value lists with different elements were equal when they shouldn't be");
 778   fail_if (gst_value_compare (&value2, &value1) == GST_VALUE_EQUAL,
 779       "Value lists with different elements were equal when they shouldn't be");
 780
 781   g_value_unset (&value1);
 782   g_value_unset (&value2);
 783   g_value_unset (&tmp);
 784
 785   /* Arrays are only equal when in the same order */
 786   g_value_init (&value1, GST_TYPE_ARRAY);
 787   g_value_init (&tmp, G_TYPE_INT);
 788   g_value_set_int (&tmp, 1);
 789   gst_value_array_append_value (&value1, &tmp);
 790   g_value_set_int (&tmp, 2);
 791   gst_value_array_append_value (&value1, &tmp);
 792   g_value_set_int (&tmp, 3);
 793   gst_value_array_append_value (&value1, &tmp);
 794   g_value_set_int (&tmp, 4);
 795   gst_value_array_append_value (&value1, &tmp);
 796
 797   g_value_init (&value2, GST_TYPE_ARRAY);
 798   g_value_set_int (&tmp, 4);
 799   gst_value_array_append_value (&value2, &tmp);
 800   g_value_set_int (&tmp, 3);
 801   gst_value_array_append_value (&value2, &tmp);
 802   g_value_set_int (&tmp, 2);
 803   gst_value_array_append_value (&value2, &tmp);
 804   g_value_set_int (&tmp, 1);
 805   gst_value_array_append_value (&value2, &tmp);
 806
 807   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 808       "Value arrays with different order were equal when they shouldn't be");
 809   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL,
 810       "Identical value arrays were not equal when they should be");
 811   fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL,
 812       "Identical value arrays were not equal when they should be");
 813
 814   /* Carry over the arrays to this next check: */
 815   /* Arrays with different sizes are unequal */
 816   g_value_unset (&value2);
 817   g_value_init (&value2, GST_TYPE_ARRAY);
 818   g_value_copy (&value1, &value2);
 819
 820   g_value_set_int (&tmp, 1);
 821   gst_value_array_append_value (&value2, &tmp);
 822
 823   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 824       "Value arrays with different size were equal when they shouldn't be");
 825   /* order should not matter */
 826   fail_if (gst_value_compare (&value2, &value1) == GST_VALUE_EQUAL,
 827       "Value arrays with different size were equal when they shouldn't be");
 828
 829   g_value_unset (&value1);
 830   g_value_unset (&value2);
 831   g_value_unset (&tmp);
 832 }
 833
 834 GST_END_TEST;
 835
 836 GST_START_TEST (test_value_intersect)
 837 {
 838   GValue dest = { 0 };
 839   GValue src1 = { 0 };
 840   GValue src2 = { 0 };
 841   GValue item = { 0 };
 842   gboolean ret;
 843
 844   g_value_init (&src1, G_TYPE_INT);
 845   g_value_set_int (&src1, 10);
 846   g_value_init (&src2, G_TYPE_INT);
 847   g_value_set_int (&src2, 20);
 848   ret = gst_value_intersect (&dest, &src1, &src2);
 849   fail_unless (ret == FALSE);
 850   g_value_unset (&src1);
 851   g_value_unset (&src2);
 852
 853   g_value_init (&src1, GST_TYPE_FOURCC);
 854   gst_value_set_fourcc (&src1, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 855   g_value_init (&src2, GST_TYPE_LIST);
 856   g_value_init (&item, GST_TYPE_FOURCC);
 857   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 858   gst_value_list_append_value (&src2, &item);
 859   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('I', '4', '2', '0'));
 860   gst_value_list_append_value (&src2, &item);
 861   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('A', 'B', 'C', 'D'));
 862   gst_value_list_append_value (&src2, &item);
 863
 864   fail_unless (gst_value_intersect (&dest, &src1, &src2));
 865   fail_unless (GST_VALUE_HOLDS_FOURCC (&dest));
 866   fail_unless (gst_value_get_fourcc (&dest) ==
 867       GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 868
 869   g_value_unset (&src1);
 870   g_value_unset (&src2);
 871 }
 872
 873 GST_END_TEST;
 874
 875
 876 GST_START_TEST (test_value_subtract_int)
 877 {
 878   GValue dest = { 0 };
 879   GValue src1 = { 0 };
 880   GValue src2 = { 0 };
 881   const GValue *tmp;
 882   gboolean ret;
 883
 884   /*  int <-> int
 885    */
 886   g_value_init (&src1, G_TYPE_INT);
 887   g_value_set_int (&src1, 10);
 888   g_value_init (&src2, G_TYPE_INT);
 889   g_value_set_int (&src2, 20);
 890   /* subtract as in sets, result is 10 */
 891   ret = gst_value_subtract (&dest, &src1, &src2);
 892   fail_unless (ret == TRUE);
 893   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 894   g_value_unset (&dest);
 895
 896   /* same values, yields empty set */
 897   ret = gst_value_subtract (&dest, &src1, &src1);
 898   fail_unless (ret == FALSE);
 899   g_value_unset (&src1);
 900   g_value_unset (&src2);
 901
 902   /*  int <-> int_range
 903    */
 904
 905   /* would yield an empty set */
 906   g_value_init (&src1, G_TYPE_INT);
 907   g_value_set_int (&src1, 10);
 908   g_value_init (&src2, GST_TYPE_INT_RANGE);
 909   gst_value_set_int_range (&src2, 0, 20);
 910   ret = gst_value_subtract (&dest, &src1, &src2);
 911   fail_unless (ret == FALSE);
 912
 913   /* and the other way around, should create a list of two ranges. */
 914   ret = gst_value_subtract (&dest, &src2, &src1);
 915   fail_unless (ret == TRUE);
 916   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 917   tmp = gst_value_list_get_value (&dest, 0);
 918   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 919   fail_unless (gst_value_get_int_range_min (tmp) == 0);
 920   fail_unless (gst_value_get_int_range_max (tmp) == 9);
 921   tmp = gst_value_list_get_value (&dest, 1);
 922   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 923   fail_unless (gst_value_get_int_range_min (tmp) == 11);
 924   fail_unless (gst_value_get_int_range_max (tmp) == 20);
 925   g_value_unset (&dest);
 926   g_value_unset (&src1);
 927   g_value_unset (&src2);
 928
 929   /* border case 1, empty set */
 930   g_value_init (&src1, G_TYPE_INT);
 931   g_value_set_int (&src1, 10);
 932   g_value_init (&src2, GST_TYPE_INT_RANGE);
 933   gst_value_set_int_range (&src2, 10, 20);
 934   ret = gst_value_subtract (&dest, &src1, &src2);
 935   fail_unless (ret == FALSE);
 936
 937   /* and the other way around, should create a new range. */
 938   ret = gst_value_subtract (&dest, &src2, &src1);
 939   fail_unless (ret == TRUE);
 940   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 941   fail_unless (gst_value_get_int_range_min (&dest) == 11);
 942   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 943   g_value_unset (&dest);
 944   g_value_unset (&src1);
 945   g_value_unset (&src2);
 946
 947   /* border case 2, empty set */
 948   g_value_init (&src1, G_TYPE_INT);
 949   g_value_set_int (&src1, 20);
 950   g_value_init (&src2, GST_TYPE_INT_RANGE);
 951   gst_value_set_int_range (&src2, 10, 20);
 952   ret = gst_value_subtract (&dest, &src1, &src2);
 953   fail_unless (ret == FALSE);
 954
 955   /* and the other way around, should create a new range. */
 956   ret = gst_value_subtract (&dest, &src2, &src1);
 957   fail_unless (ret == TRUE);
 958   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 959   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 960   fail_unless (gst_value_get_int_range_max (&dest) == 19);
 961   g_value_unset (&dest);
 962   g_value_unset (&src1);
 963   g_value_unset (&src2);
 964
 965   /* case 3, valid set */
 966   g_value_init (&src1, G_TYPE_INT);
 967   g_value_set_int (&src1, 0);
 968   g_value_init (&src2, GST_TYPE_INT_RANGE);
 969   gst_value_set_int_range (&src2, 10, 20);
 970   ret = gst_value_subtract (&dest, &src1, &src2);
 971   fail_unless (ret == TRUE);
 972   fail_unless (G_VALUE_HOLDS_INT (&dest) == TRUE);
 973   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 974   g_value_unset (&dest);
 975
 976   /* and the other way around, should keep the range. */
 977   ret = gst_value_subtract (&dest, &src2, &src1);
 978   fail_unless (ret == TRUE);
 979   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 980   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 981   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 982   g_value_unset (&dest);
 983   g_value_unset (&src1);
 984   g_value_unset (&src2);
 985
 986   /*  int_range <-> int_range
 987    */
 988
 989   /* same range, empty set */
 990   g_value_init (&src1, GST_TYPE_INT_RANGE);
 991   gst_value_set_int_range (&src1, 10, 20);
 992   g_value_init (&src2, GST_TYPE_INT_RANGE);
 993   gst_value_set_int_range (&src2, 10, 20);
 994   ret = gst_value_subtract (&dest, &src1, &src2);
 995   fail_unless (ret == FALSE);
 996   ret = gst_value_subtract (&dest, &src2, &src1);
 997   fail_unless (ret == FALSE);
 998   g_value_unset (&src1);
 999   g_value_unset (&src2);
1000
1001   /* non overlapping ranges */
1002   g_value_init (&src1, GST_TYPE_INT_RANGE);
1003   gst_value_set_int_range (&src1, 10, 20);
1004   g_value_init (&src2, GST_TYPE_INT_RANGE);
1005   gst_value_set_int_range (&src2, 30, 40);
1006   ret = gst_value_subtract (&dest, &src1, &src2);
1007   fail_unless (ret == TRUE);
1008   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1009   fail_unless (gst_value_get_int_range_min (&dest) == 10);
1010   fail_unless (gst_value_get_int_range_max (&dest) == 20);
1011   g_value_unset (&dest);
1012   /* the other way */
1013   ret = gst_value_subtract (&dest, &src2, &src1);
1014   fail_unless (ret == TRUE);
1015   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1016   fail_unless (gst_value_get_int_range_min (&dest) == 30);
1017   fail_unless (gst_value_get_int_range_max (&dest) == 40);
1018   g_value_unset (&dest);
1019   g_value_unset (&src1);
1020   g_value_unset (&src2);
1021
1022   /* completely overlapping ranges */
1023   g_value_init (&src1, GST_TYPE_INT_RANGE);
1024   gst_value_set_int_range (&src1, 10, 20);
1025   g_value_init (&src2, GST_TYPE_INT_RANGE);
1026   gst_value_set_int_range (&src2, 10, 30);
1027   ret = gst_value_subtract (&dest, &src1, &src2);
1028   fail_unless (ret == FALSE);
1029   /* the other way */
1030   ret = gst_value_subtract (&dest, &src2, &src1);
1031   fail_unless (ret == TRUE);
1032   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1033   fail_unless (gst_value_get_int_range_min (&dest) == 21);
1034   fail_unless (gst_value_get_int_range_max (&dest) == 30);
1035   g_value_unset (&dest);
1036   g_value_unset (&src1);
1037   g_value_unset (&src2);
1038
1039   /* partially overlapping ranges */
1040   g_value_init (&src1, GST_TYPE_INT_RANGE);
1041   gst_value_set_int_range (&src1, 10, 20);
1042   g_value_init (&src2, GST_TYPE_INT_RANGE);
1043   gst_value_set_int_range (&src2, 15, 30);
1044   ret = gst_value_subtract (&dest, &src1, &src2);
1045   fail_unless (ret == TRUE);
1046   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1047   fail_unless (gst_value_get_int_range_min (&dest) == 10);
1048   fail_unless (gst_value_get_int_range_max (&dest) == 14);
1049   g_value_unset (&dest);
1050   /* the other way */
1051   ret = gst_value_subtract (&dest, &src2, &src1);
1052   fail_unless (ret == TRUE);
1053   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1054   fail_unless (gst_value_get_int_range_min (&dest) == 21);
1055   fail_unless (gst_value_get_int_range_max (&dest) == 30);
1056   g_value_unset (&dest);
1057   g_value_unset (&src1);
1058   g_value_unset (&src2);
1059
1060   /* create a hole { int_range, int_range } */
1061   g_value_init (&src1, GST_TYPE_INT_RANGE);
1062   gst_value_set_int_range (&src1, 10, 30);
1063   g_value_init (&src2, GST_TYPE_INT_RANGE);
1064   gst_value_set_int_range (&src2, 15, 20);
1065   ret = gst_value_subtract (&dest, &src1, &src2);
1066   fail_unless (ret == TRUE);
1067   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1068   tmp = gst_value_list_get_value (&dest, 0);
1069   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1070   fail_unless (gst_value_get_int_range_min (tmp) == 10);
1071   fail_unless (gst_value_get_int_range_max (tmp) == 14);
1072   tmp = gst_value_list_get_value (&dest, 1);
1073   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1074   fail_unless (gst_value_get_int_range_min (tmp) == 21);
1075   fail_unless (gst_value_get_int_range_max (tmp) == 30);
1076   g_value_unset (&dest);
1077   /* the other way */
1078   ret = gst_value_subtract (&dest, &src2, &src1);
1079   fail_unless (ret == FALSE);
1080   g_value_unset (&src1);
1081   g_value_unset (&src2);
1082
1083   /* create a hole, { int, int } */
1084   g_value_init (&src1, GST_TYPE_INT_RANGE);
1085   gst_value_set_int_range (&src1, 10, 30);
1086   g_value_init (&src2, GST_TYPE_INT_RANGE);
1087   gst_value_set_int_range (&src2, 11, 29);
1088   ret = gst_value_subtract (&dest, &src1, &src2);
1089   fail_unless (ret == TRUE);
1090   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1091   tmp = gst_value_list_get_value (&dest, 0);
1092   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1093   fail_unless (g_value_get_int (tmp) == 10);
1094   tmp = gst_value_list_get_value (&dest, 1);
1095   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1096   fail_unless (g_value_get_int (tmp) == 30);
1097   g_value_unset (&dest);
1098   /* the other way */
1099   ret = gst_value_subtract (&dest, &src2, &src1);
1100   fail_unless (ret == FALSE);
1101   g_value_unset (&src1);
1102   g_value_unset (&src2);
1103
1104   /* create a hole, { int, int_range } */
1105   g_value_init (&src1, GST_TYPE_INT_RANGE);
1106   gst_value_set_int_range (&src1, 10, 30);
1107   g_value_init (&src2, GST_TYPE_INT_RANGE);
1108   gst_value_set_int_range (&src2, 11, 28);
1109   ret = gst_value_subtract (&dest, &src1, &src2);
1110   fail_unless (ret == TRUE);
1111   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1112   tmp = gst_value_list_get_value (&dest, 0);
1113   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1114   fail_unless (g_value_get_int (tmp) == 10);
1115   tmp = gst_value_list_get_value (&dest, 1);
1116   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1117   fail_unless (gst_value_get_int_range_min (tmp) == 29);
1118   fail_unless (gst_value_get_int_range_max (tmp) == 30);
1119   g_value_unset (&dest);
1120   /* the other way */
1121   ret = gst_value_subtract (&dest, &src2, &src1);
1122   fail_unless (ret == FALSE);
1123   g_value_unset (&src1);
1124   g_value_unset (&src2);
1125
1126   /* create a hole, { int_range, int } */
1127   g_value_init (&src1, GST_TYPE_INT_RANGE);
1128   gst_value_set_int_range (&src1, 10, 30);
1129   g_value_init (&src2, GST_TYPE_INT_RANGE);
1130   gst_value_set_int_range (&src2, 12, 29);
1131   ret = gst_value_subtract (&dest, &src1, &src2);
1132   fail_unless (ret == TRUE);
1133   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1134   tmp = gst_value_list_get_value (&dest, 0);
1135   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1136   fail_unless (gst_value_get_int_range_min (tmp) == 10);
1137   fail_unless (gst_value_get_int_range_max (tmp) == 11);
1138   tmp = gst_value_list_get_value (&dest, 1);
1139   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1140   fail_unless (g_value_get_int (tmp) == 30);
1141   g_value_unset (&dest);
1142   /* the other way */
1143   ret = gst_value_subtract (&dest, &src2, &src1);
1144   fail_unless (ret == FALSE);
1145   g_value_unset (&src1);
1146   g_value_unset (&src2);
1147 }
1148
1149 GST_END_TEST;
1150
1151 GST_START_TEST (test_value_subtract_int64)
1152 {
1153   GValue dest = { 0 };
1154   GValue src1 = { 0 };
1155   GValue src2 = { 0 };
1156   const GValue *tmp;
1157   gboolean ret;
1158
1159   /*  int64 <-> int64
1160    */
1161   g_value_init (&src1, G_TYPE_INT64);
1162   g_value_set_int64 (&src1, 10);
1163   g_value_init (&src2, G_TYPE_INT64);
1164   g_value_set_int64 (&src2, 20);
1165   /* subtract as in sets, result is 10 */
1166   ret = gst_value_subtract (&dest, &src1, &src2);
1167   fail_unless (ret == TRUE);
1168   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1169   g_value_unset (&dest);
1170
1171   /* same values, yields empty set */
1172   ret = gst_value_subtract (&dest, &src1, &src1);
1173   fail_unless (ret == FALSE);
1174   g_value_unset (&src1);
1175   g_value_unset (&src2);
1176
1177   /*  int64 <-> int64_range
1178    */
1179
1180   /* would yield an empty set */
1181   g_value_init (&src1, G_TYPE_INT64);
1182   g_value_set_int64 (&src1, 10);
1183   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1184   gst_value_set_int64_range (&src2, 0, 20);
1185   ret = gst_value_subtract (&dest, &src1, &src2);
1186   fail_unless (ret == FALSE);
1187
1188   /* and the other way around, should create a list of two ranges. */
1189   ret = gst_value_subtract (&dest, &src2, &src1);
1190   fail_unless (ret == TRUE);
1191   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1192   tmp = gst_value_list_get_value (&dest, 0);
1193   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1194   fail_unless (gst_value_get_int64_range_min (tmp) == 0);
1195   fail_unless (gst_value_get_int64_range_max (tmp) == 9);
1196   tmp = gst_value_list_get_value (&dest, 1);
1197   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1198   fail_unless (gst_value_get_int64_range_min (tmp) == 11);
1199   fail_unless (gst_value_get_int64_range_max (tmp) == 20);
1200   g_value_unset (&dest);
1201   g_value_unset (&src1);
1202   g_value_unset (&src2);
1203
1204   /* border case 1, empty set */
1205   g_value_init (&src1, G_TYPE_INT64);
1206   g_value_set_int64 (&src1, 10);
1207   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1208   gst_value_set_int64_range (&src2, 10, 20);
1209   ret = gst_value_subtract (&dest, &src1, &src2);
1210   fail_unless (ret == FALSE);
1211
1212   /* and the other way around, should create a new range. */
1213   ret = gst_value_subtract (&dest, &src2, &src1);
1214   fail_unless (ret == TRUE);
1215   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1216   fail_unless (gst_value_get_int64_range_min (&dest) == 11);
1217   fail_unless (gst_value_get_int64_range_max (&dest) == 20);
1218   g_value_unset (&dest);
1219   g_value_unset (&src1);
1220   g_value_unset (&src2);
1221
1222   /* border case 2, empty set */
1223   g_value_init (&src1, G_TYPE_INT64);
1224   g_value_set_int64 (&src1, 20);
1225   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1226   gst_value_set_int64_range (&src2, 10, 20);
1227   ret = gst_value_subtract (&dest, &src1, &src2);
1228   fail_unless (ret == FALSE);
1229
1230   /* and the other way around, should create a new range. */
1231   ret = gst_value_subtract (&dest, &src2, &src1);
1232   fail_unless (ret == TRUE);
1233   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1234   fail_unless (gst_value_get_int64_range_min (&dest) == 10);
1235   fail_unless (gst_value_get_int64_range_max (&dest) == 19);
1236   g_value_unset (&dest);
1237   g_value_unset (&src1);
1238   g_value_unset (&src2);
1239
1240   /* case 3, valid set */
1241   g_value_init (&src1, G_TYPE_INT64);
1242   g_value_set_int64 (&src1, 0);
1243   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1244   gst_value_set_int64_range (&src2, 10, 20);
1245   ret = gst_value_subtract (&dest, &src1, &src2);
1246   fail_unless (ret == TRUE);
1247   fail_unless (G_VALUE_HOLDS_INT64 (&dest) == TRUE);
1248   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1249   g_value_unset (&dest);
1250
1251   /* and the other way around, should keep the range. */
1252   ret = gst_value_subtract (&dest, &src2, &src1);
1253   fail_unless (ret == TRUE);
1254   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1255   fail_unless (gst_value_get_int64_range_min (&dest) == 10);
1256   fail_unless (gst_value_get_int64_range_max (&dest) == 20);
1257   g_value_unset (&dest);
1258   g_value_unset (&src1);
1259   g_value_unset (&src2);
1260
1261   /*  int64_range <-> int64_range
1262    */
1263
1264   /* same range, empty set */
1265   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1266   gst_value_set_int64_range (&src1, 10, 20);
1267   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1268   gst_value_set_int64_range (&src2, 10, 20);
1269   ret = gst_value_subtract (&dest, &src1, &src2);
1270   fail_unless (ret == FALSE);
1271   ret = gst_value_subtract (&dest, &src2, &src1);
1272   fail_unless (ret == FALSE);
1273   g_value_unset (&src1);
1274   g_value_unset (&src2);
1275
1276   /* non overlapping ranges */
1277   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1278   gst_value_set_int64_range (&src1, 10, 20);
1279   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1280   gst_value_set_int64_range (&src2, 30, 40);
1281   ret = gst_value_subtract (&dest, &src1, &src2);
1282   fail_unless (ret == TRUE);
1283   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1284   fail_unless (gst_value_get_int64_range_min (&dest) == 10);
1285   fail_unless (gst_value_get_int64_range_max (&dest) == 20);
1286   g_value_unset (&dest);
1287   /* the other way */
1288   ret = gst_value_subtract (&dest, &src2, &src1);
1289   fail_unless (ret == TRUE);
1290   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1291   fail_unless (gst_value_get_int64_range_min (&dest) == 30);
1292   fail_unless (gst_value_get_int64_range_max (&dest) == 40);
1293   g_value_unset (&dest);
1294   g_value_unset (&src1);
1295   g_value_unset (&src2);
1296
1297   /* completely overlapping ranges */
1298   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1299   gst_value_set_int64_range (&src1, 10, 20);
1300   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1301   gst_value_set_int64_range (&src2, 10, 30);
1302   ret = gst_value_subtract (&dest, &src1, &src2);
1303   fail_unless (ret == FALSE);
1304   /* the other way */
1305   ret = gst_value_subtract (&dest, &src2, &src1);
1306   fail_unless (ret == TRUE);
1307   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1308   fail_unless (gst_value_get_int64_range_min (&dest) == 21);
1309   fail_unless (gst_value_get_int64_range_max (&dest) == 30);
1310   g_value_unset (&dest);
1311   g_value_unset (&src1);
1312   g_value_unset (&src2);
1313
1314   /* partially overlapping ranges */
1315   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1316   gst_value_set_int64_range (&src1, 10, 20);
1317   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1318   gst_value_set_int64_range (&src2, 15, 30);
1319   ret = gst_value_subtract (&dest, &src1, &src2);
1320   fail_unless (ret == TRUE);
1321   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1322   fail_unless (gst_value_get_int64_range_min (&dest) == 10);
1323   fail_unless (gst_value_get_int64_range_max (&dest) == 14);
1324   g_value_unset (&dest);
1325   /* the other way */
1326   ret = gst_value_subtract (&dest, &src2, &src1);
1327   fail_unless (ret == TRUE);
1328   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1329   fail_unless (gst_value_get_int64_range_min (&dest) == 21);
1330   fail_unless (gst_value_get_int64_range_max (&dest) == 30);
1331   g_value_unset (&dest);
1332   g_value_unset (&src1);
1333   g_value_unset (&src2);
1334
1335   /* create a hole { int64_range, int64_range } */
1336   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1337   gst_value_set_int64_range (&src1, 10, 30);
1338   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1339   gst_value_set_int64_range (&src2, 15, 20);
1340   ret = gst_value_subtract (&dest, &src1, &src2);
1341   fail_unless (ret == TRUE);
1342   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1343   tmp = gst_value_list_get_value (&dest, 0);
1344   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1345   fail_unless (gst_value_get_int64_range_min (tmp) == 10);
1346   fail_unless (gst_value_get_int64_range_max (tmp) == 14);
1347   tmp = gst_value_list_get_value (&dest, 1);
1348   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1349   fail_unless (gst_value_get_int64_range_min (tmp) == 21);
1350   fail_unless (gst_value_get_int64_range_max (tmp) == 30);
1351   g_value_unset (&dest);
1352   /* the other way */
1353   ret = gst_value_subtract (&dest, &src2, &src1);
1354   fail_unless (ret == FALSE);
1355   g_value_unset (&src1);
1356   g_value_unset (&src2);
1357
1358   /* create a hole, { int64, int64 } */
1359   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1360   gst_value_set_int64_range (&src1, 10, 30);
1361   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1362   gst_value_set_int64_range (&src2, 11, 29);
1363   ret = gst_value_subtract (&dest, &src1, &src2);
1364   fail_unless (ret == TRUE);
1365   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1366   tmp = gst_value_list_get_value (&dest, 0);
1367   fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
1368   fail_unless (g_value_get_int64 (tmp) == 10);
1369   tmp = gst_value_list_get_value (&dest, 1);
1370   fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
1371   fail_unless (g_value_get_int64 (tmp) == 30);
1372   g_value_unset (&dest);
1373   /* the other way */
1374   ret = gst_value_subtract (&dest, &src2, &src1);
1375   fail_unless (ret == FALSE);
1376   g_value_unset (&src1);
1377   g_value_unset (&src2);
1378
1379   /* create a hole, { int64, int64_range } */
1380   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1381   gst_value_set_int64_range (&src1, 10, 30);
1382   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1383   gst_value_set_int64_range (&src2, 11, 28);
1384   ret = gst_value_subtract (&dest, &src1, &src2);
1385   fail_unless (ret == TRUE);
1386   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1387   tmp = gst_value_list_get_value (&dest, 0);
1388   fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
1389   fail_unless (g_value_get_int64 (tmp) == 10);
1390   tmp = gst_value_list_get_value (&dest, 1);
1391   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1392   fail_unless (gst_value_get_int64_range_min (tmp) == 29);
1393   fail_unless (gst_value_get_int64_range_max (tmp) == 30);
1394   g_value_unset (&dest);
1395   /* the other way */
1396   ret = gst_value_subtract (&dest, &src2, &src1);
1397   fail_unless (ret == FALSE);
1398   g_value_unset (&src1);
1399   g_value_unset (&src2);
1400
1401   /* create a hole, { int64_range, int64 } */
1402   g_value_init (&src1, GST_TYPE_INT64_RANGE);
1403   gst_value_set_int64_range (&src1, 10, 30);
1404   g_value_init (&src2, GST_TYPE_INT64_RANGE);
1405   gst_value_set_int64_range (&src2, 12, 29);
1406   ret = gst_value_subtract (&dest, &src1, &src2);
1407   fail_unless (ret == TRUE);
1408   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1409   tmp = gst_value_list_get_value (&dest, 0);
1410   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1411   fail_unless (gst_value_get_int64_range_min (tmp) == 10);
1412   fail_unless (gst_value_get_int64_range_max (tmp) == 11);
1413   tmp = gst_value_list_get_value (&dest, 1);
1414   fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
1415   fail_unless (g_value_get_int64 (tmp) == 30);
1416   g_value_unset (&dest);
1417   /* the other way */
1418   ret = gst_value_subtract (&dest, &src2, &src1);
1419   fail_unless (ret == FALSE);
1420   g_value_unset (&src1);
1421   g_value_unset (&src2);
1422 }
1423
1424 GST_END_TEST;
1425
1426 GST_START_TEST (test_value_subtract_double)
1427 {
1428   GValue dest = { 0 };
1429   GValue src1 = { 0 };
1430   GValue src2 = { 0 };
1431   const GValue *tmp;
1432   gboolean ret;
1433
1434   /*  double <-> double
1435    */
1436   g_value_init (&src1, G_TYPE_DOUBLE);
1437   g_value_set_double (&src1, 10.0);
1438   g_value_init (&src2, G_TYPE_DOUBLE);
1439   g_value_set_double (&src2, 20.0);
1440   /* subtract as in sets, result is 10 */
1441   ret = gst_value_subtract (&dest, &src1, &src2);
1442   fail_unless (ret == TRUE);
1443   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1444   g_value_unset (&dest);
1445
1446   /* same values, yields empty set */
1447   ret = gst_value_subtract (&dest, &src1, &src1);
1448   fail_unless (ret == FALSE);
1449   g_value_unset (&src1);
1450   g_value_unset (&src2);
1451
1452   /*  double <-> double_range
1453    */
1454
1455   /* would yield an empty set */
1456   g_value_init (&src1, G_TYPE_DOUBLE);
1457   g_value_set_double (&src1, 10.0);
1458   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1459   gst_value_set_double_range (&src2, 0.0, 20.0);
1460   ret = gst_value_subtract (&dest, &src1, &src2);
1461   fail_unless (ret == FALSE);
1462
1463   /* and the other way around, we cannot create open ranges
1464    * so the result is the range again */
1465   ret = gst_value_subtract (&dest, &src2, &src1);
1466   fail_unless (ret == TRUE);
1467   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1468   fail_unless (gst_value_get_double_range_min (&dest) == 0.0);
1469   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1470   g_value_unset (&dest);
1471   g_value_unset (&src1);
1472   g_value_unset (&src2);
1473
1474   /* border case 1, empty set */
1475   g_value_init (&src1, G_TYPE_DOUBLE);
1476   g_value_set_double (&src1, 10.0);
1477   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1478   gst_value_set_double_range (&src2, 10.0, 20.0);
1479   ret = gst_value_subtract (&dest, &src1, &src2);
1480   fail_unless (ret == FALSE);
1481
1482   /* and the other way around, should keep same range as
1483    * we don't have open ranges. */
1484   ret = gst_value_subtract (&dest, &src2, &src1);
1485   fail_unless (ret == TRUE);
1486   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1487   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1488   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1489   g_value_unset (&dest);
1490   g_value_unset (&src1);
1491   g_value_unset (&src2);
1492
1493   /* border case 2, empty set */
1494   g_value_init (&src1, G_TYPE_DOUBLE);
1495   g_value_set_double (&src1, 20.0);
1496   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1497   gst_value_set_double_range (&src2, 10.0, 20.0);
1498   ret = gst_value_subtract (&dest, &src1, &src2);
1499   fail_unless (ret == FALSE);
1500
1501   /* and the other way around, should keep same range as
1502    * we don't have open ranges. */
1503   ret = gst_value_subtract (&dest, &src2, &src1);
1504   fail_unless (ret == TRUE);
1505   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1506   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1507   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1508   g_value_unset (&dest);
1509   g_value_unset (&src1);
1510   g_value_unset (&src2);
1511
1512   /* case 3, valid set */
1513   g_value_init (&src1, G_TYPE_DOUBLE);
1514   g_value_set_double (&src1, 0.0);
1515   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1516   gst_value_set_double_range (&src2, 10.0, 20.0);
1517   ret = gst_value_subtract (&dest, &src1, &src2);
1518   fail_unless (ret == TRUE);
1519   fail_unless (G_VALUE_HOLDS_DOUBLE (&dest) == TRUE);
1520   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1521   g_value_unset (&dest);
1522
1523   /* and the other way around, should keep the range. */
1524   ret = gst_value_subtract (&dest, &src2, &src1);
1525   fail_unless (ret == TRUE);
1526   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1527   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1528   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1529   g_value_unset (&dest);
1530   g_value_unset (&src1);
1531   g_value_unset (&src2);
1532
1533   /*  double_range <-> double_range
1534    */
1535
1536   /* same range, empty set */
1537   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1538   gst_value_set_double_range (&src1, 10.0, 20.0);
1539   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1540   gst_value_set_double_range (&src2, 10.0, 20.0);
1541   ret = gst_value_subtract (&dest, &src1, &src2);
1542   fail_unless (ret == FALSE);
1543   ret = gst_value_subtract (&dest, &src2, &src1);
1544   fail_unless (ret == FALSE);
1545   g_value_unset (&src1);
1546   g_value_unset (&src2);
1547
1548   /* non overlapping ranges */
1549   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1550   gst_value_set_double_range (&src1, 10.0, 20.0);
1551   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1552   gst_value_set_double_range (&src2, 30.0, 40.0);
1553   ret = gst_value_subtract (&dest, &src1, &src2);
1554   fail_unless (ret == TRUE);
1555   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1556   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1557   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1558   g_value_unset (&dest);
1559   /* the other way */
1560   ret = gst_value_subtract (&dest, &src2, &src1);
1561   fail_unless (ret == TRUE);
1562   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1563   fail_unless (gst_value_get_double_range_min (&dest) == 30.0);
1564   fail_unless (gst_value_get_double_range_max (&dest) == 40.0);
1565   g_value_unset (&dest);
1566   g_value_unset (&src1);
1567   g_value_unset (&src2);
1568
1569   /* completely overlapping ranges */
1570   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1571   gst_value_set_double_range (&src1, 10.0, 20.0);
1572   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1573   gst_value_set_double_range (&src2, 10.0, 30.0);
1574   ret = gst_value_subtract (&dest, &src1, &src2);
1575   fail_unless (ret == FALSE);
1576   /* the other way */
1577   ret = gst_value_subtract (&dest, &src2, &src1);
1578   fail_unless (ret == TRUE);
1579   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1580   fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
1581   fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
1582   g_value_unset (&dest);
1583   g_value_unset (&src1);
1584   g_value_unset (&src2);
1585
1586   /* partially overlapping ranges */
1587   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1588   gst_value_set_double_range (&src1, 10.0, 20.0);
1589   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1590   gst_value_set_double_range (&src2, 15.0, 30.0);
1591   ret = gst_value_subtract (&dest, &src1, &src2);
1592   fail_unless (ret == TRUE);
1593   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1594   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1595   fail_unless (gst_value_get_double_range_max (&dest) == 15.0);
1596   g_value_unset (&dest);
1597   /* the other way */
1598   ret = gst_value_subtract (&dest, &src2, &src1);
1599   fail_unless (ret == TRUE);
1600   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1601   fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
1602   fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
1603   g_value_unset (&dest);
1604   g_value_unset (&src1);
1605   g_value_unset (&src2);
1606
1607   /* create a hole { double_range, double_range } */
1608   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1609   gst_value_set_double_range (&src1, 10.0, 30.0);
1610   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1611   gst_value_set_double_range (&src2, 15.0, 20.0);
1612   ret = gst_value_subtract (&dest, &src1, &src2);
1613   fail_unless (ret == TRUE);
1614   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1615   tmp = gst_value_list_get_value (&dest, 0);
1616   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
1617   fail_unless (gst_value_get_double_range_min (tmp) == 10.0);
1618   fail_unless (gst_value_get_double_range_max (tmp) == 15.0);
1619   tmp = gst_value_list_get_value (&dest, 1);
1620   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
1621   fail_unless (gst_value_get_double_range_min (tmp) == 20.0);
1622   fail_unless (gst_value_get_double_range_max (tmp) == 30.0);
1623   g_value_unset (&dest);
1624   /* the other way */
1625   ret = gst_value_subtract (&dest, &src2, &src1);
1626   fail_unless (ret == FALSE);
1627   g_value_unset (&src1);
1628   g_value_unset (&src2);
1629 }
1630
1631 GST_END_TEST;
1632
1633 /* Test arithmetic subtraction of fractions */
1634 GST_START_TEST (test_value_subtract_fraction)
1635 {
1636   GValue result = { 0 };
1637   GValue src1 = { 0 };
1638   GValue src2 = { 0 };
1639
1640   /* Subtract 1/4 from 1/2 */
1641   g_value_init (&src1, GST_TYPE_FRACTION);
1642   g_value_init (&src2, GST_TYPE_FRACTION);
1643   g_value_init (&result, GST_TYPE_FRACTION);
1644   gst_value_set_fraction (&src1, 1, 2);
1645   gst_value_set_fraction (&src2, 1, 4);
1646   fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1647   fail_unless (gst_value_get_fraction_numerator (&result) == 1);
1648   fail_unless (gst_value_get_fraction_denominator (&result) == 4);
1649
1650   g_value_unset (&src1);
1651   g_value_unset (&src2);
1652   g_value_unset (&result);
1653
1654   /* Subtract 1/12 from 7/8 */
1655   g_value_init (&src1, GST_TYPE_FRACTION);
1656   g_value_init (&src2, GST_TYPE_FRACTION);
1657   g_value_init (&result, GST_TYPE_FRACTION);
1658   gst_value_set_fraction (&src1, 7, 8);
1659   gst_value_set_fraction (&src2, 1, 12);
1660   fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1661   fail_unless (gst_value_get_fraction_numerator (&result) == 19);
1662   fail_unless (gst_value_get_fraction_denominator (&result) == 24);
1663
1664   g_value_unset (&src1);
1665   g_value_unset (&src2);
1666   g_value_unset (&result);
1667
1668   /* Subtract 12/13 from 4/3 */
1669   g_value_init (&src1, GST_TYPE_FRACTION);
1670   g_value_init (&src2, GST_TYPE_FRACTION);
1671   g_value_init (&result, GST_TYPE_FRACTION);
1672   gst_value_set_fraction (&src1, 4, 3);
1673   gst_value_set_fraction (&src2, 12, 13);
1674   fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1675   fail_unless (gst_value_get_fraction_numerator (&result) == 16);
1676   fail_unless (gst_value_get_fraction_denominator (&result) == 39);
1677
1678   g_value_unset (&src1);
1679   g_value_unset (&src2);
1680   g_value_unset (&result);
1681
1682   /* Subtract 1/12 from 7/8 */
1683 }
1684
1685 GST_END_TEST;
1686
1687 /* Test set subtraction operations on fraction ranges */
1688 GST_START_TEST (test_value_subtract_fraction_range)
1689 {
1690   GValue dest = { 0 };
1691   GValue src1 = { 0 };
1692   GValue src2 = { 0 };
1693   GValue cmp = { 0 };
1694   const GValue *tmp;
1695   gboolean ret;
1696
1697   /* Value for tests */
1698   g_value_init (&cmp, GST_TYPE_FRACTION);
1699
1700   /*  fraction <-> fraction
1701    */
1702   g_value_init (&src1, GST_TYPE_FRACTION);
1703   gst_value_set_fraction (&src1, 10, 1);
1704   g_value_init (&src2, GST_TYPE_FRACTION);
1705   gst_value_set_fraction (&src2, 20, 1);
1706   gst_value_set_fraction (&src1, 10, 1);
1707
1708   /* subtract as in sets, result is 10 */
1709   ret = gst_value_subtract (&dest, &src1, &src2);
1710   fail_unless (ret == TRUE);
1711   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1712   g_value_unset (&dest);
1713
1714   /* same values, yields empty set */
1715   ret = gst_value_subtract (&dest, &src1, &src1);
1716   fail_unless (ret == FALSE);
1717   g_value_unset (&src1);
1718   g_value_unset (&src2);
1719
1720   /*  fraction <-> fraction_range
1721    */
1722
1723   /* would yield an empty set */
1724   g_value_init (&src1, GST_TYPE_FRACTION);
1725   gst_value_set_fraction (&src1, 10, 1);
1726   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1727   gst_value_set_fraction_range_full (&src2, 0, 1, 20, 1);
1728   ret = gst_value_subtract (&dest, &src1, &src2);
1729   fail_unless (ret == FALSE);
1730
1731   /* and the other way around, we cannot create open ranges
1732    * so the result is the range again */
1733   ret = gst_value_subtract (&dest, &src2, &src1);
1734   fail_unless (ret == TRUE);
1735   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1736   gst_value_set_fraction (&cmp, 0, 1);
1737   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1738           &cmp) == GST_VALUE_EQUAL);
1739   gst_value_set_fraction (&cmp, 20, 1);
1740   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1741           &cmp) == GST_VALUE_EQUAL);
1742   g_value_unset (&dest);
1743   g_value_unset (&src1);
1744   g_value_unset (&src2);
1745
1746   /* border case 1, empty set */
1747   g_value_init (&src1, GST_TYPE_FRACTION);
1748   gst_value_set_fraction (&src1, 10, 1);
1749   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1750   gst_value_set_fraction_range_full (&src2, 10, 1, 20, 1);
1751   ret = gst_value_subtract (&dest, &src1, &src2);
1752   fail_unless (ret == FALSE);
1753
1754   /* and the other way around, should keep same range as
1755    * we don't have open ranges. */
1756   ret = gst_value_subtract (&dest, &src2, &src1);
1757   fail_unless (ret == TRUE);
1758   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1759   gst_value_set_fraction (&cmp, 10, 1);
1760   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1761           &cmp) == GST_VALUE_EQUAL);
1762   gst_value_set_fraction (&cmp, 20, 1);
1763   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1764           &cmp) == GST_VALUE_EQUAL);
1765   g_value_unset (&dest);
1766   g_value_unset (&src1);
1767   g_value_unset (&src2);
1768
1769   /* case 2, valid set */
1770   g_value_init (&src1, GST_TYPE_FRACTION);
1771   gst_value_set_fraction (&src1, 0, 1);
1772   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1773   gst_value_set_fraction_range_full (&src2, 10, 1, 20, 1);
1774   ret = gst_value_subtract (&dest, &src1, &src2);
1775   fail_unless (ret == TRUE);
1776   fail_unless (GST_VALUE_HOLDS_FRACTION (&dest) == TRUE);
1777   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1778   g_value_unset (&dest);
1779
1780   /* and the other way around, should keep the range. */
1781   ret = gst_value_subtract (&dest, &src2, &src1);
1782   fail_unless (ret == TRUE);
1783   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1784   fail_unless (gst_value_compare (&dest, &src2) == GST_VALUE_EQUAL);
1785   g_value_unset (&dest);
1786   g_value_unset (&src1);
1787   g_value_unset (&src2);
1788
1789   /*  fraction_range <-> fraction_range
1790    */
1791
1792   /* same range, empty set */
1793   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1794   gst_value_set_fraction_range_full (&src1, 10, 2, 20, 2);
1795   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1796   gst_value_set_fraction_range_full (&src2, 10, 2, 20, 2);
1797   ret = gst_value_subtract (&dest, &src1, &src2);
1798   fail_unless (ret == FALSE);
1799   ret = gst_value_subtract (&dest, &src2, &src1);
1800   fail_unless (ret == FALSE);
1801   g_value_unset (&src1);
1802   g_value_unset (&src2);
1803
1804   /* non overlapping ranges */
1805   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1806   gst_value_set_fraction_range_full (&src1, 10, 2, 10, 1);
1807   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1808   gst_value_set_fraction_range_full (&src2, 30, 2, 40, 2);
1809   ret = gst_value_subtract (&dest, &src1, &src2);
1810   fail_unless (ret == TRUE);
1811   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1812   gst_value_set_fraction (&cmp, 5, 1);
1813   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1814           &cmp) == GST_VALUE_EQUAL);
1815   gst_value_set_fraction (&cmp, 10, 1);
1816   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1817           &cmp) == GST_VALUE_EQUAL);
1818
1819   g_value_unset (&dest);
1820   /* the other way */
1821   ret = gst_value_subtract (&dest, &src2, &src1);
1822   fail_unless (ret == TRUE);
1823   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1824   gst_value_set_fraction (&cmp, 15, 1);
1825   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1826           &cmp) == GST_VALUE_EQUAL);
1827   gst_value_set_fraction (&cmp, 20, 1);
1828   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1829           &cmp) == GST_VALUE_EQUAL);
1830   g_value_unset (&dest);
1831   g_value_unset (&src1);
1832   g_value_unset (&src2);
1833
1834   /* completely overlapping ranges */
1835   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1836   gst_value_set_fraction_range_full (&src1, 10, 1, 20, 1);
1837   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1838   gst_value_set_fraction_range_full (&src2, 10, 1, 30, 1);
1839   ret = gst_value_subtract (&dest, &src1, &src2);
1840   fail_unless (ret == FALSE);
1841   /* the other way */
1842   ret = gst_value_subtract (&dest, &src2, &src1);
1843   fail_unless (ret == TRUE);
1844   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1845   gst_value_set_fraction (&cmp, 20, 1);
1846   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1847           &cmp) == GST_VALUE_EQUAL);
1848   gst_value_set_fraction (&cmp, 30, 1);
1849   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1850           &cmp) == GST_VALUE_EQUAL);
1851   g_value_unset (&dest);
1852   g_value_unset (&src1);
1853   g_value_unset (&src2);
1854
1855   /* partially overlapping ranges */
1856   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1857   gst_value_set_fraction_range_full (&src1, 10, 1, 20, 1);
1858   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1859   gst_value_set_fraction_range_full (&src2, 15, 1, 30, 1);
1860   ret = gst_value_subtract (&dest, &src1, &src2);
1861   fail_unless (ret == TRUE);
1862   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1863   gst_value_set_fraction (&cmp, 10, 1);
1864   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1865           &cmp) == GST_VALUE_EQUAL);
1866   gst_value_set_fraction (&cmp, 15, 1);
1867   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1868           &cmp) == GST_VALUE_EQUAL);
1869   g_value_unset (&dest);
1870
1871   /* the other way */
1872   ret = gst_value_subtract (&dest, &src2, &src1);
1873   fail_unless (ret == TRUE);
1874   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1875   gst_value_set_fraction (&cmp, 20, 1);
1876   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1877           &cmp) == GST_VALUE_EQUAL);
1878   gst_value_set_fraction (&cmp, 30, 1);
1879   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1880           &cmp) == GST_VALUE_EQUAL);
1881   g_value_unset (&dest);
1882   g_value_unset (&src1);
1883   g_value_unset (&src2);
1884
1885   /* create a hole { double_range, double_range } */
1886   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1887   gst_value_set_fraction_range_full (&src1, 10, 1, 30, 1);
1888   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1889   gst_value_set_fraction_range_full (&src2, 15, 1, 20, 1);
1890   ret = gst_value_subtract (&dest, &src1, &src2);
1891   fail_unless (ret == TRUE);
1892   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1893   /* 1st list entry */
1894   tmp = gst_value_list_get_value (&dest, 0);
1895   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (tmp) == TRUE);
1896   gst_value_set_fraction (&cmp, 10, 1);
1897   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (tmp),
1898           &cmp) == GST_VALUE_EQUAL);
1899   gst_value_set_fraction (&cmp, 15, 1);
1900   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (tmp),
1901           &cmp) == GST_VALUE_EQUAL);
1902   /* 2nd list entry */
1903   tmp = gst_value_list_get_value (&dest, 1);
1904   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (tmp) == TRUE);
1905   gst_value_set_fraction (&cmp, 20, 1);
1906   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (tmp),
1907           &cmp) == GST_VALUE_EQUAL);
1908   gst_value_set_fraction (&cmp, 30, 1);
1909   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (tmp),
1910           &cmp) == GST_VALUE_EQUAL);
1911   g_value_unset (&dest);
1912   /* the other way */
1913   ret = gst_value_subtract (&dest, &src2, &src1);
1914   fail_unless (ret == FALSE);
1915   g_value_unset (&src1);
1916   g_value_unset (&src2);
1917
1918   g_value_unset (&cmp);
1919 }
1920
1921 GST_END_TEST;
1922
1923 /* Test set subtraction operations on fraction lists */
1924 GST_START_TEST (test_value_subtract_fraction_list)
1925 {
1926   GValue list1 = { 0 };
1927   GValue list2 = { 0 };
1928   GValue val1 = { 0 };
1929   GValue val2 = { 0 };
1930   GValue tmp = { 0 };
1931   gboolean ret;
1932
1933   g_value_init (&list1, GST_TYPE_LIST);
1934   g_value_init (&val1, GST_TYPE_FRACTION);
1935   gst_value_set_fraction (&val1, 15, 2);
1936   gst_value_list_append_value (&list1, &val1);
1937   g_value_init (&tmp, GST_TYPE_FRACTION);
1938   gst_value_set_fraction (&tmp, 5, 1);
1939   gst_value_list_append_value (&list1, &tmp);
1940   g_value_unset (&tmp);
1941
1942   g_value_init (&list2, GST_TYPE_LIST);
1943   g_value_init (&val2, GST_TYPE_FRACTION);
1944   gst_value_set_fraction (&val2, 15, 1);
1945   gst_value_list_append_value (&list2, &val2);
1946   g_value_init (&tmp, GST_TYPE_FRACTION);
1947   gst_value_set_fraction (&tmp, 5, 1);
1948   gst_value_list_append_value (&list2, &tmp);
1949   g_value_unset (&tmp);
1950
1951   /* should subtract all common elements */
1952   ret = gst_value_subtract (&tmp, &list1, &list2);
1953   fail_unless (ret == TRUE);
1954   fail_unless (gst_value_compare (&tmp, &val1) == GST_VALUE_EQUAL);
1955   g_value_unset (&val1);
1956   g_value_unset (&tmp);
1957
1958   ret = gst_value_subtract (&tmp, &list2, &list1);
1959   fail_unless (ret == TRUE);
1960   fail_unless (gst_value_compare (&tmp, &val2) == GST_VALUE_EQUAL);
1961   g_value_unset (&val2);
1962   g_value_unset (&tmp);
1963
1964   g_value_unset (&list1);
1965   g_value_unset (&list2);
1966 }
1967
1968 GST_END_TEST;
1969
1970
1971 GST_START_TEST (test_date)
1972 {
1973   GstStructure *s;
1974   GDate *date, *date2;
1975   gchar *str;
1976
1977   date = g_date_new_dmy (22, 9, 2005);
1978
1979   s = gst_structure_new ("media/x-type", "SOME_DATE_TAG", GST_TYPE_DATE,
1980       date, NULL);
1981
1982   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
1983           GST_TYPE_DATE));
1984   fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date2));
1985   fail_unless (date2 != NULL);
1986   fail_unless (g_date_valid (date2));
1987   fail_unless (g_date_compare (date, date2) == 0);
1988
1989   g_date_free (date);
1990   g_date_free (date2);
1991   date = NULL;
1992   date2 = NULL;
1993
1994   str = gst_structure_to_string (s);
1995   gst_structure_free (s);
1996   s = NULL;
1997
1998   fail_unless (g_str_equal (str,
1999           "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22;"));
2000
2001   s = gst_structure_from_string (str, NULL);
2002   g_free (str);
2003   str = NULL;
2004
2005   fail_unless (s != NULL);
2006   fail_unless (gst_structure_has_name (s, "media/x-type"));
2007   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
2008           GST_TYPE_DATE));
2009   fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date));
2010   fail_unless (date != NULL);
2011   fail_unless (g_date_valid (date));
2012   fail_unless (g_date_get_day (date) == 22);
2013   fail_unless (g_date_get_month (date) == 9);
2014   fail_unless (g_date_get_year (date) == 2005);
2015   g_date_free (date);
2016   date = NULL;
2017
2018   str = gst_structure_to_string (s);
2019   gst_structure_free (s);
2020   s = NULL;
2021
2022   fail_unless (g_str_equal (str,
2023           "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22;"));
2024   g_free (str);
2025   str = NULL;
2026 }
2027
2028 GST_END_TEST;
2029
2030 static gboolean
2031 date_time_equal (GstDateTime * a, GstDateTime * b)
2032 {
2033   if (gst_date_time_get_year (a) != gst_date_time_get_year (b) ||
2034       gst_date_time_get_month (a) != gst_date_time_get_month (b) ||
2035       gst_date_time_get_day (a) != gst_date_time_get_day (b))
2036     return FALSE;
2037
2038   if (gst_date_time_get_hour (a) != gst_date_time_get_hour (b) ||
2039       gst_date_time_get_minute (a) != gst_date_time_get_minute (b) ||
2040       gst_date_time_get_second (a) != gst_date_time_get_second (b) ||
2041       gst_date_time_get_microsecond (a) != gst_date_time_get_microsecond (b))
2042     return FALSE;
2043
2044   if (gst_date_time_get_time_zone_offset (a) !=
2045       gst_date_time_get_time_zone_offset (b))
2046     return FALSE;
2047
2048   return TRUE;
2049 }
2050
2051 GST_START_TEST (test_date_time)
2052 {
2053   GstStructure *s;
2054   GstDateTime *datetime, *datetime2;
2055   gchar *str;
2056
2057   /* utc timezone */
2058   datetime = gst_date_time_new (0, 2010, 6, 23, 7, 40, 10);
2059
2060   s = gst_structure_new ("media/x-type", "SOME_DATE_TIME_TAG",
2061       GST_TYPE_DATE_TIME, datetime, NULL);
2062
2063   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2064           GST_TYPE_DATE_TIME));
2065   fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2066           &datetime2));
2067   fail_unless (datetime2 != NULL);
2068   fail_unless (date_time_equal (datetime, datetime2));
2069
2070   gst_date_time_unref (datetime);
2071   gst_date_time_unref (datetime2);
2072   datetime = NULL;
2073   datetime2 = NULL;
2074
2075   str = gst_structure_to_string (s);
2076   gst_structure_free (s);
2077   s = NULL;
2078
2079   fail_unless (g_str_equal (str,
2080           "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000000+0000\";"));
2081
2082   s = gst_structure_from_string (str, NULL);
2083   g_free (str);
2084   str = NULL;
2085
2086   fail_unless (s != NULL);
2087   fail_unless (gst_structure_has_name (s, "media/x-type"));
2088   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2089           GST_TYPE_DATE_TIME));
2090   fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2091           &datetime));
2092   fail_unless (datetime != NULL);
2093   fail_unless (gst_date_time_get_year (datetime) == 2010);
2094   fail_unless (gst_date_time_get_month (datetime) == 6);
2095   fail_unless (gst_date_time_get_day (datetime) == 23);
2096   fail_unless (gst_date_time_get_hour (datetime) == 7);
2097   fail_unless (gst_date_time_get_minute (datetime) == 40);
2098   fail_unless (gst_date_time_get_second (datetime) == 10);
2099   fail_unless (gst_date_time_get_microsecond (datetime) == 0);
2100   fail_unless (gst_date_time_get_time_zone_offset (datetime) == 0);
2101   gst_date_time_unref (datetime);
2102   datetime = NULL;
2103
2104   str = gst_structure_to_string (s);
2105   gst_structure_free (s);
2106   s = NULL;
2107
2108   fail_unless (g_str_equal (str,
2109           "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000000+0000\";"));
2110   g_free (str);
2111   str = NULL;
2112
2113   /* with timezone */
2114   datetime = gst_date_time_new (-3.0, 2010, 6, 23, 7, 40, 10.000001);
2115
2116   s = gst_structure_new ("media/x-type", "SOME_DATE_TIME_TAG",
2117       GST_TYPE_DATE_TIME, datetime, NULL);
2118
2119   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2120           GST_TYPE_DATE_TIME));
2121   fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2122           &datetime2));
2123   fail_unless (datetime2 != NULL);
2124   fail_unless (date_time_equal (datetime, datetime2));
2125
2126   gst_date_time_unref (datetime);
2127   gst_date_time_unref (datetime2);
2128   datetime = NULL;
2129   datetime2 = NULL;
2130
2131   str = gst_structure_to_string (s);
2132   gst_structure_free (s);
2133   s = NULL;
2134
2135   fail_unless (g_str_equal (str,
2136           "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000001-0300\";"));
2137
2138   s = gst_structure_from_string (str, NULL);
2139   g_free (str);
2140   str = NULL;
2141
2142   fail_unless (s != NULL);
2143   fail_unless (gst_structure_has_name (s, "media/x-type"));
2144   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2145           GST_TYPE_DATE_TIME));
2146   fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2147           &datetime));
2148   fail_unless (datetime != NULL);
2149   fail_unless (gst_date_time_get_year (datetime) == 2010);
2150   fail_unless (gst_date_time_get_month (datetime) == 6);
2151   fail_unless (gst_date_time_get_day (datetime) == 23);
2152   fail_unless (gst_date_time_get_hour (datetime) == 7);
2153   fail_unless (gst_date_time_get_minute (datetime) == 40);
2154   fail_unless (gst_date_time_get_second (datetime) == 10);
2155   fail_unless (gst_date_time_get_microsecond (datetime) == 1);
2156   fail_unless (gst_date_time_get_time_zone_offset (datetime) == -3);
2157   gst_date_time_unref (datetime);
2158   datetime = NULL;
2159
2160   str = gst_structure_to_string (s);
2161   gst_structure_free (s);
2162   s = NULL;
2163   fail_unless (g_str_equal (str,
2164           "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000001-0300\";"));
2165
2166   g_free (str);
2167   str = NULL;
2168
2169   /* with positive timezone */
2170   datetime = gst_date_time_new (2.0, 2010, 6, 23, 7, 40, 10.000001);
2171
2172   s = gst_structure_new ("media/x-type", "SOME_DATE_TIME_TAG",
2173       GST_TYPE_DATE_TIME, datetime, NULL);
2174
2175   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2176           GST_TYPE_DATE_TIME));
2177   fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2178           &datetime2));
2179   fail_unless (datetime2 != NULL);
2180   fail_unless (date_time_equal (datetime, datetime2));
2181
2182   gst_date_time_unref (datetime);
2183   gst_date_time_unref (datetime2);
2184   datetime = NULL;
2185   datetime2 = NULL;
2186
2187   str = gst_structure_to_string (s);
2188   gst_structure_free (s);
2189   s = NULL;
2190
2191   fail_unless (g_str_equal (str,
2192           "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000001+0200\";"));
2193
2194   s = gst_structure_from_string (str, NULL);
2195   g_free (str);
2196   str = NULL;
2197
2198   fail_unless (s != NULL);
2199   fail_unless (gst_structure_has_name (s, "media/x-type"));
2200   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2201           GST_TYPE_DATE_TIME));
2202   fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2203           &datetime));
2204   fail_unless (datetime != NULL);
2205   fail_unless (gst_date_time_get_year (datetime) == 2010);
2206   fail_unless (gst_date_time_get_month (datetime) == 6);
2207   fail_unless (gst_date_time_get_day (datetime) == 23);
2208   fail_unless (gst_date_time_get_hour (datetime) == 7);
2209   fail_unless (gst_date_time_get_minute (datetime) == 40);
2210   fail_unless (gst_date_time_get_second (datetime) == 10);
2211   fail_unless (gst_date_time_get_microsecond (datetime) == 1);
2212   fail_unless (gst_date_time_get_time_zone_offset (datetime) == 2);
2213   gst_date_time_unref (datetime);
2214   datetime = NULL;
2215
2216   str = gst_structure_to_string (s);
2217   gst_structure_free (s);
2218   s = NULL;
2219   fail_unless (g_str_equal (str,
2220           "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000001+0200\";"));
2221
2222   g_free (str);
2223   str = NULL;
2224
2225 }
2226
2227 GST_END_TEST;
2228
2229 GST_START_TEST (test_fraction_range)
2230 {
2231   GValue range = { 0, };
2232   GValue start = { 0, };
2233   GValue end = { 0, };
2234   GValue src = { 0, };
2235   GValue dest = { 0, };
2236   GValue range2 = { 0, };
2237
2238   g_value_init (&range, GST_TYPE_FRACTION_RANGE);
2239   g_value_init (&range2, GST_TYPE_FRACTION_RANGE);
2240   g_value_init (&start, GST_TYPE_FRACTION);
2241   g_value_init (&end, GST_TYPE_FRACTION);
2242   g_value_init (&src, GST_TYPE_FRACTION);
2243
2244   gst_value_set_fraction (&src, 1, 2);
2245
2246   /* Check that a intersection of fraction & range = fraction */
2247   gst_value_set_fraction (&start, 1, 4);
2248   gst_value_set_fraction (&end, 2, 3);
2249   gst_value_set_fraction_range (&range, &start, &end);
2250
2251   fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
2252   fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION);
2253   fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
2254
2255   /* Check that a intersection selects the overlapping range */
2256   gst_value_set_fraction (&start, 1, 3);
2257   gst_value_set_fraction (&end, 2, 3);
2258   gst_value_set_fraction_range (&range2, &start, &end);
2259   g_value_unset (&dest);
2260   fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
2261   fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
2262
2263   gst_value_set_fraction_range (&range2, &start, &end);
2264   fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
2265
2266   /* Check that non intersection ranges don't intersect */
2267   gst_value_set_fraction (&start, 4, 2);
2268   gst_value_set_fraction (&end, 5, 2);
2269   gst_value_set_fraction_range (&range2, &start, &end);
2270   g_value_unset (&dest);
2271   fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
2272
2273   g_value_unset (&start);
2274   g_value_unset (&end);
2275   g_value_unset (&range);
2276   g_value_unset (&range2);
2277   g_value_unset (&src);
2278 }
2279
2280 GST_END_TEST;
2281
2282 GST_START_TEST (test_serialize_deserialize_format_enum)
2283 {
2284   GstStructure *s, *s2;
2285   GstFormat foobar_fmt;
2286   gchar *str, *str2, *end = NULL;
2287
2288   /* make sure custom formats are serialised properly as well */
2289   foobar_fmt = gst_format_register ("foobar", "GST_FORMAT_FOOBAR");
2290   fail_unless (foobar_fmt != GST_FORMAT_UNDEFINED);
2291
2292   s = gst_structure_new ("foo/bar", "format1", GST_TYPE_FORMAT,
2293       GST_FORMAT_BYTES, "format2", GST_TYPE_FORMAT, GST_FORMAT_TIME,
2294       "format3", GST_TYPE_FORMAT, GST_FORMAT_DEFAULT, "format4",
2295       GST_TYPE_FORMAT, foobar_fmt, NULL);
2296
2297   str = gst_structure_to_string (s);
2298   GST_LOG ("Got structure string '%s'", GST_STR_NULL (str));
2299   fail_unless (str != NULL);
2300   fail_unless (strstr (str, "TIME") != NULL);
2301   fail_unless (strstr (str, "BYTE") != NULL);
2302   fail_unless (strstr (str, "DEFAULT") != NULL);
2303   fail_unless (strstr (str, "FOOBAR") != NULL);
2304
2305   s2 = gst_structure_from_string (str, &end);
2306   fail_unless (s2 != NULL);
2307
2308   str2 = gst_structure_to_string (s2);
2309   fail_unless (str2 != NULL);
2310
2311   fail_unless (g_str_equal (str, str2));
2312
2313   g_free (str);
2314   g_free (str2);
2315   gst_structure_free (s);
2316   gst_structure_free (s2);
2317 }
2318
2319 GST_END_TEST;
2320
2321 GST_START_TEST (test_serialize_deserialize_caps)
2322 {
2323   GValue value = { 0 }
2324   , value2 = {
2325   0};
2326   GstCaps *caps, *caps2;
2327   gchar *serialized;
2328
2329   caps = gst_caps_new_simple ("test/caps",
2330       "foo", G_TYPE_INT, 10, "bar", G_TYPE_STRING, "test", NULL);
2331   fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
2332
2333   /* and assign caps to gvalue */
2334   g_value_init (&value, GST_TYPE_CAPS);
2335   g_value_take_boxed (&value, caps);
2336   fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
2337
2338   /* now serialize it */
2339   serialized = gst_value_serialize (&value);
2340   GST_DEBUG ("serialized caps to %s", serialized);
2341   fail_unless (serialized != NULL);
2342
2343   /* refcount should not change */
2344   fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
2345
2346   /* now deserialize again */
2347   g_value_init (&value2, GST_TYPE_CAPS);
2348   gst_value_deserialize (&value2, serialized);
2349
2350   caps2 = g_value_get_boxed (&value2);
2351   fail_if (GST_CAPS_REFCOUNT_VALUE (caps2) != 1);
2352
2353   /* they should be equal */
2354   fail_unless (gst_caps_is_equal (caps, caps2));
2355
2356   /* cleanup */
2357   g_value_unset (&value);
2358   g_value_unset (&value2);
2359   g_free (serialized);
2360 }
2361
2362 GST_END_TEST;
2363
2364 GST_START_TEST (test_int_range)
2365 {
2366   GValue range = { 0, };
2367   GValue start = { 0, };
2368   GValue end = { 0, };
2369   GValue src = { 0, };
2370   GValue dest = { 0, };
2371   GValue range2 = { 0, };
2372
2373   g_value_init (&range, GST_TYPE_INT_RANGE);
2374   g_value_init (&range2, GST_TYPE_INT_RANGE);
2375   g_value_init (&start, G_TYPE_INT);
2376   g_value_init (&end, G_TYPE_INT);
2377   g_value_init (&src, G_TYPE_INT);
2378
2379   g_value_set_int (&src, 2);
2380
2381   /* Check that a intersection of int & range = int */
2382   gst_value_set_int_range (&range, 1, 5);
2383
2384   fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
2385   fail_unless (G_VALUE_TYPE (&dest) == G_TYPE_INT);
2386   fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
2387
2388   /* Check that a intersection selects the overlapping range */
2389   gst_value_set_int_range (&range2, 2, 3);
2390   g_value_unset (&dest);
2391   fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
2392   fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
2393
2394   fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
2395
2396   /* Check that non intersection ranges don't intersect */
2397   gst_value_set_int_range (&range2, 6, 7);
2398   g_value_unset (&dest);
2399   fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
2400
2401   g_value_unset (&start);
2402   g_value_unset (&end);
2403   g_value_unset (&range);
2404   g_value_unset (&range2);
2405   g_value_unset (&src);
2406 }
2407
2408 GST_END_TEST;
2409
2410 GST_START_TEST (test_int64_range)
2411 {
2412   GValue range = { 0, };
2413   GValue start = { 0, };
2414   GValue end = { 0, };
2415   GValue src = { 0, };
2416   GValue dest = { 0, };
2417   GValue range2 = { 0, };
2418
2419   g_value_init (&range, GST_TYPE_INT64_RANGE);
2420   g_value_init (&range2, GST_TYPE_INT64_RANGE);
2421   g_value_init (&start, G_TYPE_INT64);
2422   g_value_init (&end, G_TYPE_INT64);
2423   g_value_init (&src, G_TYPE_INT64);
2424
2425   g_value_set_int64 (&src, 2);
2426
2427   /* Check that a intersection of int64 & range = int64 */
2428   gst_value_set_int64_range (&range, 1, 5);
2429
2430   fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
2431   fail_unless (G_VALUE_TYPE (&dest) == G_TYPE_INT64);
2432   fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
2433
2434   /* Check that a intersection selects the overlapping range */
2435   gst_value_set_int64_range (&range2, 2, 3);
2436   g_value_unset (&dest);
2437   fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
2438   fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
2439
2440   fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
2441
2442   /* Check that non intersection ranges don't intersect */
2443   gst_value_set_int64_range (&range2, 6, 7);
2444   g_value_unset (&dest);
2445   fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
2446
2447   g_value_unset (&start);
2448   g_value_unset (&end);
2449   g_value_unset (&range);
2450   g_value_unset (&range2);
2451   g_value_unset (&src);
2452 }
2453
2454 GST_END_TEST;
2455
2456 GST_START_TEST (test_serialize_int64_range)
2457 {
2458   int i = 0;
2459
2460   gint64 int64_ranges[] = {
2461     0, 5,
2462     0, G_MAXINT,
2463     5, G_MAXINT32,
2464     5, G_MAXINT64,
2465   };
2466   gint int64_ranges_size = sizeof (int64_ranges) / sizeof (int64_ranges[0]) / 2;
2467
2468   gchar *int64_range_strings[] = {
2469     g_strdup ("[ 0, 5 ]"),
2470     g_strdup_printf ("[ 0, %" G_GINT64_FORMAT " ]", (gint64) G_MAXINT),
2471     g_strdup_printf ("[ 5, %" G_GINT64_FORMAT " ]", (gint64) G_MAXINT32),
2472     g_strdup_printf ("[ 5, %" G_GINT64_FORMAT " ]", G_MAXINT64),
2473   };
2474   gint int64_range_strings_size =
2475       sizeof (int64_range_strings) / sizeof (int64_range_strings[0]);
2476
2477   fail_unless (int64_ranges_size == int64_range_strings_size);
2478
2479   while (i + 1 < (int64_ranges_size * 2)) {
2480     if ((i + 1) % 2) {
2481       gchar *str;
2482       gchar *str2;
2483       GValue value = { 0 };
2484       const GValue *deserialized_value;
2485       int idx = i / 2;
2486       GstStructure *s;
2487
2488       g_value_init (&value, GST_TYPE_INT64_RANGE);
2489
2490       /* check serialization */
2491       gst_value_set_int64_range (&value, int64_ranges[i], int64_ranges[i + 1]);
2492       str = gst_value_serialize (&value);
2493       fail_unless (strcmp (str, int64_range_strings[idx]) == 0);
2494       g_free (int64_range_strings[idx]);
2495
2496       /* now deserialize again to an int64 range */
2497       s = gst_structure_new ("foo/bar", "range", GST_TYPE_INT64_RANGE,
2498           int64_ranges[i], int64_ranges[i + 1], NULL);
2499       deserialized_value = gst_structure_get_value (s, "range");
2500       fail_unless (GST_VALUE_HOLDS_INT64_RANGE (deserialized_value) == TRUE);
2501       str2 = gst_value_serialize (deserialized_value);
2502
2503       fail_unless (gst_value_get_int64_range_min (deserialized_value) ==
2504           int64_ranges[i]);
2505       fail_unless (gst_value_get_int64_range_max (deserialized_value) ==
2506           int64_ranges[i + 1]);
2507
2508       gst_structure_free (s);
2509       g_free (str);
2510       g_free (str2);
2511     }
2512     i++;
2513   }
2514 }
2515
2516 GST_END_TEST;
2517
2518 GST_START_TEST (test_deserialize_int_range)
2519 {
2520   GstStructure *s;
2521   gchar *str, *str2;
2522   gchar *end = NULL;
2523   const GValue *deserialized_value;
2524
2525   /* check a valid int_range deserialization */
2526   str = g_strdup_printf ("foo/bar, range=[ 1, %d ];", G_MAXINT);
2527   s = gst_structure_from_string (str, &end);
2528   fail_unless (*end == '\0');
2529   deserialized_value = gst_structure_get_value (s, "range");
2530   fail_unless (GST_VALUE_HOLDS_INT_RANGE (deserialized_value) == TRUE);
2531   fail_unless (gst_value_get_int_range_min (deserialized_value) == 1);
2532   fail_unless (gst_value_get_int_range_max (deserialized_value) == G_MAXINT);
2533   gst_structure_free (s);
2534   end = NULL;
2535   g_free (str);
2536
2537   /* check invalid int_range deserialization */
2538   str =
2539       g_strdup_printf ("foo/bar, range=[ 1, %" G_GINT64_FORMAT " ];",
2540       (gint64) G_MAXINT + 1);
2541   ASSERT_CRITICAL (s = gst_structure_from_string (str, &end));
2542   g_free (str);
2543   gst_structure_free (s);
2544   str =
2545       g_strdup_printf ("foo/bar, range=[ %" G_GINT64_FORMAT ", %"
2546       G_GINT64_FORMAT " ];", (gint64) G_MAXINT, (gint64) G_MAXINT + 1);
2547   ASSERT_CRITICAL (s = gst_structure_from_string (str, NULL));
2548   end = NULL;
2549   g_free (str);
2550   gst_structure_free (s);
2551
2552   /* check a valid int64_range deserialization. Those ranges need to
2553    * be explicit about their storage type. */
2554   str = g_strdup_printf ("foo/bar, range=(gint64)[ 1, %d ];", G_MAXINT);
2555   s = gst_structure_from_string (str, &end);
2556   fail_unless (*end == '\0');
2557   deserialized_value = gst_structure_get_value (s, "range");
2558   fail_unless (GST_VALUE_HOLDS_INT64_RANGE (deserialized_value) == TRUE);
2559   fail_unless (gst_value_get_int64_range_min (deserialized_value) == 1);
2560   fail_unless (gst_value_get_int64_range_max (deserialized_value) == G_MAXINT);
2561   str2 = gst_structure_to_string (s);
2562   fail_unless (strcmp (str, str2) == 0);
2563   gst_structure_free (s);
2564   end = NULL;
2565   g_free (str);
2566   g_free (str2);
2567
2568   /* check invalid int64_range (starting with a gint) deserialization */
2569   str =
2570       g_strdup_printf ("foo/bar, range=(gint64)[ 1, %" G_GUINT64_FORMAT " ];",
2571       (guint64) G_MAXINT64 + 1);
2572   ASSERT_CRITICAL (s = gst_structure_from_string (str, &end));
2573   fail_unless (*end == '\0');
2574   gst_structure_free (s);
2575   end = NULL;
2576   g_free (str);
2577
2578   /* check invalid int64_range deserialization into a int64_range */
2579   str =
2580       g_strdup_printf ("foo/bar, range=(gint64)[ %" G_GINT64_FORMAT ", %"
2581       G_GUINT64_FORMAT " ];", (gint64) G_MAXINT, (guint64) G_MAXINT64 + 1);
2582   ASSERT_CRITICAL (s = gst_structure_from_string (str, NULL));
2583   g_free (str);
2584   gst_structure_free (s);
2585
2586   /* check invalid int64_range deserialization into a int_range */
2587   str =
2588       g_strdup_printf ("foo/bar, range=[ %" G_GINT64_FORMAT ", %"
2589       G_GUINT64_FORMAT " ];", (gint64) G_MAXINT, (guint64) G_MAXINT64 + 1);
2590   s = gst_structure_from_string (str, &end);
2591   fail_unless (s == NULL);
2592   fail_unless (end == NULL);
2593   g_free (str);
2594 }
2595
2596 GST_END_TEST static Suite *
2597 gst_value_suite (void)
2598 {
2599   Suite *s = suite_create ("GstValue");
2600   TCase *tc_chain = tcase_create ("general");
2601
2602   suite_add_tcase (s, tc_chain);
2603   tcase_add_test (tc_chain, test_serialize_fourcc);
2604   tcase_add_test (tc_chain, test_deserialize_fourcc);
2605   tcase_add_test (tc_chain, test_deserialize_buffer);
2606   tcase_add_test (tc_chain, test_serialize_buffer);
2607   tcase_add_test (tc_chain, test_deserialize_gint);
2608   tcase_add_test (tc_chain, test_deserialize_gint_failures);
2609   tcase_add_test (tc_chain, test_deserialize_guint);
2610   tcase_add_test (tc_chain, test_deserialize_guint_failures);
2611   tcase_add_test (tc_chain, test_deserialize_gint64);
2612   tcase_add_test (tc_chain, test_deserialize_guint64);
2613   tcase_add_test (tc_chain, test_deserialize_guchar);
2614   tcase_add_test (tc_chain, test_deserialize_gstfraction);
2615   tcase_add_test (tc_chain, test_serialize_flags);
2616   tcase_add_test (tc_chain, test_deserialize_flags);
2617   tcase_add_test (tc_chain, test_serialize_deserialize_format_enum);
2618   tcase_add_test (tc_chain, test_string);
2619   tcase_add_test (tc_chain, test_deserialize_string);
2620   tcase_add_test (tc_chain, test_value_compare);
2621   tcase_add_test (tc_chain, test_value_intersect);
2622   tcase_add_test (tc_chain, test_value_subtract_int);
2623   tcase_add_test (tc_chain, test_value_subtract_int64);
2624   tcase_add_test (tc_chain, test_value_subtract_double);
2625   tcase_add_test (tc_chain, test_value_subtract_fraction);
2626   tcase_add_test (tc_chain, test_value_subtract_fraction_range);
2627   tcase_add_test (tc_chain, test_value_subtract_fraction_list);
2628   tcase_add_test (tc_chain, test_date);
2629   tcase_add_test (tc_chain, test_date_time);
2630   tcase_add_test (tc_chain, test_fraction_range);
2631   tcase_add_test (tc_chain, test_serialize_deserialize_caps);
2632   tcase_add_test (tc_chain, test_int_range);
2633   tcase_add_test (tc_chain, test_int64_range);
2634   tcase_add_test (tc_chain, test_serialize_int64_range);
2635   tcase_add_test (tc_chain, test_deserialize_int_range);
2636
2637   return s;
2638 }
2639
2640 GST_CHECK_MAIN (gst_value);