tests/check/gst/gstvalue.c

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