tests/check/gst/gstvalue.c

   1 /* GStreamer
   2  * Copyright (C) <2004> David Schleef <david at schleef dot org>
   3  * Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
   4  *
   5  * gstvalue.c: Unit tests for GstValue
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23
  24 #include <gst/check/gstcheck.h>
  25
  26
  27 GST_START_TEST (test_serialize_fourcc)
  28 {
  29   int i;
  30
  31   guint32 fourccs[] = {
  32     GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'),
  33     GST_MAKE_FOURCC ('Y', '8', '0', '0'),
  34     GST_MAKE_FOURCC ('Y', '8', ' ', ' '),
  35     GST_MAKE_FOURCC ('Y', '1', '6', ' '),
  36     GST_MAKE_FOURCC ('Y', 'U', 'Y', '_'),
  37     GST_MAKE_FOURCC ('Y', 'U', 'Y', '#'),
  38   };
  39   gint fourccs_size = sizeof (fourccs) / sizeof (fourccs[0]);
  40   const gchar *fourcc_strings[] = {
  41     "YUY2",
  42     "Y800",
  43     "Y8  ",
  44     "Y16 ",
  45     "0x5f595559",               /* Ascii values of YUY_ */
  46     "0x23595559",               /* Ascii values of YUY# */
  47   };
  48   gint fourcc_strings_size =
  49       sizeof (fourcc_strings) / sizeof (fourcc_strings[0]);
  50
  51   fail_unless (fourccs_size == fourcc_strings_size);
  52
  53   for (i = 0; i < fourccs_size; ++i) {
  54     gchar *str;
  55     GValue value = { 0 };
  56     g_value_init (&value, GST_TYPE_FOURCC);
  57
  58     gst_value_set_fourcc (&value, fourccs[i]);
  59     str = gst_value_serialize (&value);
  60
  61     fail_unless (strcmp (str, fourcc_strings[i]) == 0);
  62
  63     g_free (str);
  64   }
  65 }
  66
  67 GST_END_TEST;
  68
  69 GST_START_TEST (test_deserialize_fourcc)
  70 {
  71   int i;
  72
  73   guint32 fourccs[] = {
  74     GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'),
  75     GST_MAKE_FOURCC ('Y', '8', '0', '0'),
  76     GST_MAKE_FOURCC ('Y', '8', ' ', ' '),
  77     GST_MAKE_FOURCC ('Y', '8', ' ', ' '),
  78     GST_MAKE_FOURCC ('Y', '8', ' ', ' '),
  79     GST_MAKE_FOURCC ('Y', '1', '6', ' '),
  80     GST_MAKE_FOURCC ('Y', 'U', 'Y', '_'),
  81     GST_MAKE_FOURCC ('Y', 'U', 'Y', '#'),
  82   };
  83   gint fourccs_size = sizeof (fourccs) / sizeof (fourccs[0]);
  84   const gchar *fourcc_strings[] = {
  85     "YUY2",
  86     "Y800",
  87     "Y8  ",
  88     "Y8 ",
  89     "Y8",
  90     "Y16 ",
  91     "0x5f595559",               /* Ascii values of YUY_ */
  92     "0x23595559",               /* Ascii values of YUY# */
  93   };
  94   gint fourcc_strings_size =
  95       sizeof (fourcc_strings) / sizeof (fourcc_strings[0]);
  96
  97   fail_unless (fourccs_size == fourcc_strings_size);
  98
  99   for (i = 0; i < fourccs_size; ++i) {
 100     GValue value = { 0 };
 101
 102     g_value_init (&value, GST_TYPE_FOURCC);
 103
 104     fail_unless (gst_value_deserialize (&value, fourcc_strings[i]));
 105     fail_unless_equals_int (gst_value_get_fourcc (&value), fourccs[i]);
 106
 107     g_value_unset (&value);
 108   }
 109 }
 110
 111 GST_END_TEST;
 112
 113 GST_START_TEST (test_deserialize_buffer)
 114 {
 115   GValue value = { 0 };
 116   GstBuffer *buf;
 117
 118   g_value_init (&value, GST_TYPE_BUFFER);
 119   fail_unless (gst_value_deserialize (&value, "1234567890abcdef"));
 120   /* does not increase the refcount */
 121   buf = GST_BUFFER (gst_value_get_mini_object (&value));
 122   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
 123
 124   /* does not increase the refcount */
 125   buf = gst_value_get_buffer (&value);
 126   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
 127
 128   /* cleanup */
 129   g_value_unset (&value);
 130 }
 131
 132 GST_END_TEST;
 133
 134 /* create and serialize a buffer */
 135 GST_START_TEST (test_serialize_buffer)
 136 {
 137   GValue value = { 0 };
 138   GstBuffer *buf;
 139   gchar *serialized;
 140   static const char *buf_data = "1234567890abcdef";
 141   gint len;
 142
 143   len = strlen (buf_data);
 144   buf = gst_buffer_new_and_alloc (len);
 145   memcpy (GST_BUFFER_DATA (buf), buf_data, len);
 146   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
 147
 148   /* and assign buffer to mini object */
 149   g_value_init (&value, GST_TYPE_BUFFER);
 150   gst_value_take_buffer (&value, buf);
 151   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
 152
 153   /* now serialize it */
 154   serialized = gst_value_serialize (&value);
 155   GST_DEBUG ("serialized buffer to %s", serialized);
 156   fail_unless (serialized != NULL);
 157
 158   /* refcount should not change */
 159   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
 160
 161   /* cleanup */
 162   g_free (serialized);
 163   g_value_unset (&value);
 164
 165   /* take NULL buffer */
 166   g_value_init (&value, GST_TYPE_BUFFER);
 167   GST_DEBUG ("setting NULL buffer");
 168   gst_value_take_buffer (&value, NULL);
 169
 170   /* now serialize it */
 171   GST_DEBUG ("serializing NULL buffer");
 172   serialized = gst_value_serialize (&value);
 173   /* should return NULL */
 174   fail_unless (serialized == NULL);
 175
 176   g_free (serialized);
 177   g_value_unset (&value);
 178 }
 179
 180 GST_END_TEST;
 181
 182 GST_START_TEST (test_deserialize_gint64)
 183 {
 184   GValue value = { 0 };
 185   const char *strings[] = {
 186     "12345678901",
 187     "-12345678901",
 188     "1152921504606846976",
 189     "-1152921504606846976",
 190   };
 191   gint64 results[] = {
 192     12345678901LL,
 193     -12345678901LL,
 194     1152921504606846976LL,
 195     -1152921504606846976LL,
 196   };
 197   int i;
 198
 199   g_value_init (&value, G_TYPE_INT64);
 200
 201   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 202     fail_unless (gst_value_deserialize (&value, strings[i]),
 203         "could not deserialize %s (%d)", strings[i], i);
 204     fail_unless (g_value_get_int64 (&value) == results[i],
 205         "resulting value is %" G_GINT64_FORMAT ", not %" G_GINT64_FORMAT
 206         ", for string %s (%d)", g_value_get_int64 (&value),
 207         results[i], strings[i], i);
 208   }
 209 }
 210
 211 GST_END_TEST;
 212
 213 GST_START_TEST (test_deserialize_guint64)
 214 {
 215   GValue value = { 0 };
 216   const char *strings[] = {
 217     "0xffffffffffffffff",
 218     "9223372036854775810",
 219     "-9223372036854775810",
 220     "-1",
 221     "1",
 222     "-0",
 223   };
 224   guint64 results[] = {
 225     0xffffffffffffffffULL,
 226     9223372036854775810ULL,
 227     9223372036854775806ULL,
 228     (guint64) - 1,
 229     1,
 230     0,
 231   };
 232   int i;
 233
 234   g_value_init (&value, G_TYPE_UINT64);
 235
 236   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 237     fail_unless (gst_value_deserialize (&value, strings[i]),
 238         "could not deserialize %s (%d)", strings[i], i);
 239     fail_unless (g_value_get_uint64 (&value) == results[i],
 240         "resulting value is %" G_GUINT64_FORMAT ", not %" G_GUINT64_FORMAT
 241         ", for string %s (%d)", g_value_get_uint64 (&value),
 242         results[i], strings[i], i);
 243   }
 244 }
 245
 246 GST_END_TEST;
 247
 248 GST_START_TEST (test_deserialize_gstfraction)
 249 {
 250   GValue value = { 0 };
 251   const char *strings[] = {
 252     "4/5",
 253     "-8/9"
 254   };
 255   gint64 result_numers[] = {
 256     4,
 257     -8
 258   };
 259   gint64 result_denoms[] = {
 260     5,
 261     9
 262   };
 263
 264   int i;
 265
 266   g_value_init (&value, GST_TYPE_FRACTION);
 267   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 268     fail_unless (gst_value_deserialize (&value, strings[i]),
 269         "could not deserialize %s (%d)", strings[i], i);
 270     fail_unless (gst_value_get_fraction_numerator (&value) == result_numers[i],
 271         "resulting numerator value is %d, not %d"
 272         ", for string %s (%d)", gst_value_get_fraction_numerator (&value),
 273         result_numers[i], strings[i], i);
 274     fail_unless (gst_value_get_fraction_denominator (&value) ==
 275         result_denoms[i], "resulting denominator value is %d, not %d"
 276         ", for string %s (%d)", gst_value_get_fraction_denominator (&value),
 277         result_denoms[i], strings[i], i);
 278   }
 279 }
 280
 281 GST_END_TEST;
 282
 283 GST_START_TEST (test_deserialize_gint)
 284 {
 285   GValue value = { 0 };
 286   const char *strings[] = {
 287     "123456",
 288     "-123456",
 289     "0xFFFF",
 290     "0x0000FFFF",
 291     /* a positive long long, serializing to highest possible positive sint */
 292     "0x7FFFFFFF",
 293     /* a positive long long, serializing to lowest possible negative sint */
 294     "0x80000000",
 295     /* a negative long long, serializing to lowest possible negative sint */
 296     "0xFFFFFFFF80000000",
 297     "0xFF000000",
 298     /* a positive long long serializing to -1 */
 299     "0xFFFFFFFF",
 300     "0xFFFFFFFF",
 301     /* a negative long long serializing to -1 */
 302     "0xFFFFFFFFFFFFFFFF",
 303     "0xFFFFFFFFFFFFFFFF",
 304     "0xEFFFFFFF",
 305   };
 306   /* some casts need to be explicit because of unsigned -> signed */
 307   gint results[] = {
 308     123456,
 309     -123456,
 310     0xFFFF,
 311     0xFFFF,
 312     0x7FFFFFFF,
 313     (gint) 0x80000000,
 314     (gint) 0x80000000,
 315     (gint) 0xFF000000,
 316     -1,
 317     (gint) 0xFFFFFFFF,
 318     -1,
 319     (gint) 0xFFFFFFFFFFFFFFFFLL,
 320     (gint) 0xEFFFFFFF,
 321   };
 322   int i;
 323
 324   g_value_init (&value, G_TYPE_INT);
 325
 326   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 327     fail_unless (gst_value_deserialize (&value, strings[i]),
 328         "could not deserialize %s (%d)", strings[i], i);
 329     fail_unless (g_value_get_int (&value) == results[i],
 330         "resulting value is %d, not %d, for string %s (%d)",
 331         g_value_get_int (&value), results[i], strings[i], i);
 332   }
 333 }
 334
 335 GST_END_TEST;
 336
 337 GST_START_TEST (test_deserialize_gint_failures)
 338 {
 339   GValue value = { 0 };
 340   const char *strings[] = {
 341     "-",                        /* not a complete number */
 342     "- TEST",                   /* not a complete number */
 343     "0x0000000100000000",       /* lowest long long that cannot fit in 32 bits */
 344     "0xF000000000000000",
 345     "0xFFFFFFF000000000",
 346     "0xFFFFFFFF00000000",
 347     "0x10000000000000000",      /* first number too long to fit into a long long */
 348     /* invent a new processor first before trying to make this one pass */
 349     "0x10000000000000000000000000000000000000000000",
 350   };
 351   int i;
 352
 353   g_value_init (&value, G_TYPE_INT);
 354
 355   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 356     fail_if (gst_value_deserialize (&value, strings[i]),
 357         "deserialized %s (%d), while it should have failed", strings[i], i);
 358   }
 359 }
 360
 361 GST_END_TEST;
 362
 363 GST_START_TEST (test_deserialize_guint)
 364 {
 365   GValue value = { 0 };
 366   const char *strings[] = {
 367     "123456",
 368     "-123456",
 369     "0xFFFF",
 370     "0x0000FFFF",
 371     /* a positive long long, serializing to highest possible positive sint */
 372     "0x7FFFFFFF",
 373     /* a positive long long, serializing to lowest possible negative sint */
 374     "0x80000000",
 375     "2147483648",
 376     /* a negative long long, serializing to lowest possible negative sint */
 377     "0xFFFFFFFF80000000",
 378     /* a value typically used for rgb masks */
 379     "0xFF000000",
 380     /* a positive long long serializing to highest possible positive uint */
 381     "0xFFFFFFFF",
 382     "0xFFFFFFFF",
 383     /* a negative long long serializing to highest possible positive uint */
 384     "0xFFFFFFFFFFFFFFFF",
 385     "0xEFFFFFFF",
 386   };
 387   guint results[] = {
 388     123456,
 389     (guint) - 123456,
 390     0xFFFF,
 391     0xFFFF,
 392     0x7FFFFFFF,
 393     0x80000000,
 394     (guint) 2147483648LL,
 395     0x80000000,
 396     0xFF000000,
 397     0xFFFFFFFF,
 398     G_MAXUINT,
 399     (guint) 0xFFFFFFFFFFFFFFFFLL,
 400     0xEFFFFFFF,
 401   };
 402   int i;
 403
 404   g_value_init (&value, G_TYPE_UINT);
 405
 406   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 407     fail_unless (gst_value_deserialize (&value, strings[i]),
 408         "could not deserialize %s (%d)", strings[i], i);
 409     fail_unless (g_value_get_uint (&value) == results[i],
 410         "resulting value is %d, not %d, for string %s (%d)",
 411         g_value_get_uint (&value), results[i], strings[i], i);
 412   }
 413 }
 414
 415 GST_END_TEST;
 416
 417 GST_START_TEST (test_deserialize_guint_failures)
 418 {
 419   GValue value = { 0 };
 420   const char *strings[] = {
 421     "-",                        /* not a complete number */
 422     "- TEST",                   /* not a complete number */
 423 #if 0
 424 /* FIXME: these values should not be deserializable, since they overflow
 425  * the target format */
 426     "0x0000000100000000",       /* lowest long long that cannot fit in 32 bits */
 427     "0xF000000000000000",
 428     "0xFFFFFFF000000000",
 429     "0xFFFFFFFF00000000",
 430     "0x10000000000000000",      /* first number too long to fit into a long long */
 431     /* invent a new processor first before trying to make this one pass */
 432     "0x10000000000000000000000000000000000000000000",
 433 #endif
 434   };
 435   int i;
 436
 437   g_value_init (&value, G_TYPE_UINT);
 438
 439   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 440     fail_if (gst_value_deserialize (&value, strings[i]),
 441         "deserialized %s (%d), while it should have failed", strings[i], i);
 442   }
 443 }
 444
 445 GST_END_TEST;
 446
 447 GST_START_TEST (test_serialize_flags)
 448 {
 449   GValue value = { 0 };
 450   gchar *string;
 451   GstSeekFlags flags[] = {
 452     0,
 453     GST_SEEK_FLAG_NONE,
 454     GST_SEEK_FLAG_FLUSH,
 455     GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
 456   };
 457   const char *results[] = {
 458     "GST_SEEK_FLAG_NONE",
 459     "GST_SEEK_FLAG_NONE",
 460     "GST_SEEK_FLAG_FLUSH",
 461     "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",
 462   };
 463   int i;
 464
 465   g_value_init (&value, GST_TYPE_SEEK_FLAGS);
 466
 467   for (i = 0; i < G_N_ELEMENTS (flags); ++i) {
 468     g_value_set_flags (&value, flags[i]);
 469     string = gst_value_serialize (&value);
 470     fail_if (string == NULL, "could not serialize flags %d", i);
 471     fail_unless (strcmp (string, results[i]) == 0,
 472         "resulting value is %s, not %s, for flags #%d", string, results[i], i);
 473     g_free (string);
 474   }
 475 }
 476
 477 GST_END_TEST;
 478
 479
 480 GST_START_TEST (test_deserialize_flags)
 481 {
 482   GValue value = { 0 };
 483   const char *strings[] = {
 484     "",
 485     "0",
 486     "GST_SEEK_FLAG_NONE",
 487     "GST_SEEK_FLAG_FLUSH",
 488     "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",
 489   };
 490   GstSeekFlags results[] = {
 491     GST_SEEK_FLAG_NONE,
 492     GST_SEEK_FLAG_NONE,
 493     GST_SEEK_FLAG_NONE,
 494     GST_SEEK_FLAG_FLUSH,
 495     GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
 496   };
 497   int i;
 498
 499   g_value_init (&value, GST_TYPE_SEEK_FLAGS);
 500
 501   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 502     fail_unless (gst_value_deserialize (&value, strings[i]),
 503         "could not deserialize %s (%d)", strings[i], i);
 504     fail_unless (g_value_get_flags (&value) == results[i],
 505         "resulting value is %d, not %d, for string %s (%d)",
 506         g_value_get_flags (&value), results[i], strings[i], i);
 507   }
 508 }
 509
 510 GST_END_TEST;
 511
 512 GST_START_TEST (test_string)
 513 {
 514   const gchar *try[] = {
 515     "Dude",
 516     "Hi, I'm a string",
 517     "tüüüt!",
 518     "\"\""                      /* Empty string */
 519   };
 520   gchar *tmp;
 521   GValue v = { 0, };
 522   guint i;
 523
 524   g_value_init (&v, G_TYPE_STRING);
 525   for (i = 0; i < G_N_ELEMENTS (try); i++) {
 526     g_value_set_string (&v, try[i]);
 527     tmp = gst_value_serialize (&v);
 528     fail_if (tmp == NULL, "couldn't serialize: %s\n", try[i]);
 529     fail_unless (gst_value_deserialize (&v, tmp),
 530         "couldn't deserialize: %s\n", tmp);
 531     g_free (tmp);
 532
 533     fail_unless (g_str_equal (g_value_get_string (&v), try[i]),
 534         "\nserialized  : %s\ndeserialized: %s", try[i],
 535         g_value_get_string (&v));
 536   }
 537   /* NULL strings should not be serializable */
 538   g_value_set_string (&v, NULL);
 539   fail_unless (gst_value_serialize (&v) == NULL);
 540   g_value_unset (&v);
 541 }
 542
 543 GST_END_TEST;
 544
 545 GST_START_TEST (test_deserialize_string)
 546 {
 547   struct
 548   {
 549     const gchar *from;
 550     const gchar *to;
 551   } tests[] = {
 552     {
 553     "", ""},                    /* empty strings */
 554     {
 555     "\"\"", ""},                /* quoted empty string -> empty string */
 556         /* Expected FAILURES: */
 557     {
 558     "\"", NULL},                /* missing second quote */
 559     {
 560     "\"Hello\\ World", NULL},   /* missing second quote */
 561     {
 562     "\"\\", NULL},              /* quote at end, missing second quote */
 563     {
 564     "\"\\0", NULL},             /* missing second quote */
 565     {
 566     "\"\\0\"", NULL},           /* unfinished escaped character */
 567     {
 568     "\" \"", NULL},             /* spaces must be escaped */
 569 #if 0
 570         /* FIXME 0.9: this test should fail, but it doesn't */
 571     {
 572     "tüüt", NULL}             /* string with special chars must be escaped */
 573 #endif
 574   };
 575   guint i;
 576   GValue v = { 0, };
 577   gboolean ret = TRUE;
 578
 579   g_value_init (&v, G_TYPE_STRING);
 580   for (i = 0; i < G_N_ELEMENTS (tests); i++) {
 581     if (gst_value_deserialize (&v, tests[i].from)) {
 582       fail_if (tests[i].to == NULL,
 583           "I got %s instead of a failure", g_value_get_string (&v));
 584       fail_unless (g_str_equal (g_value_get_string (&v), tests[i].to),
 585           "\nwanted: %s\ngot    : %s", tests[i].to, g_value_get_string (&v));
 586     } else {
 587       fail_if (tests[i].to != NULL, "failed, but wanted: %s", tests[i].to);
 588       ret = FALSE;
 589     }
 590   }
 591   g_value_unset (&v);
 592 }
 593
 594 GST_END_TEST;
 595
 596 GST_START_TEST (test_value_compare)
 597 {
 598   GValue value1 = { 0 };
 599   GValue value2 = { 0 };
 600   GValue tmp = { 0 };
 601
 602   g_value_init (&value1, G_TYPE_INT);
 603   g_value_set_int (&value1, 10);
 604   g_value_init (&value2, G_TYPE_INT);
 605   g_value_set_int (&value2, 20);
 606   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 607   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 608   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 609   g_value_unset (&value1);
 610   g_value_unset (&value2);
 611
 612   g_value_init (&value1, G_TYPE_DOUBLE);
 613   g_value_set_double (&value1, 10);
 614   g_value_init (&value2, G_TYPE_DOUBLE);
 615   g_value_set_double (&value2, 20);
 616   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 617   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 618   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 619   g_value_unset (&value1);
 620   g_value_unset (&value2);
 621
 622   g_value_init (&value1, G_TYPE_STRING);
 623   g_value_set_string (&value1, "a");
 624   g_value_init (&value2, G_TYPE_STRING);
 625   g_value_set_string (&value2, "b");
 626   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 627   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 628   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 629   /* Test some NULL string comparisons */
 630   g_value_set_string (&value2, NULL);
 631   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
 632   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_UNORDERED);
 633   fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL);
 634
 635   g_value_unset (&value1);
 636   g_value_unset (&value2);
 637
 638   g_value_init (&value1, GST_TYPE_FOURCC);
 639   gst_value_set_fourcc (&value1, GST_MAKE_FOURCC ('a', 'b', 'c', 'd'));
 640   g_value_init (&value2, GST_TYPE_FOURCC);
 641   gst_value_set_fourcc (&value2, GST_MAKE_FOURCC ('1', '2', '3', '4'));
 642   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
 643   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 644   g_value_unset (&value1);
 645   g_value_unset (&value2);
 646
 647   /* comparing 2/3 with 3/4 */
 648   g_value_init (&value1, GST_TYPE_FRACTION);
 649   gst_value_set_fraction (&value1, 2, 3);
 650   g_value_init (&value2, GST_TYPE_FRACTION);
 651   gst_value_set_fraction (&value2, 3, 4);
 652   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 653   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 654   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 655   g_value_unset (&value1);
 656   g_value_unset (&value2);
 657
 658   /* comparing -4/5 with 2/-3 */
 659   g_value_init (&value1, GST_TYPE_FRACTION);
 660   gst_value_set_fraction (&value1, -4, 5);
 661   g_value_init (&value2, GST_TYPE_FRACTION);
 662   gst_value_set_fraction (&value2, 2, -3);
 663   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 664   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 665   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 666   g_value_unset (&value1);
 667   g_value_unset (&value2);
 668
 669   /* comparing 10/100 with 200/2000 */
 670   g_value_init (&value1, GST_TYPE_FRACTION);
 671   gst_value_set_fraction (&value1, 10, 100);
 672   g_value_init (&value2, GST_TYPE_FRACTION);
 673   gst_value_set_fraction (&value2, 200, 2000);
 674   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL);
 675   g_value_unset (&value1);
 676   g_value_unset (&value2);
 677
 678   /* comparing -4/5 with 2/-3 */
 679   g_value_init (&value1, GST_TYPE_FRACTION);
 680   gst_value_set_fraction (&value1, -4, 5);
 681   g_value_init (&value2, GST_TYPE_FRACTION);
 682   gst_value_set_fraction (&value2, 2, -3);
 683   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 684   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 685   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 686   g_value_unset (&value1);
 687   g_value_unset (&value2);
 688
 689   /* Check that lists are equal regardless of order */
 690   g_value_init (&value1, GST_TYPE_LIST);
 691   g_value_init (&tmp, G_TYPE_INT);
 692   g_value_set_int (&tmp, 1);
 693   gst_value_list_append_value (&value1, &tmp);
 694   g_value_set_int (&tmp, 2);
 695   gst_value_list_append_value (&value1, &tmp);
 696   g_value_set_int (&tmp, 3);
 697   gst_value_list_append_value (&value1, &tmp);
 698   g_value_set_int (&tmp, 4);
 699   gst_value_list_append_value (&value1, &tmp);
 700
 701   g_value_init (&value2, GST_TYPE_LIST);
 702   g_value_set_int (&tmp, 4);
 703   gst_value_list_append_value (&value2, &tmp);
 704   g_value_set_int (&tmp, 3);
 705   gst_value_list_append_value (&value2, &tmp);
 706   g_value_set_int (&tmp, 2);
 707   gst_value_list_append_value (&value2, &tmp);
 708   g_value_set_int (&tmp, 1);
 709   gst_value_list_append_value (&value2, &tmp);
 710
 711   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 712       "value lists with different order were not equal when they should be");
 713   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL,
 714       "value lists with same order were not equal when they should be");
 715   fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL,
 716       "value lists with same order were not equal when they should be");
 717
 718   /* Carry over the lists to this next check: */
 719   /* Lists with different sizes are unequal */
 720   g_value_set_int (&tmp, 1);
 721   gst_value_list_append_value (&value2, &tmp);
 722
 723   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 724       "Value lists with different size were equal when they shouldn't be");
 725
 726   /* Carry over the lists to this next check: */
 727   /* Lists with same size but list1 contains one more element not in list2 */
 728   g_value_set_int (&tmp, 5);
 729   gst_value_list_append_value (&value1, &tmp);
 730
 731   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 732       "Value lists with different elements were equal when they shouldn't be");
 733   fail_if (gst_value_compare (&value2, &value1) == GST_VALUE_EQUAL,
 734       "Value lists with different elements were equal when they shouldn't be");
 735
 736   g_value_unset (&value1);
 737   g_value_unset (&value2);
 738   g_value_unset (&tmp);
 739
 740   /* Arrays are only equal when in the same order */
 741   g_value_init (&value1, GST_TYPE_ARRAY);
 742   g_value_init (&tmp, G_TYPE_INT);
 743   g_value_set_int (&tmp, 1);
 744   gst_value_array_append_value (&value1, &tmp);
 745   g_value_set_int (&tmp, 2);
 746   gst_value_array_append_value (&value1, &tmp);
 747   g_value_set_int (&tmp, 3);
 748   gst_value_array_append_value (&value1, &tmp);
 749   g_value_set_int (&tmp, 4);
 750   gst_value_array_append_value (&value1, &tmp);
 751
 752   g_value_init (&value2, GST_TYPE_ARRAY);
 753   g_value_set_int (&tmp, 4);
 754   gst_value_array_append_value (&value2, &tmp);
 755   g_value_set_int (&tmp, 3);
 756   gst_value_array_append_value (&value2, &tmp);
 757   g_value_set_int (&tmp, 2);
 758   gst_value_array_append_value (&value2, &tmp);
 759   g_value_set_int (&tmp, 1);
 760   gst_value_array_append_value (&value2, &tmp);
 761
 762   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 763       "Value arrays with different order were equal when they shouldn't be");
 764   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL,
 765       "Identical value arrays were not equal when they should be");
 766   fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL,
 767       "Identical value arrays were not equal when they should be");
 768
 769   /* Carry over the arrays to this next check: */
 770   /* Arrays with different sizes are unequal */
 771   g_value_unset (&value2);
 772   g_value_init (&value2, GST_TYPE_ARRAY);
 773   g_value_copy (&value1, &value2);
 774
 775   g_value_set_int (&tmp, 1);
 776   gst_value_array_append_value (&value2, &tmp);
 777
 778   fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
 779       "Value arrays with different size were equal when they shouldn't be");
 780   /* order should not matter */
 781   fail_if (gst_value_compare (&value2, &value1) == GST_VALUE_EQUAL,
 782       "Value arrays with different size 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
 789 GST_END_TEST;
 790
 791 GST_START_TEST (test_value_intersect)
 792 {
 793   GValue dest = { 0 };
 794   GValue src1 = { 0 };
 795   GValue src2 = { 0 };
 796   GValue item = { 0 };
 797   gboolean ret;
 798
 799   g_value_init (&src1, G_TYPE_INT);
 800   g_value_set_int (&src1, 10);
 801   g_value_init (&src2, G_TYPE_INT);
 802   g_value_set_int (&src2, 20);
 803   ret = gst_value_intersect (&dest, &src1, &src2);
 804   fail_unless (ret == FALSE);
 805   g_value_unset (&src1);
 806   g_value_unset (&src2);
 807
 808   g_value_init (&src1, GST_TYPE_FOURCC);
 809   gst_value_set_fourcc (&src1, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 810   g_value_init (&src2, GST_TYPE_LIST);
 811   g_value_init (&item, GST_TYPE_FOURCC);
 812   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 813   gst_value_list_append_value (&src2, &item);
 814   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('I', '4', '2', '0'));
 815   gst_value_list_append_value (&src2, &item);
 816   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('A', 'B', 'C', 'D'));
 817   gst_value_list_append_value (&src2, &item);
 818
 819   fail_unless (gst_value_intersect (&dest, &src1, &src2));
 820   fail_unless (GST_VALUE_HOLDS_FOURCC (&dest));
 821   fail_unless (gst_value_get_fourcc (&dest) ==
 822       GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 823
 824   g_value_unset (&src1);
 825   g_value_unset (&src2);
 826 }
 827
 828 GST_END_TEST;
 829
 830
 831 GST_START_TEST (test_value_subtract_int)
 832 {
 833   GValue dest = { 0 };
 834   GValue src1 = { 0 };
 835   GValue src2 = { 0 };
 836   const GValue *tmp;
 837   gboolean ret;
 838
 839   /*  int <-> int
 840    */
 841   g_value_init (&src1, G_TYPE_INT);
 842   g_value_set_int (&src1, 10);
 843   g_value_init (&src2, G_TYPE_INT);
 844   g_value_set_int (&src2, 20);
 845   /* subtract as in sets, result is 10 */
 846   ret = gst_value_subtract (&dest, &src1, &src2);
 847   fail_unless (ret == TRUE);
 848   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 849   g_value_unset (&dest);
 850
 851   /* same values, yields empty set */
 852   ret = gst_value_subtract (&dest, &src1, &src1);
 853   fail_unless (ret == FALSE);
 854   g_value_unset (&src1);
 855   g_value_unset (&src2);
 856
 857   /*  int <-> int_range
 858    */
 859
 860   /* would yield an empty set */
 861   g_value_init (&src1, G_TYPE_INT);
 862   g_value_set_int (&src1, 10);
 863   g_value_init (&src2, GST_TYPE_INT_RANGE);
 864   gst_value_set_int_range (&src2, 0, 20);
 865   ret = gst_value_subtract (&dest, &src1, &src2);
 866   fail_unless (ret == FALSE);
 867
 868   /* and the other way around, should create a list of two ranges. */
 869   ret = gst_value_subtract (&dest, &src2, &src1);
 870   fail_unless (ret == TRUE);
 871   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 872   tmp = gst_value_list_get_value (&dest, 0);
 873   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 874   fail_unless (gst_value_get_int_range_min (tmp) == 0);
 875   fail_unless (gst_value_get_int_range_max (tmp) == 9);
 876   tmp = gst_value_list_get_value (&dest, 1);
 877   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 878   fail_unless (gst_value_get_int_range_min (tmp) == 11);
 879   fail_unless (gst_value_get_int_range_max (tmp) == 20);
 880   g_value_unset (&dest);
 881   g_value_unset (&src1);
 882   g_value_unset (&src2);
 883
 884   /* border case 1, empty set */
 885   g_value_init (&src1, G_TYPE_INT);
 886   g_value_set_int (&src1, 10);
 887   g_value_init (&src2, GST_TYPE_INT_RANGE);
 888   gst_value_set_int_range (&src2, 10, 20);
 889   ret = gst_value_subtract (&dest, &src1, &src2);
 890   fail_unless (ret == FALSE);
 891
 892   /* and the other way around, should create a new range. */
 893   ret = gst_value_subtract (&dest, &src2, &src1);
 894   fail_unless (ret == TRUE);
 895   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 896   fail_unless (gst_value_get_int_range_min (&dest) == 11);
 897   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 898   g_value_unset (&dest);
 899   g_value_unset (&src1);
 900   g_value_unset (&src2);
 901
 902   /* border case 2, empty set */
 903   g_value_init (&src1, G_TYPE_INT);
 904   g_value_set_int (&src1, 20);
 905   g_value_init (&src2, GST_TYPE_INT_RANGE);
 906   gst_value_set_int_range (&src2, 10, 20);
 907   ret = gst_value_subtract (&dest, &src1, &src2);
 908   fail_unless (ret == FALSE);
 909
 910   /* and the other way around, should create a new range. */
 911   ret = gst_value_subtract (&dest, &src2, &src1);
 912   fail_unless (ret == TRUE);
 913   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 914   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 915   fail_unless (gst_value_get_int_range_max (&dest) == 19);
 916   g_value_unset (&dest);
 917   g_value_unset (&src1);
 918   g_value_unset (&src2);
 919
 920   /* case 3, valid set */
 921   g_value_init (&src1, G_TYPE_INT);
 922   g_value_set_int (&src1, 0);
 923   g_value_init (&src2, GST_TYPE_INT_RANGE);
 924   gst_value_set_int_range (&src2, 10, 20);
 925   ret = gst_value_subtract (&dest, &src1, &src2);
 926   fail_unless (ret == TRUE);
 927   fail_unless (G_VALUE_HOLDS_INT (&dest) == TRUE);
 928   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 929   g_value_unset (&dest);
 930
 931   /* and the other way around, should keep the range. */
 932   ret = gst_value_subtract (&dest, &src2, &src1);
 933   fail_unless (ret == TRUE);
 934   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 935   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 936   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 937   g_value_unset (&dest);
 938   g_value_unset (&src1);
 939   g_value_unset (&src2);
 940
 941   /*  int_range <-> int_range
 942    */
 943
 944   /* same range, empty set */
 945   g_value_init (&src1, GST_TYPE_INT_RANGE);
 946   gst_value_set_int_range (&src1, 10, 20);
 947   g_value_init (&src2, GST_TYPE_INT_RANGE);
 948   gst_value_set_int_range (&src2, 10, 20);
 949   ret = gst_value_subtract (&dest, &src1, &src2);
 950   fail_unless (ret == FALSE);
 951   ret = gst_value_subtract (&dest, &src2, &src1);
 952   fail_unless (ret == FALSE);
 953   g_value_unset (&src1);
 954   g_value_unset (&src2);
 955
 956   /* non overlapping ranges */
 957   g_value_init (&src1, GST_TYPE_INT_RANGE);
 958   gst_value_set_int_range (&src1, 10, 20);
 959   g_value_init (&src2, GST_TYPE_INT_RANGE);
 960   gst_value_set_int_range (&src2, 30, 40);
 961   ret = gst_value_subtract (&dest, &src1, &src2);
 962   fail_unless (ret == TRUE);
 963   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 964   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 965   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 966   g_value_unset (&dest);
 967   /* the other way */
 968   ret = gst_value_subtract (&dest, &src2, &src1);
 969   fail_unless (ret == TRUE);
 970   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 971   fail_unless (gst_value_get_int_range_min (&dest) == 30);
 972   fail_unless (gst_value_get_int_range_max (&dest) == 40);
 973   g_value_unset (&dest);
 974   g_value_unset (&src1);
 975   g_value_unset (&src2);
 976
 977   /* completely overlapping ranges */
 978   g_value_init (&src1, GST_TYPE_INT_RANGE);
 979   gst_value_set_int_range (&src1, 10, 20);
 980   g_value_init (&src2, GST_TYPE_INT_RANGE);
 981   gst_value_set_int_range (&src2, 10, 30);
 982   ret = gst_value_subtract (&dest, &src1, &src2);
 983   fail_unless (ret == FALSE);
 984   /* the other way */
 985   ret = gst_value_subtract (&dest, &src2, &src1);
 986   fail_unless (ret == TRUE);
 987   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 988   fail_unless (gst_value_get_int_range_min (&dest) == 21);
 989   fail_unless (gst_value_get_int_range_max (&dest) == 30);
 990   g_value_unset (&dest);
 991   g_value_unset (&src1);
 992   g_value_unset (&src2);
 993
 994   /* partially overlapping ranges */
 995   g_value_init (&src1, GST_TYPE_INT_RANGE);
 996   gst_value_set_int_range (&src1, 10, 20);
 997   g_value_init (&src2, GST_TYPE_INT_RANGE);
 998   gst_value_set_int_range (&src2, 15, 30);
 999   ret = gst_value_subtract (&dest, &src1, &src2);
1000   fail_unless (ret == TRUE);
1001   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1002   fail_unless (gst_value_get_int_range_min (&dest) == 10);
1003   fail_unless (gst_value_get_int_range_max (&dest) == 14);
1004   g_value_unset (&dest);
1005   /* the other way */
1006   ret = gst_value_subtract (&dest, &src2, &src1);
1007   fail_unless (ret == TRUE);
1008   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1009   fail_unless (gst_value_get_int_range_min (&dest) == 21);
1010   fail_unless (gst_value_get_int_range_max (&dest) == 30);
1011   g_value_unset (&dest);
1012   g_value_unset (&src1);
1013   g_value_unset (&src2);
1014
1015   /* create a hole { int_range, int_range } */
1016   g_value_init (&src1, GST_TYPE_INT_RANGE);
1017   gst_value_set_int_range (&src1, 10, 30);
1018   g_value_init (&src2, GST_TYPE_INT_RANGE);
1019   gst_value_set_int_range (&src2, 15, 20);
1020   ret = gst_value_subtract (&dest, &src1, &src2);
1021   fail_unless (ret == TRUE);
1022   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1023   tmp = gst_value_list_get_value (&dest, 0);
1024   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1025   fail_unless (gst_value_get_int_range_min (tmp) == 10);
1026   fail_unless (gst_value_get_int_range_max (tmp) == 14);
1027   tmp = gst_value_list_get_value (&dest, 1);
1028   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1029   fail_unless (gst_value_get_int_range_min (tmp) == 21);
1030   fail_unless (gst_value_get_int_range_max (tmp) == 30);
1031   g_value_unset (&dest);
1032   /* the other way */
1033   ret = gst_value_subtract (&dest, &src2, &src1);
1034   fail_unless (ret == FALSE);
1035   g_value_unset (&src1);
1036   g_value_unset (&src2);
1037
1038   /* create a hole, { int, int } */
1039   g_value_init (&src1, GST_TYPE_INT_RANGE);
1040   gst_value_set_int_range (&src1, 10, 30);
1041   g_value_init (&src2, GST_TYPE_INT_RANGE);
1042   gst_value_set_int_range (&src2, 11, 29);
1043   ret = gst_value_subtract (&dest, &src1, &src2);
1044   fail_unless (ret == TRUE);
1045   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1046   tmp = gst_value_list_get_value (&dest, 0);
1047   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1048   fail_unless (g_value_get_int (tmp) == 10);
1049   tmp = gst_value_list_get_value (&dest, 1);
1050   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1051   fail_unless (g_value_get_int (tmp) == 30);
1052   g_value_unset (&dest);
1053   /* the other way */
1054   ret = gst_value_subtract (&dest, &src2, &src1);
1055   fail_unless (ret == FALSE);
1056   g_value_unset (&src1);
1057   g_value_unset (&src2);
1058
1059   /* create a hole, { int, int_range } */
1060   g_value_init (&src1, GST_TYPE_INT_RANGE);
1061   gst_value_set_int_range (&src1, 10, 30);
1062   g_value_init (&src2, GST_TYPE_INT_RANGE);
1063   gst_value_set_int_range (&src2, 11, 28);
1064   ret = gst_value_subtract (&dest, &src1, &src2);
1065   fail_unless (ret == TRUE);
1066   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1067   tmp = gst_value_list_get_value (&dest, 0);
1068   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1069   fail_unless (g_value_get_int (tmp) == 10);
1070   tmp = gst_value_list_get_value (&dest, 1);
1071   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1072   fail_unless (gst_value_get_int_range_min (tmp) == 29);
1073   fail_unless (gst_value_get_int_range_max (tmp) == 30);
1074   g_value_unset (&dest);
1075   /* the other way */
1076   ret = gst_value_subtract (&dest, &src2, &src1);
1077   fail_unless (ret == FALSE);
1078   g_value_unset (&src1);
1079   g_value_unset (&src2);
1080
1081   /* create a hole, { int_range, int } */
1082   g_value_init (&src1, GST_TYPE_INT_RANGE);
1083   gst_value_set_int_range (&src1, 10, 30);
1084   g_value_init (&src2, GST_TYPE_INT_RANGE);
1085   gst_value_set_int_range (&src2, 12, 29);
1086   ret = gst_value_subtract (&dest, &src1, &src2);
1087   fail_unless (ret == TRUE);
1088   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1089   tmp = gst_value_list_get_value (&dest, 0);
1090   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1091   fail_unless (gst_value_get_int_range_min (tmp) == 10);
1092   fail_unless (gst_value_get_int_range_max (tmp) == 11);
1093   tmp = gst_value_list_get_value (&dest, 1);
1094   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1095   fail_unless (g_value_get_int (tmp) == 30);
1096   g_value_unset (&dest);
1097   /* the other way */
1098   ret = gst_value_subtract (&dest, &src2, &src1);
1099   fail_unless (ret == FALSE);
1100   g_value_unset (&src1);
1101   g_value_unset (&src2);
1102 }
1103
1104 GST_END_TEST;
1105
1106 GST_START_TEST (test_value_subtract_double)
1107 {
1108   GValue dest = { 0 };
1109   GValue src1 = { 0 };
1110   GValue src2 = { 0 };
1111   const GValue *tmp;
1112   gboolean ret;
1113
1114   /*  double <-> double
1115    */
1116   g_value_init (&src1, G_TYPE_DOUBLE);
1117   g_value_set_double (&src1, 10.0);
1118   g_value_init (&src2, G_TYPE_DOUBLE);
1119   g_value_set_double (&src2, 20.0);
1120   /* subtract as in sets, result is 10 */
1121   ret = gst_value_subtract (&dest, &src1, &src2);
1122   fail_unless (ret == TRUE);
1123   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1124   g_value_unset (&dest);
1125
1126   /* same values, yields empty set */
1127   ret = gst_value_subtract (&dest, &src1, &src1);
1128   fail_unless (ret == FALSE);
1129   g_value_unset (&src1);
1130   g_value_unset (&src2);
1131
1132   /*  double <-> double_range
1133    */
1134
1135   /* would yield an empty set */
1136   g_value_init (&src1, G_TYPE_DOUBLE);
1137   g_value_set_double (&src1, 10.0);
1138   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1139   gst_value_set_double_range (&src2, 0.0, 20.0);
1140   ret = gst_value_subtract (&dest, &src1, &src2);
1141   fail_unless (ret == FALSE);
1142
1143   /* and the other way around, we cannot create open ranges
1144    * so the result is the range again */
1145   ret = gst_value_subtract (&dest, &src2, &src1);
1146   fail_unless (ret == TRUE);
1147   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1148   fail_unless (gst_value_get_double_range_min (&dest) == 0.0);
1149   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1150   g_value_unset (&dest);
1151   g_value_unset (&src1);
1152   g_value_unset (&src2);
1153
1154   /* border case 1, empty set */
1155   g_value_init (&src1, G_TYPE_DOUBLE);
1156   g_value_set_double (&src1, 10.0);
1157   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1158   gst_value_set_double_range (&src2, 10.0, 20.0);
1159   ret = gst_value_subtract (&dest, &src1, &src2);
1160   fail_unless (ret == FALSE);
1161
1162   /* and the other way around, should keep same range as
1163    * we don't have open ranges. */
1164   ret = gst_value_subtract (&dest, &src2, &src1);
1165   fail_unless (ret == TRUE);
1166   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1167   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1168   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1169   g_value_unset (&dest);
1170   g_value_unset (&src1);
1171   g_value_unset (&src2);
1172
1173   /* border case 2, empty set */
1174   g_value_init (&src1, G_TYPE_DOUBLE);
1175   g_value_set_double (&src1, 20.0);
1176   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1177   gst_value_set_double_range (&src2, 10.0, 20.0);
1178   ret = gst_value_subtract (&dest, &src1, &src2);
1179   fail_unless (ret == FALSE);
1180
1181   /* and the other way around, should keep same range as
1182    * we don't have open ranges. */
1183   ret = gst_value_subtract (&dest, &src2, &src1);
1184   fail_unless (ret == TRUE);
1185   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1186   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1187   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1188   g_value_unset (&dest);
1189   g_value_unset (&src1);
1190   g_value_unset (&src2);
1191
1192   /* case 3, valid set */
1193   g_value_init (&src1, G_TYPE_DOUBLE);
1194   g_value_set_double (&src1, 0.0);
1195   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1196   gst_value_set_double_range (&src2, 10.0, 20.0);
1197   ret = gst_value_subtract (&dest, &src1, &src2);
1198   fail_unless (ret == TRUE);
1199   fail_unless (G_VALUE_HOLDS_DOUBLE (&dest) == TRUE);
1200   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1201   g_value_unset (&dest);
1202
1203   /* and the other way around, should keep the range. */
1204   ret = gst_value_subtract (&dest, &src2, &src1);
1205   fail_unless (ret == TRUE);
1206   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1207   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1208   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1209   g_value_unset (&dest);
1210   g_value_unset (&src1);
1211   g_value_unset (&src2);
1212
1213   /*  double_range <-> double_range
1214    */
1215
1216   /* same range, empty set */
1217   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1218   gst_value_set_double_range (&src1, 10.0, 20.0);
1219   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1220   gst_value_set_double_range (&src2, 10.0, 20.0);
1221   ret = gst_value_subtract (&dest, &src1, &src2);
1222   fail_unless (ret == FALSE);
1223   ret = gst_value_subtract (&dest, &src2, &src1);
1224   fail_unless (ret == FALSE);
1225   g_value_unset (&src1);
1226   g_value_unset (&src2);
1227
1228   /* non overlapping ranges */
1229   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1230   gst_value_set_double_range (&src1, 10.0, 20.0);
1231   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1232   gst_value_set_double_range (&src2, 30.0, 40.0);
1233   ret = gst_value_subtract (&dest, &src1, &src2);
1234   fail_unless (ret == TRUE);
1235   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1236   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1237   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1238   g_value_unset (&dest);
1239   /* the other way */
1240   ret = gst_value_subtract (&dest, &src2, &src1);
1241   fail_unless (ret == TRUE);
1242   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1243   fail_unless (gst_value_get_double_range_min (&dest) == 30.0);
1244   fail_unless (gst_value_get_double_range_max (&dest) == 40.0);
1245   g_value_unset (&dest);
1246   g_value_unset (&src1);
1247   g_value_unset (&src2);
1248
1249   /* completely overlapping ranges */
1250   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1251   gst_value_set_double_range (&src1, 10.0, 20.0);
1252   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1253   gst_value_set_double_range (&src2, 10.0, 30.0);
1254   ret = gst_value_subtract (&dest, &src1, &src2);
1255   fail_unless (ret == FALSE);
1256   /* the other way */
1257   ret = gst_value_subtract (&dest, &src2, &src1);
1258   fail_unless (ret == TRUE);
1259   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1260   fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
1261   fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
1262   g_value_unset (&dest);
1263   g_value_unset (&src1);
1264   g_value_unset (&src2);
1265
1266   /* partially overlapping ranges */
1267   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1268   gst_value_set_double_range (&src1, 10.0, 20.0);
1269   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1270   gst_value_set_double_range (&src2, 15.0, 30.0);
1271   ret = gst_value_subtract (&dest, &src1, &src2);
1272   fail_unless (ret == TRUE);
1273   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1274   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1275   fail_unless (gst_value_get_double_range_max (&dest) == 15.0);
1276   g_value_unset (&dest);
1277   /* the other way */
1278   ret = gst_value_subtract (&dest, &src2, &src1);
1279   fail_unless (ret == TRUE);
1280   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1281   fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
1282   fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
1283   g_value_unset (&dest);
1284   g_value_unset (&src1);
1285   g_value_unset (&src2);
1286
1287   /* create a hole { double_range, double_range } */
1288   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1289   gst_value_set_double_range (&src1, 10.0, 30.0);
1290   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1291   gst_value_set_double_range (&src2, 15.0, 20.0);
1292   ret = gst_value_subtract (&dest, &src1, &src2);
1293   fail_unless (ret == TRUE);
1294   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1295   tmp = gst_value_list_get_value (&dest, 0);
1296   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
1297   fail_unless (gst_value_get_double_range_min (tmp) == 10.0);
1298   fail_unless (gst_value_get_double_range_max (tmp) == 15.0);
1299   tmp = gst_value_list_get_value (&dest, 1);
1300   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
1301   fail_unless (gst_value_get_double_range_min (tmp) == 20.0);
1302   fail_unless (gst_value_get_double_range_max (tmp) == 30.0);
1303   g_value_unset (&dest);
1304   /* the other way */
1305   ret = gst_value_subtract (&dest, &src2, &src1);
1306   fail_unless (ret == FALSE);
1307   g_value_unset (&src1);
1308   g_value_unset (&src2);
1309 }
1310
1311 GST_END_TEST;
1312
1313 /* Test arithmetic subtraction of fractions */
1314 GST_START_TEST (test_value_subtract_fraction)
1315 {
1316   GValue result = { 0 };
1317   GValue src1 = { 0 };
1318   GValue src2 = { 0 };
1319
1320   /* Subtract 1/4 from 1/2 */
1321   g_value_init (&src1, GST_TYPE_FRACTION);
1322   g_value_init (&src2, GST_TYPE_FRACTION);
1323   g_value_init (&result, GST_TYPE_FRACTION);
1324   gst_value_set_fraction (&src1, 1, 2);
1325   gst_value_set_fraction (&src2, 1, 4);
1326   fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1327   fail_unless (gst_value_get_fraction_numerator (&result) == 1);
1328   fail_unless (gst_value_get_fraction_denominator (&result) == 4);
1329
1330   g_value_unset (&src1);
1331   g_value_unset (&src2);
1332   g_value_unset (&result);
1333
1334   /* Subtract 1/12 from 7/8 */
1335   g_value_init (&src1, GST_TYPE_FRACTION);
1336   g_value_init (&src2, GST_TYPE_FRACTION);
1337   g_value_init (&result, GST_TYPE_FRACTION);
1338   gst_value_set_fraction (&src1, 7, 8);
1339   gst_value_set_fraction (&src2, 1, 12);
1340   fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1341   fail_unless (gst_value_get_fraction_numerator (&result) == 19);
1342   fail_unless (gst_value_get_fraction_denominator (&result) == 24);
1343
1344   g_value_unset (&src1);
1345   g_value_unset (&src2);
1346   g_value_unset (&result);
1347
1348   /* Subtract 12/13 from 4/3 */
1349   g_value_init (&src1, GST_TYPE_FRACTION);
1350   g_value_init (&src2, GST_TYPE_FRACTION);
1351   g_value_init (&result, GST_TYPE_FRACTION);
1352   gst_value_set_fraction (&src1, 4, 3);
1353   gst_value_set_fraction (&src2, 12, 13);
1354   fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1355   fail_unless (gst_value_get_fraction_numerator (&result) == 16);
1356   fail_unless (gst_value_get_fraction_denominator (&result) == 39);
1357
1358   g_value_unset (&src1);
1359   g_value_unset (&src2);
1360   g_value_unset (&result);
1361
1362   /* Subtract 1/12 from 7/8 */
1363 }
1364
1365 GST_END_TEST;
1366
1367 /* Test set subtraction operations on fraction ranges */
1368 GST_START_TEST (test_value_subtract_fraction_range)
1369 {
1370   GValue dest = { 0 };
1371   GValue src1 = { 0 };
1372   GValue src2 = { 0 };
1373   GValue cmp = { 0 };
1374   const GValue *tmp;
1375   gboolean ret;
1376
1377   /* Value for tests */
1378   g_value_init (&cmp, GST_TYPE_FRACTION);
1379
1380   /*  fraction <-> fraction
1381    */
1382   g_value_init (&src1, GST_TYPE_FRACTION);
1383   gst_value_set_fraction (&src1, 10, 1);
1384   g_value_init (&src2, GST_TYPE_FRACTION);
1385   gst_value_set_fraction (&src2, 20, 1);
1386   gst_value_set_fraction (&src1, 10, 1);
1387
1388   /* subtract as in sets, result is 10 */
1389   ret = gst_value_subtract (&dest, &src1, &src2);
1390   fail_unless (ret == TRUE);
1391   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1392   g_value_unset (&dest);
1393
1394   /* same values, yields empty set */
1395   ret = gst_value_subtract (&dest, &src1, &src1);
1396   fail_unless (ret == FALSE);
1397   g_value_unset (&src1);
1398   g_value_unset (&src2);
1399
1400   /*  fraction <-> fraction_range
1401    */
1402
1403   /* would yield an empty set */
1404   g_value_init (&src1, GST_TYPE_FRACTION);
1405   gst_value_set_fraction (&src1, 10, 1);
1406   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1407   gst_value_set_fraction_range_full (&src2, 0, 1, 20, 1);
1408   ret = gst_value_subtract (&dest, &src1, &src2);
1409   fail_unless (ret == FALSE);
1410
1411   /* and the other way around, we cannot create open ranges
1412    * so the result is the range again */
1413   ret = gst_value_subtract (&dest, &src2, &src1);
1414   fail_unless (ret == TRUE);
1415   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1416   gst_value_set_fraction (&cmp, 0, 1);
1417   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1418           &cmp) == GST_VALUE_EQUAL);
1419   gst_value_set_fraction (&cmp, 20, 1);
1420   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1421           &cmp) == GST_VALUE_EQUAL);
1422   g_value_unset (&dest);
1423   g_value_unset (&src1);
1424   g_value_unset (&src2);
1425
1426   /* border case 1, empty set */
1427   g_value_init (&src1, GST_TYPE_FRACTION);
1428   gst_value_set_fraction (&src1, 10, 1);
1429   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1430   gst_value_set_fraction_range_full (&src2, 10, 1, 20, 1);
1431   ret = gst_value_subtract (&dest, &src1, &src2);
1432   fail_unless (ret == FALSE);
1433
1434   /* and the other way around, should keep same range as
1435    * we don't have open ranges. */
1436   ret = gst_value_subtract (&dest, &src2, &src1);
1437   fail_unless (ret == TRUE);
1438   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1439   gst_value_set_fraction (&cmp, 10, 1);
1440   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1441           &cmp) == GST_VALUE_EQUAL);
1442   gst_value_set_fraction (&cmp, 20, 1);
1443   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1444           &cmp) == GST_VALUE_EQUAL);
1445   g_value_unset (&dest);
1446   g_value_unset (&src1);
1447   g_value_unset (&src2);
1448
1449   /* case 2, valid set */
1450   g_value_init (&src1, GST_TYPE_FRACTION);
1451   gst_value_set_fraction (&src1, 0, 1);
1452   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1453   gst_value_set_fraction_range_full (&src2, 10, 1, 20, 1);
1454   ret = gst_value_subtract (&dest, &src1, &src2);
1455   fail_unless (ret == TRUE);
1456   fail_unless (GST_VALUE_HOLDS_FRACTION (&dest) == TRUE);
1457   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1458   g_value_unset (&dest);
1459
1460   /* and the other way around, should keep the range. */
1461   ret = gst_value_subtract (&dest, &src2, &src1);
1462   fail_unless (ret == TRUE);
1463   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1464   fail_unless (gst_value_compare (&dest, &src2) == GST_VALUE_EQUAL);
1465   g_value_unset (&dest);
1466   g_value_unset (&src1);
1467   g_value_unset (&src2);
1468
1469   /*  fraction_range <-> fraction_range
1470    */
1471
1472   /* same range, empty set */
1473   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1474   gst_value_set_fraction_range_full (&src1, 10, 2, 20, 2);
1475   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1476   gst_value_set_fraction_range_full (&src2, 10, 2, 20, 2);
1477   ret = gst_value_subtract (&dest, &src1, &src2);
1478   fail_unless (ret == FALSE);
1479   ret = gst_value_subtract (&dest, &src2, &src1);
1480   fail_unless (ret == FALSE);
1481   g_value_unset (&src1);
1482   g_value_unset (&src2);
1483
1484   /* non overlapping ranges */
1485   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1486   gst_value_set_fraction_range_full (&src1, 10, 2, 10, 1);
1487   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1488   gst_value_set_fraction_range_full (&src2, 30, 2, 40, 2);
1489   ret = gst_value_subtract (&dest, &src1, &src2);
1490   fail_unless (ret == TRUE);
1491   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1492   gst_value_set_fraction (&cmp, 5, 1);
1493   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1494           &cmp) == GST_VALUE_EQUAL);
1495   gst_value_set_fraction (&cmp, 10, 1);
1496   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1497           &cmp) == GST_VALUE_EQUAL);
1498
1499   g_value_unset (&dest);
1500   /* the other way */
1501   ret = gst_value_subtract (&dest, &src2, &src1);
1502   fail_unless (ret == TRUE);
1503   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1504   gst_value_set_fraction (&cmp, 15, 1);
1505   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1506           &cmp) == GST_VALUE_EQUAL);
1507   gst_value_set_fraction (&cmp, 20, 1);
1508   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1509           &cmp) == GST_VALUE_EQUAL);
1510   g_value_unset (&dest);
1511   g_value_unset (&src1);
1512   g_value_unset (&src2);
1513
1514   /* completely overlapping ranges */
1515   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1516   gst_value_set_fraction_range_full (&src1, 10, 1, 20, 1);
1517   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1518   gst_value_set_fraction_range_full (&src2, 10, 1, 30, 1);
1519   ret = gst_value_subtract (&dest, &src1, &src2);
1520   fail_unless (ret == FALSE);
1521   /* the other way */
1522   ret = gst_value_subtract (&dest, &src2, &src1);
1523   fail_unless (ret == TRUE);
1524   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1525   gst_value_set_fraction (&cmp, 20, 1);
1526   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1527           &cmp) == GST_VALUE_EQUAL);
1528   gst_value_set_fraction (&cmp, 30, 1);
1529   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1530           &cmp) == GST_VALUE_EQUAL);
1531   g_value_unset (&dest);
1532   g_value_unset (&src1);
1533   g_value_unset (&src2);
1534
1535   /* partially overlapping ranges */
1536   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1537   gst_value_set_fraction_range_full (&src1, 10, 1, 20, 1);
1538   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1539   gst_value_set_fraction_range_full (&src2, 15, 1, 30, 1);
1540   ret = gst_value_subtract (&dest, &src1, &src2);
1541   fail_unless (ret == TRUE);
1542   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1543   gst_value_set_fraction (&cmp, 10, 1);
1544   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1545           &cmp) == GST_VALUE_EQUAL);
1546   gst_value_set_fraction (&cmp, 15, 1);
1547   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1548           &cmp) == GST_VALUE_EQUAL);
1549   g_value_unset (&dest);
1550
1551   /* the other way */
1552   ret = gst_value_subtract (&dest, &src2, &src1);
1553   fail_unless (ret == TRUE);
1554   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1555   gst_value_set_fraction (&cmp, 20, 1);
1556   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1557           &cmp) == GST_VALUE_EQUAL);
1558   gst_value_set_fraction (&cmp, 30, 1);
1559   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1560           &cmp) == GST_VALUE_EQUAL);
1561   g_value_unset (&dest);
1562   g_value_unset (&src1);
1563   g_value_unset (&src2);
1564
1565   /* create a hole { double_range, double_range } */
1566   g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1567   gst_value_set_fraction_range_full (&src1, 10, 1, 30, 1);
1568   g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1569   gst_value_set_fraction_range_full (&src2, 15, 1, 20, 1);
1570   ret = gst_value_subtract (&dest, &src1, &src2);
1571   fail_unless (ret == TRUE);
1572   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1573   /* 1st list entry */
1574   tmp = gst_value_list_get_value (&dest, 0);
1575   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (tmp) == TRUE);
1576   gst_value_set_fraction (&cmp, 10, 1);
1577   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (tmp),
1578           &cmp) == GST_VALUE_EQUAL);
1579   gst_value_set_fraction (&cmp, 15, 1);
1580   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (tmp),
1581           &cmp) == GST_VALUE_EQUAL);
1582   /* 2nd list entry */
1583   tmp = gst_value_list_get_value (&dest, 1);
1584   fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (tmp) == TRUE);
1585   gst_value_set_fraction (&cmp, 20, 1);
1586   fail_unless (gst_value_compare (gst_value_get_fraction_range_min (tmp),
1587           &cmp) == GST_VALUE_EQUAL);
1588   gst_value_set_fraction (&cmp, 30, 1);
1589   fail_unless (gst_value_compare (gst_value_get_fraction_range_max (tmp),
1590           &cmp) == GST_VALUE_EQUAL);
1591   g_value_unset (&dest);
1592   /* the other way */
1593   ret = gst_value_subtract (&dest, &src2, &src1);
1594   fail_unless (ret == FALSE);
1595   g_value_unset (&src1);
1596   g_value_unset (&src2);
1597
1598   g_value_unset (&cmp);
1599 }
1600
1601 GST_END_TEST;
1602
1603 /* Test set subtraction operations on fraction lists */
1604 GST_START_TEST (test_value_subtract_fraction_list)
1605 {
1606   GValue list1 = { 0 };
1607   GValue list2 = { 0 };
1608   GValue val1 = { 0 };
1609   GValue val2 = { 0 };
1610   GValue tmp = { 0 };
1611   gboolean ret;
1612
1613   g_value_init (&list1, GST_TYPE_LIST);
1614   g_value_init (&val1, GST_TYPE_FRACTION);
1615   gst_value_set_fraction (&val1, 15, 2);
1616   gst_value_list_append_value (&list1, &val1);
1617   g_value_init (&tmp, GST_TYPE_FRACTION);
1618   gst_value_set_fraction (&tmp, 5, 1);
1619   gst_value_list_append_value (&list1, &tmp);
1620   g_value_unset (&tmp);
1621
1622   g_value_init (&list2, GST_TYPE_LIST);
1623   g_value_init (&val2, GST_TYPE_FRACTION);
1624   gst_value_set_fraction (&val2, 15, 1);
1625   gst_value_list_append_value (&list2, &val2);
1626   g_value_init (&tmp, GST_TYPE_FRACTION);
1627   gst_value_set_fraction (&tmp, 5, 1);
1628   gst_value_list_append_value (&list2, &tmp);
1629   g_value_unset (&tmp);
1630
1631   /* should subtract all common elements */
1632   ret = gst_value_subtract (&tmp, &list1, &list2);
1633   fail_unless (ret == TRUE);
1634   fail_unless (gst_value_compare (&tmp, &val1) == GST_VALUE_EQUAL);
1635   g_value_unset (&val1);
1636   g_value_unset (&tmp);
1637
1638   ret = gst_value_subtract (&tmp, &list2, &list1);
1639   fail_unless (ret == TRUE);
1640   fail_unless (gst_value_compare (&tmp, &val2) == GST_VALUE_EQUAL);
1641   g_value_unset (&val2);
1642   g_value_unset (&tmp);
1643
1644   g_value_unset (&list1);
1645   g_value_unset (&list2);
1646 }
1647
1648 GST_END_TEST;
1649
1650
1651 GST_START_TEST (test_date)
1652 {
1653   GstStructure *s;
1654   GDate *date, *date2;
1655   gchar *str;
1656
1657   date = g_date_new_dmy (22, 9, 2005);
1658
1659   s = gst_structure_new ("media/x-type", "SOME_DATE_TAG", GST_TYPE_DATE,
1660       date, NULL);
1661
1662   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
1663           GST_TYPE_DATE));
1664   fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date2));
1665   fail_unless (date2 != NULL);
1666   fail_unless (g_date_valid (date2));
1667   fail_unless (g_date_compare (date, date2) == 0);
1668
1669   g_date_free (date);
1670   g_date_free (date2);
1671   date = NULL;
1672   date2 = NULL;
1673
1674   str = gst_structure_to_string (s);
1675   gst_structure_free (s);
1676   s = NULL;
1677
1678   fail_unless (g_str_equal (str,
1679           "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22;"));
1680
1681   s = gst_structure_from_string (str, NULL);
1682   g_free (str);
1683   str = NULL;
1684
1685   fail_unless (s != NULL);
1686   fail_unless (gst_structure_has_name (s, "media/x-type"));
1687   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
1688           GST_TYPE_DATE));
1689   fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date));
1690   fail_unless (date != NULL);
1691   fail_unless (g_date_valid (date));
1692   fail_unless (g_date_get_day (date) == 22);
1693   fail_unless (g_date_get_month (date) == 9);
1694   fail_unless (g_date_get_year (date) == 2005);
1695   g_date_free (date);
1696   date = NULL;
1697
1698   str = gst_structure_to_string (s);
1699   gst_structure_free (s);
1700   s = NULL;
1701
1702   fail_unless (g_str_equal (str,
1703           "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22;"));
1704   g_free (str);
1705   str = NULL;
1706 }
1707
1708 GST_END_TEST;
1709
1710 GST_START_TEST (test_fraction_range)
1711 {
1712   GValue range = { 0, };
1713   GValue start = { 0, }, end = {
1714   0,};
1715   GValue src = { 0, }, dest = {
1716   0,};
1717   GValue range2 = { 0, };
1718
1719   g_value_init (&range, GST_TYPE_FRACTION_RANGE);
1720   g_value_init (&range2, GST_TYPE_FRACTION_RANGE);
1721   g_value_init (&start, GST_TYPE_FRACTION);
1722   g_value_init (&end, GST_TYPE_FRACTION);
1723   g_value_init (&src, GST_TYPE_FRACTION);
1724
1725   gst_value_set_fraction (&src, 1, 2);
1726
1727   /* Check that a intersection of fraction & range = fraction */
1728   gst_value_set_fraction (&start, 1, 4);
1729   gst_value_set_fraction (&end, 2, 3);
1730   gst_value_set_fraction_range (&range, &start, &end);
1731
1732   fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
1733   fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION);
1734   fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
1735
1736   /* Check that a intersection selects the overlapping range */
1737   gst_value_set_fraction (&start, 1, 3);
1738   gst_value_set_fraction (&end, 2, 3);
1739   gst_value_set_fraction_range (&range2, &start, &end);
1740   g_value_unset (&dest);
1741   fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
1742   fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
1743
1744   gst_value_set_fraction_range (&range2, &start, &end);
1745   fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
1746
1747   /* Check that non intersection ranges don't intersect */
1748   gst_value_set_fraction (&start, 4, 2);
1749   gst_value_set_fraction (&end, 5, 2);
1750   gst_value_set_fraction_range (&range2, &start, &end);
1751   g_value_unset (&dest);
1752   fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
1753
1754   g_value_unset (&start);
1755   g_value_unset (&end);
1756   g_value_unset (&range);
1757   g_value_unset (&range2);
1758   g_value_unset (&src);
1759 }
1760
1761 GST_END_TEST;
1762
1763 GST_START_TEST (test_serialize_deserialize_format_enum)
1764 {
1765   GstStructure *s, *s2;
1766   GstFormat foobar_fmt;
1767   gchar *str, *str2, *end = NULL;
1768
1769   /* make sure custom formats are serialised properly as well */
1770   foobar_fmt = gst_format_register ("foobar", "GST_FORMAT_FOOBAR");
1771   fail_unless (foobar_fmt != GST_FORMAT_UNDEFINED);
1772
1773   s = gst_structure_new ("foo/bar", "format1", GST_TYPE_FORMAT,
1774       GST_FORMAT_BYTES, "format2", GST_TYPE_FORMAT, GST_FORMAT_TIME,
1775       "format3", GST_TYPE_FORMAT, GST_FORMAT_DEFAULT, "format4",
1776       GST_TYPE_FORMAT, foobar_fmt, NULL);
1777
1778   str = gst_structure_to_string (s);
1779   GST_LOG ("Got structure string '%s'", GST_STR_NULL (str));
1780   fail_unless (str != NULL);
1781   fail_unless (strstr (str, "TIME") != NULL);
1782   fail_unless (strstr (str, "BYTE") != NULL);
1783   fail_unless (strstr (str, "DEFAULT") != NULL);
1784   fail_unless (strstr (str, "FOOBAR") != NULL);
1785
1786   s2 = gst_structure_from_string (str, &end);
1787   fail_unless (s2 != NULL);
1788
1789   str2 = gst_structure_to_string (s2);
1790   fail_unless (str2 != NULL);
1791
1792   fail_unless (g_str_equal (str, str2));
1793
1794   g_free (str);
1795   g_free (str2);
1796   gst_structure_free (s);
1797   gst_structure_free (s2);
1798 }
1799
1800 GST_END_TEST;
1801
1802 GST_START_TEST (test_serialize_deserialize_caps)
1803 {
1804   GValue value = { 0 }, value2 = {
1805   0};
1806   GstCaps *caps, *caps2;
1807   gchar *serialized;
1808
1809   caps = gst_caps_new_simple ("test/caps",
1810       "foo", G_TYPE_INT, 10, "bar", G_TYPE_STRING, "test", NULL);
1811   fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
1812
1813   /* and assign caps to gvalue */
1814   g_value_init (&value, GST_TYPE_CAPS);
1815   g_value_take_boxed (&value, caps);
1816   fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
1817
1818   /* now serialize it */
1819   serialized = gst_value_serialize (&value);
1820   GST_DEBUG ("serialized caps to %s", serialized);
1821   fail_unless (serialized != NULL);
1822
1823   /* refcount should not change */
1824   fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
1825
1826   /* now deserialize again */
1827   g_value_init (&value2, GST_TYPE_CAPS);
1828   gst_value_deserialize (&value2, serialized);
1829
1830   caps2 = g_value_get_boxed (&value2);
1831   fail_if (GST_CAPS_REFCOUNT_VALUE (caps2) != 1);
1832
1833   /* they should be equal */
1834   fail_unless (gst_caps_is_equal (caps, caps2));
1835
1836   /* cleanup */
1837   g_value_unset (&value);
1838   g_value_unset (&value2);
1839   g_free (serialized);
1840 }
1841
1842 GST_END_TEST;
1843
1844 static Suite *
1845 gst_value_suite (void)
1846 {
1847   Suite *s = suite_create ("GstValue");
1848   TCase *tc_chain = tcase_create ("general");
1849
1850   suite_add_tcase (s, tc_chain);
1851   tcase_add_test (tc_chain, test_serialize_fourcc);
1852   tcase_add_test (tc_chain, test_deserialize_fourcc);
1853   tcase_add_test (tc_chain, test_deserialize_buffer);
1854   tcase_add_test (tc_chain, test_serialize_buffer);
1855   tcase_add_test (tc_chain, test_deserialize_gint);
1856   tcase_add_test (tc_chain, test_deserialize_gint_failures);
1857   tcase_add_test (tc_chain, test_deserialize_guint);
1858   tcase_add_test (tc_chain, test_deserialize_guint_failures);
1859   tcase_add_test (tc_chain, test_deserialize_gint64);
1860   tcase_add_test (tc_chain, test_deserialize_guint64);
1861   tcase_add_test (tc_chain, test_deserialize_gstfraction);
1862   tcase_add_test (tc_chain, test_serialize_flags);
1863   tcase_add_test (tc_chain, test_deserialize_flags);
1864   tcase_add_test (tc_chain, test_serialize_deserialize_format_enum);
1865   tcase_add_test (tc_chain, test_string);
1866   tcase_add_test (tc_chain, test_deserialize_string);
1867   tcase_add_test (tc_chain, test_value_compare);
1868   tcase_add_test (tc_chain, test_value_intersect);
1869   tcase_add_test (tc_chain, test_value_subtract_int);
1870   tcase_add_test (tc_chain, test_value_subtract_double);
1871   tcase_add_test (tc_chain, test_value_subtract_fraction);
1872   tcase_add_test (tc_chain, test_value_subtract_fraction_range);
1873   tcase_add_test (tc_chain, test_value_subtract_fraction_list);
1874   tcase_add_test (tc_chain, test_date);
1875   tcase_add_test (tc_chain, test_fraction_range);
1876   tcase_add_test (tc_chain, test_serialize_deserialize_caps);
1877
1878   return s;
1879 }
1880
1881 GST_CHECK_MAIN (gst_value);