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