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