check/gst/gstvalue.c

   1 /* GStreamer
   2  * Copyright (C) <2004> David Schleef <david at schleef dot org>
   3  * Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
   4  *
   5  * gstvalue.c: Unit tests for GstValue
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23
  24 #include <gst/check/gstcheck.h>
  25
  26
  27 GST_START_TEST (test_deserialize_buffer)
  28 {
  29   GValue value = { 0 };
  30   GstBuffer *buf;
  31
  32   g_value_init (&value, GST_TYPE_BUFFER);
  33   fail_unless (gst_value_deserialize (&value, "1234567890abcdef"));
  34   buf = GST_BUFFER (gst_value_get_mini_object (&value));
  35
  36   ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
  37
  38   /* cleanup */
  39   gst_buffer_unref (buf);
  40 }
  41
  42 GST_END_TEST;
  43
  44 GST_START_TEST (test_deserialize_gint64)
  45 {
  46   GValue value = { 0 };
  47   const char *strings[] = {
  48     "12345678901",
  49     "-12345678901",
  50   };
  51   gint64 results[] = {
  52     12345678901LL,
  53     -12345678901LL,
  54   };
  55   int i;
  56
  57   g_value_init (&value, G_TYPE_INT64);
  58
  59   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
  60     fail_unless (gst_value_deserialize (&value, strings[i]),
  61         "could not deserialize %s (%d)", strings[i], i);
  62     fail_unless (g_value_get_int64 (&value) == results[i],
  63         "resulting value is %" G_GINT64_FORMAT ", not %" G_GINT64_FORMAT
  64         ", for string %s (%d)", value, results[i], strings[i], i);
  65   }
  66 }
  67
  68 GST_END_TEST;
  69
  70 GST_START_TEST (test_deserialize_gint)
  71 {
  72   GValue value = { 0 };
  73   const char *strings[] = {
  74     "123456",
  75     "-123456",
  76     "0xFFFF",
  77     "0x0000FFFF",
  78     /* a positive long long, serializing to highest possible positive sint */
  79     "0x7FFFFFFF",
  80     /* a positive long long, serializing to lowest possible negative sint */
  81     "0x80000000",
  82     /* a negative long long, serializing to lowest possible negative sint */
  83     "0xFFFFFFFF80000000",
  84     "0xFF000000",
  85     /* a positive long long serializing to -1 */
  86     "0xFFFFFFFF",
  87     "0xFFFFFFFF",
  88     /* a negative long long serializing to -1 */
  89     "0xFFFFFFFFFFFFFFFF",
  90     "0xFFFFFFFFFFFFFFFF",
  91     "0xEFFFFFFF",
  92   };
  93   gint results[] = {
  94     123456,
  95     -123456,
  96     0xFFFF,
  97     0xFFFF,
  98     0x7FFFFFFF,
  99     0x80000000,
 100     0x80000000,
 101     0xFF000000,
 102     -1,
 103     0xFFFFFFFF,
 104     -1,
 105     /* cast needs to be explicit because of unsigned -> signed */
 106     (gint) 0xFFFFFFFFFFFFFFFFLL,
 107     0xEFFFFFFF,
 108   };
 109   int i;
 110
 111   g_value_init (&value, G_TYPE_INT);
 112
 113   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 114     fail_unless (gst_value_deserialize (&value, strings[i]),
 115         "could not deserialize %s (%d)", strings[i], i);
 116     fail_unless (g_value_get_int (&value) == results[i],
 117         "resulting value is %d, not %d, for string %s (%d)",
 118         g_value_get_int (&value), results[i], strings[i], i);
 119   }
 120 }
 121
 122 GST_END_TEST;
 123
 124 GST_START_TEST (test_deserialize_gint_failures)
 125 {
 126   GValue value = { 0 };
 127   const char *strings[] = {
 128     "-",                        /* not a complete number */
 129     "- TEST",                   /* not a complete number */
 130     "0x0000000100000000",       /* lowest long long that cannot fit in 32 bits */
 131     "0xF000000000000000",
 132     "0xFFFFFFF000000000",
 133     "0xFFFFFFFF00000000",
 134     "0x10000000000000000",      /* first number too long to fit into a long long */
 135     /* invent a new processor first before trying to make this one pass */
 136     "0x10000000000000000000000000000000000000000000",
 137   };
 138   int i;
 139
 140   g_value_init (&value, G_TYPE_INT);
 141
 142   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 143     fail_if (gst_value_deserialize (&value, strings[i]),
 144         "deserialized %s (%d), while it should have failed", strings[i], i);
 145   }
 146 }
 147
 148 GST_END_TEST;
 149
 150 GST_START_TEST (test_deserialize_guint)
 151 {
 152   GValue value = { 0 };
 153   const char *strings[] = {
 154     "123456",
 155     "-123456",
 156     "0xFFFF",
 157     "0x0000FFFF",
 158     /* a positive long long, serializing to highest possible positive sint */
 159     "0x7FFFFFFF",
 160     /* a positive long long, serializing to lowest possible negative sint */
 161     "0x80000000",
 162     "2147483648",
 163     /* a negative long long, serializing to lowest possible negative sint */
 164     "0xFFFFFFFF80000000",
 165     /* a value typically used for rgb masks */
 166     "0xFF000000",
 167     /* a positive long long serializing to highest possible positive uint */
 168     "0xFFFFFFFF",
 169     "0xFFFFFFFF",
 170     /* a negative long long serializing to highest possible positive uint */
 171     "0xFFFFFFFFFFFFFFFF",
 172     "0xEFFFFFFF",
 173   };
 174   guint results[] = {
 175     123456,
 176     -123456,
 177     0xFFFF,
 178     0xFFFF,
 179     0x7FFFFFFF,
 180     0x80000000,
 181     (guint) 2147483648LL,
 182     0x80000000,
 183     0xFF000000,
 184     0xFFFFFFFF,
 185     G_MAXUINT,
 186     (guint) 0xFFFFFFFFFFFFFFFFLL,
 187     0xEFFFFFFF,
 188   };
 189   int i;
 190
 191   g_value_init (&value, G_TYPE_UINT);
 192
 193   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 194     fail_unless (gst_value_deserialize (&value, strings[i]),
 195         "could not deserialize %s (%d)", strings[i], i);
 196     fail_unless (g_value_get_uint (&value) == results[i],
 197         "resulting value is %d, not %d, for string %s (%d)",
 198         g_value_get_uint (&value), results[i], strings[i], i);
 199   }
 200 }
 201
 202 GST_END_TEST;
 203
 204 GST_START_TEST (test_deserialize_guint_failures)
 205 {
 206   GValue value = { 0 };
 207   const char *strings[] = {
 208     "-",                        /* not a complete number */
 209     "- TEST",                   /* not a complete number */
 210 #if 0
 211 /* FIXME: these values should not be deserializable, since they overflow
 212  * the target format */
 213     "0x0000000100000000",       /* lowest long long that cannot fit in 32 bits */
 214     "0xF000000000000000",
 215     "0xFFFFFFF000000000",
 216     "0xFFFFFFFF00000000",
 217     "0x10000000000000000",      /* first number too long to fit into a long long */
 218     /* invent a new processor first before trying to make this one pass */
 219     "0x10000000000000000000000000000000000000000000",
 220 #endif
 221   };
 222   int i;
 223
 224   g_value_init (&value, G_TYPE_UINT);
 225
 226   for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
 227     fail_if (gst_value_deserialize (&value, strings[i]),
 228         "deserialized %s (%d), while it should have failed", strings[i], i);
 229   }
 230 }
 231
 232 GST_END_TEST;
 233
 234
 235 GST_START_TEST (test_string)
 236 {
 237   gchar *try[] = {
 238     "Dude",
 239     "Hi, I'm a string",
 240     "tüüüt!"
 241   };
 242   gchar *tmp;
 243   GValue v = { 0, };
 244   guint i;
 245
 246   g_value_init (&v, G_TYPE_STRING);
 247   for (i = 0; i < G_N_ELEMENTS (try); i++) {
 248     g_value_set_string (&v, try[i]);
 249     tmp = gst_value_serialize (&v);
 250     fail_if (tmp == NULL, "couldn't serialize: %s\n", try[i]);
 251     fail_unless (gst_value_deserialize (&v, tmp),
 252         "couldn't deserialize: %s\n", tmp);
 253     g_free (tmp);
 254
 255     fail_unless (g_str_equal (g_value_get_string (&v), try[i]),
 256         "\nserialized  : %s\ndeserialized: %s", try[i],
 257         g_value_get_string (&v));
 258   }
 259   /* NULL strings should not be serializable */
 260   g_value_set_string (&v, NULL);
 261   fail_unless (gst_value_serialize (&v) == NULL);
 262   g_value_unset (&v);
 263 }
 264
 265 GST_END_TEST;
 266
 267 GST_START_TEST (test_deserialize_string)
 268 {
 269   struct
 270   {
 271     gchar *from;
 272     gchar *to;
 273   } tests[] = {
 274     {
 275     "", ""},                    /* empty strings */
 276     {
 277     "\"\"", ""},                /* FAILURES */
 278     {
 279     "\"", NULL},                /* missing second quote */
 280     {
 281     "\"Hello\\ World", NULL},   /* missing second quote */
 282     {
 283     "\"\\", NULL},              /* quote at end, missing second quote */
 284     {
 285     "\"\\0", NULL},             /* missing second quote */
 286     {
 287     "\"\\0\"", NULL},           /* unfinished escaped character */
 288     {
 289     "\" \"", NULL},             /* spaces must be escaped */
 290 #if 0
 291         /* FIXME 0.9: this test should fail, but it doesn't */
 292     {
 293     "tüüt", NULL}             /* string with special chars must be escaped */
 294 #endif
 295   };
 296   guint i;
 297   GValue v = { 0, };
 298   gboolean ret = TRUE;
 299
 300   g_value_init (&v, G_TYPE_STRING);
 301   for (i = 0; i < G_N_ELEMENTS (tests); i++) {
 302     if (gst_value_deserialize (&v, tests[i].from)) {
 303       fail_if (tests[i].to == NULL,
 304           "I got %s instead of a failure", g_value_get_string (&v));
 305       fail_unless (g_str_equal (g_value_get_string (&v), tests[i].to),
 306           "\nwanted: %s\ngot    : %s", tests[i].to, g_value_get_string (&v));
 307     } else {
 308       fail_if (tests[i].to != NULL, "failed, but wanted: %s", tests[i].to);
 309       ret = FALSE;
 310     }
 311   }
 312   g_value_unset (&v);
 313 }
 314
 315 GST_END_TEST;
 316
 317 GST_START_TEST (test_value_compare)
 318 {
 319   GValue value1 = { 0 };
 320   GValue value2 = { 0 };
 321
 322   g_value_init (&value1, G_TYPE_INT);
 323   g_value_set_int (&value1, 10);
 324   g_value_init (&value2, G_TYPE_INT);
 325   g_value_set_int (&value2, 20);
 326   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 327   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 328   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 329   g_value_unset (&value1);
 330   g_value_unset (&value2);
 331
 332   g_value_init (&value1, G_TYPE_DOUBLE);
 333   g_value_set_double (&value1, 10);
 334   g_value_init (&value2, G_TYPE_DOUBLE);
 335   g_value_set_double (&value2, 20);
 336   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 337   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 338   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 339   g_value_unset (&value1);
 340   g_value_unset (&value2);
 341
 342   g_value_init (&value1, G_TYPE_STRING);
 343   g_value_set_string (&value1, "a");
 344   g_value_init (&value2, G_TYPE_STRING);
 345   g_value_set_string (&value2, "b");
 346   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 347   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 348   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 349   g_value_unset (&value1);
 350   g_value_unset (&value2);
 351
 352   g_value_init (&value1, GST_TYPE_FOURCC);
 353   gst_value_set_fourcc (&value1, GST_MAKE_FOURCC ('a', 'b', 'c', 'd'));
 354   g_value_init (&value2, GST_TYPE_FOURCC);
 355   gst_value_set_fourcc (&value2, GST_MAKE_FOURCC ('1', '2', '3', '4'));
 356   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
 357   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 358   g_value_unset (&value1);
 359   g_value_unset (&value2);
 360
 361   /* comparing 2/3 with 3/4 */
 362   g_value_init (&value1, GST_TYPE_FRACTION);
 363   gst_value_set_fraction (&value1, 2, 3);
 364   g_value_init (&value2, GST_TYPE_FRACTION);
 365   gst_value_set_fraction (&value2, 3, 4);
 366   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 367   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 368   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 369   g_value_unset (&value1);
 370   g_value_unset (&value2);
 371
 372   /* comparing -4/5 with 2/-3 */
 373   g_value_init (&value1, GST_TYPE_FRACTION);
 374   gst_value_set_fraction (&value1, -4, 5);
 375   g_value_init (&value2, GST_TYPE_FRACTION);
 376   gst_value_set_fraction (&value2, 2, -3);
 377   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 378   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 379   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 380   g_value_unset (&value1);
 381   g_value_unset (&value2);
 382
 383   /* comparing 10/100 with 200/2000 */
 384   g_value_init (&value1, GST_TYPE_FRACTION);
 385   gst_value_set_fraction (&value1, 10, 100);
 386   g_value_init (&value2, GST_TYPE_FRACTION);
 387   gst_value_set_fraction (&value2, 200, 2000);
 388   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL);
 389   g_value_unset (&value1);
 390   g_value_unset (&value2);
 391
 392   /* comparing -4/5 with 2/-3 */
 393   g_value_init (&value1, GST_TYPE_FRACTION);
 394   gst_value_set_fraction (&value1, -4, 5);
 395   g_value_init (&value2, GST_TYPE_FRACTION);
 396   gst_value_set_fraction (&value2, 2, -3);
 397   fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
 398   fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
 399   fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
 400   g_value_unset (&value1);
 401   g_value_unset (&value2);
 402 }
 403
 404 GST_END_TEST;
 405
 406 GST_START_TEST (test_value_intersect)
 407 {
 408   GValue dest = { 0 };
 409   GValue src1 = { 0 };
 410   GValue src2 = { 0 };
 411   GValue item = { 0 };
 412   gboolean ret;
 413
 414   g_value_init (&src1, G_TYPE_INT);
 415   g_value_set_int (&src1, 10);
 416   g_value_init (&src2, G_TYPE_INT);
 417   g_value_set_int (&src2, 20);
 418   ret = gst_value_intersect (&dest, &src1, &src2);
 419   fail_unless (ret == FALSE);
 420   g_value_unset (&src1);
 421   g_value_unset (&src2);
 422
 423   g_value_init (&src1, GST_TYPE_FOURCC);
 424   gst_value_set_fourcc (&src1, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 425   g_value_init (&src2, GST_TYPE_LIST);
 426   g_value_init (&item, GST_TYPE_FOURCC);
 427   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 428   gst_value_list_append_value (&src2, &item);
 429   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('I', '4', '2', '0'));
 430   gst_value_list_append_value (&src2, &item);
 431   gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('A', 'B', 'C', 'D'));
 432   gst_value_list_append_value (&src2, &item);
 433
 434   fail_unless (gst_value_intersect (&dest, &src1, &src2));
 435   fail_unless (GST_VALUE_HOLDS_FOURCC (&dest));
 436   fail_unless (gst_value_get_fourcc (&dest) ==
 437       GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
 438 }
 439
 440 GST_END_TEST;
 441
 442
 443 GST_START_TEST (test_value_subtract_int)
 444 {
 445   GValue dest = { 0 };
 446   GValue src1 = { 0 };
 447   GValue src2 = { 0 };
 448   const GValue *tmp;
 449   gboolean ret;
 450
 451   /*  int <-> int
 452    */
 453   g_value_init (&src1, G_TYPE_INT);
 454   g_value_set_int (&src1, 10);
 455   g_value_init (&src2, G_TYPE_INT);
 456   g_value_set_int (&src2, 20);
 457   /* subtract as in sets, result is 10 */
 458   ret = gst_value_subtract (&dest, &src1, &src2);
 459   fail_unless (ret == TRUE);
 460   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 461   g_value_unset (&dest);
 462
 463   /* same values, yields empty set */
 464   ret = gst_value_subtract (&dest, &src1, &src1);
 465   fail_unless (ret == FALSE);
 466   g_value_unset (&src1);
 467   g_value_unset (&src2);
 468
 469   /*  int <-> int_range
 470    */
 471
 472   /* would yield an empty set */
 473   g_value_init (&src1, G_TYPE_INT);
 474   g_value_set_int (&src1, 10);
 475   g_value_init (&src2, GST_TYPE_INT_RANGE);
 476   gst_value_set_int_range (&src2, 0, 20);
 477   ret = gst_value_subtract (&dest, &src1, &src2);
 478   fail_unless (ret == FALSE);
 479
 480   /* and the other way around, should create a list of two ranges. */
 481   ret = gst_value_subtract (&dest, &src2, &src1);
 482   fail_unless (ret == TRUE);
 483   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 484   tmp = gst_value_list_get_value (&dest, 0);
 485   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 486   fail_unless (gst_value_get_int_range_min (tmp) == 0);
 487   fail_unless (gst_value_get_int_range_max (tmp) == 9);
 488   tmp = gst_value_list_get_value (&dest, 1);
 489   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 490   fail_unless (gst_value_get_int_range_min (tmp) == 11);
 491   fail_unless (gst_value_get_int_range_max (tmp) == 20);
 492   g_value_unset (&dest);
 493   g_value_unset (&src1);
 494   g_value_unset (&src2);
 495
 496   /* border case 1, empty set */
 497   g_value_init (&src1, G_TYPE_INT);
 498   g_value_set_int (&src1, 10);
 499   g_value_init (&src2, GST_TYPE_INT_RANGE);
 500   gst_value_set_int_range (&src2, 10, 20);
 501   ret = gst_value_subtract (&dest, &src1, &src2);
 502   fail_unless (ret == FALSE);
 503
 504   /* and the other way around, should create a new range. */
 505   ret = gst_value_subtract (&dest, &src2, &src1);
 506   fail_unless (ret == TRUE);
 507   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 508   fail_unless (gst_value_get_int_range_min (&dest) == 11);
 509   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 510   g_value_unset (&dest);
 511   g_value_unset (&src1);
 512   g_value_unset (&src2);
 513
 514   /* border case 2, empty set */
 515   g_value_init (&src1, G_TYPE_INT);
 516   g_value_set_int (&src1, 20);
 517   g_value_init (&src2, GST_TYPE_INT_RANGE);
 518   gst_value_set_int_range (&src2, 10, 20);
 519   ret = gst_value_subtract (&dest, &src1, &src2);
 520   fail_unless (ret == FALSE);
 521
 522   /* and the other way around, should create a new range. */
 523   ret = gst_value_subtract (&dest, &src2, &src1);
 524   fail_unless (ret == TRUE);
 525   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 526   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 527   fail_unless (gst_value_get_int_range_max (&dest) == 19);
 528   g_value_unset (&dest);
 529   g_value_unset (&src1);
 530   g_value_unset (&src2);
 531
 532   /* case 3, valid set */
 533   g_value_init (&src1, G_TYPE_INT);
 534   g_value_set_int (&src1, 0);
 535   g_value_init (&src2, GST_TYPE_INT_RANGE);
 536   gst_value_set_int_range (&src2, 10, 20);
 537   ret = gst_value_subtract (&dest, &src1, &src2);
 538   fail_unless (ret == TRUE);
 539   fail_unless (G_VALUE_HOLDS_INT (&dest) == TRUE);
 540   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 541   g_value_unset (&dest);
 542
 543   /* and the other way around, should keep the range. */
 544   ret = gst_value_subtract (&dest, &src2, &src1);
 545   fail_unless (ret == TRUE);
 546   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 547   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 548   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 549   g_value_unset (&dest);
 550   g_value_unset (&src1);
 551   g_value_unset (&src2);
 552
 553   /*  int_range <-> int_range
 554    */
 555
 556   /* same range, empty set */
 557   g_value_init (&src1, GST_TYPE_INT_RANGE);
 558   gst_value_set_int_range (&src1, 10, 20);
 559   g_value_init (&src2, GST_TYPE_INT_RANGE);
 560   gst_value_set_int_range (&src2, 10, 20);
 561   ret = gst_value_subtract (&dest, &src1, &src2);
 562   fail_unless (ret == FALSE);
 563   ret = gst_value_subtract (&dest, &src2, &src1);
 564   fail_unless (ret == FALSE);
 565   g_value_unset (&src1);
 566   g_value_unset (&src2);
 567
 568   /* non overlapping ranges */
 569   g_value_init (&src1, GST_TYPE_INT_RANGE);
 570   gst_value_set_int_range (&src1, 10, 20);
 571   g_value_init (&src2, GST_TYPE_INT_RANGE);
 572   gst_value_set_int_range (&src2, 30, 40);
 573   ret = gst_value_subtract (&dest, &src1, &src2);
 574   fail_unless (ret == TRUE);
 575   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 576   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 577   fail_unless (gst_value_get_int_range_max (&dest) == 20);
 578   g_value_unset (&dest);
 579   /* the other way */
 580   ret = gst_value_subtract (&dest, &src2, &src1);
 581   fail_unless (ret == TRUE);
 582   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 583   fail_unless (gst_value_get_int_range_min (&dest) == 30);
 584   fail_unless (gst_value_get_int_range_max (&dest) == 40);
 585   g_value_unset (&dest);
 586   g_value_unset (&src1);
 587   g_value_unset (&src2);
 588
 589   /* completely overlapping ranges */
 590   g_value_init (&src1, GST_TYPE_INT_RANGE);
 591   gst_value_set_int_range (&src1, 10, 20);
 592   g_value_init (&src2, GST_TYPE_INT_RANGE);
 593   gst_value_set_int_range (&src2, 10, 30);
 594   ret = gst_value_subtract (&dest, &src1, &src2);
 595   fail_unless (ret == FALSE);
 596   /* the other way */
 597   ret = gst_value_subtract (&dest, &src2, &src1);
 598   fail_unless (ret == TRUE);
 599   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 600   fail_unless (gst_value_get_int_range_min (&dest) == 21);
 601   fail_unless (gst_value_get_int_range_max (&dest) == 30);
 602   g_value_unset (&dest);
 603   g_value_unset (&src1);
 604   g_value_unset (&src2);
 605
 606   /* partially overlapping ranges */
 607   g_value_init (&src1, GST_TYPE_INT_RANGE);
 608   gst_value_set_int_range (&src1, 10, 20);
 609   g_value_init (&src2, GST_TYPE_INT_RANGE);
 610   gst_value_set_int_range (&src2, 15, 30);
 611   ret = gst_value_subtract (&dest, &src1, &src2);
 612   fail_unless (ret == TRUE);
 613   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 614   fail_unless (gst_value_get_int_range_min (&dest) == 10);
 615   fail_unless (gst_value_get_int_range_max (&dest) == 14);
 616   g_value_unset (&dest);
 617   /* the other way */
 618   ret = gst_value_subtract (&dest, &src2, &src1);
 619   fail_unless (ret == TRUE);
 620   fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
 621   fail_unless (gst_value_get_int_range_min (&dest) == 21);
 622   fail_unless (gst_value_get_int_range_max (&dest) == 30);
 623   g_value_unset (&dest);
 624   g_value_unset (&src1);
 625   g_value_unset (&src2);
 626
 627   /* create a hole { int_range, int_range } */
 628   g_value_init (&src1, GST_TYPE_INT_RANGE);
 629   gst_value_set_int_range (&src1, 10, 30);
 630   g_value_init (&src2, GST_TYPE_INT_RANGE);
 631   gst_value_set_int_range (&src2, 15, 20);
 632   ret = gst_value_subtract (&dest, &src1, &src2);
 633   fail_unless (ret == TRUE);
 634   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 635   tmp = gst_value_list_get_value (&dest, 0);
 636   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 637   fail_unless (gst_value_get_int_range_min (tmp) == 10);
 638   fail_unless (gst_value_get_int_range_max (tmp) == 14);
 639   tmp = gst_value_list_get_value (&dest, 1);
 640   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 641   fail_unless (gst_value_get_int_range_min (tmp) == 21);
 642   fail_unless (gst_value_get_int_range_max (tmp) == 30);
 643   g_value_unset (&dest);
 644   /* the other way */
 645   ret = gst_value_subtract (&dest, &src2, &src1);
 646   fail_unless (ret == FALSE);
 647   g_value_unset (&src1);
 648   g_value_unset (&src2);
 649
 650   /* create a hole, { int, int } */
 651   g_value_init (&src1, GST_TYPE_INT_RANGE);
 652   gst_value_set_int_range (&src1, 10, 30);
 653   g_value_init (&src2, GST_TYPE_INT_RANGE);
 654   gst_value_set_int_range (&src2, 11, 29);
 655   ret = gst_value_subtract (&dest, &src1, &src2);
 656   fail_unless (ret == TRUE);
 657   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 658   tmp = gst_value_list_get_value (&dest, 0);
 659   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
 660   fail_unless (g_value_get_int (tmp) == 10);
 661   tmp = gst_value_list_get_value (&dest, 1);
 662   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
 663   fail_unless (g_value_get_int (tmp) == 30);
 664   g_value_unset (&dest);
 665   /* the other way */
 666   ret = gst_value_subtract (&dest, &src2, &src1);
 667   fail_unless (ret == FALSE);
 668   g_value_unset (&src1);
 669   g_value_unset (&src2);
 670
 671   /* create a hole, { int, int_range } */
 672   g_value_init (&src1, GST_TYPE_INT_RANGE);
 673   gst_value_set_int_range (&src1, 10, 30);
 674   g_value_init (&src2, GST_TYPE_INT_RANGE);
 675   gst_value_set_int_range (&src2, 11, 28);
 676   ret = gst_value_subtract (&dest, &src1, &src2);
 677   fail_unless (ret == TRUE);
 678   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 679   tmp = gst_value_list_get_value (&dest, 0);
 680   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
 681   fail_unless (g_value_get_int (tmp) == 10);
 682   tmp = gst_value_list_get_value (&dest, 1);
 683   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 684   fail_unless (gst_value_get_int_range_min (tmp) == 29);
 685   fail_unless (gst_value_get_int_range_max (tmp) == 30);
 686   g_value_unset (&dest);
 687   /* the other way */
 688   ret = gst_value_subtract (&dest, &src2, &src1);
 689   fail_unless (ret == FALSE);
 690   g_value_unset (&src1);
 691   g_value_unset (&src2);
 692
 693   /* create a hole, { int_range, int } */
 694   g_value_init (&src1, GST_TYPE_INT_RANGE);
 695   gst_value_set_int_range (&src1, 10, 30);
 696   g_value_init (&src2, GST_TYPE_INT_RANGE);
 697   gst_value_set_int_range (&src2, 12, 29);
 698   ret = gst_value_subtract (&dest, &src1, &src2);
 699   fail_unless (ret == TRUE);
 700   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 701   tmp = gst_value_list_get_value (&dest, 0);
 702   fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
 703   fail_unless (gst_value_get_int_range_min (tmp) == 10);
 704   fail_unless (gst_value_get_int_range_max (tmp) == 11);
 705   tmp = gst_value_list_get_value (&dest, 1);
 706   fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
 707   fail_unless (g_value_get_int (tmp) == 30);
 708   g_value_unset (&dest);
 709   /* the other way */
 710   ret = gst_value_subtract (&dest, &src2, &src1);
 711   fail_unless (ret == FALSE);
 712   g_value_unset (&src1);
 713   g_value_unset (&src2);
 714 }
 715
 716 GST_END_TEST;
 717
 718 GST_START_TEST (test_value_subtract_double)
 719 {
 720   GValue dest = { 0 };
 721   GValue src1 = { 0 };
 722   GValue src2 = { 0 };
 723   const GValue *tmp;
 724   gboolean ret;
 725
 726   /*  double <-> double
 727    */
 728   g_value_init (&src1, G_TYPE_DOUBLE);
 729   g_value_set_double (&src1, 10.0);
 730   g_value_init (&src2, G_TYPE_DOUBLE);
 731   g_value_set_double (&src2, 20.0);
 732   /* subtract as in sets, result is 10 */
 733   ret = gst_value_subtract (&dest, &src1, &src2);
 734   fail_unless (ret == TRUE);
 735   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 736   g_value_unset (&dest);
 737
 738   /* same values, yields empty set */
 739   ret = gst_value_subtract (&dest, &src1, &src1);
 740   fail_unless (ret == FALSE);
 741   g_value_unset (&src1);
 742   g_value_unset (&src2);
 743
 744   /*  double <-> double_range
 745    */
 746
 747   /* would yield an empty set */
 748   g_value_init (&src1, G_TYPE_DOUBLE);
 749   g_value_set_double (&src1, 10.0);
 750   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 751   gst_value_set_double_range (&src2, 0.0, 20.0);
 752   ret = gst_value_subtract (&dest, &src1, &src2);
 753   fail_unless (ret == FALSE);
 754
 755   /* and the other way around, we cannot create open ranges
 756    * so the result is the range again */
 757   ret = gst_value_subtract (&dest, &src2, &src1);
 758   fail_unless (ret == TRUE);
 759   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 760   fail_unless (gst_value_get_double_range_min (&dest) == 0.0);
 761   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
 762   g_value_unset (&dest);
 763   g_value_unset (&src1);
 764   g_value_unset (&src2);
 765
 766   /* border case 1, empty set */
 767   g_value_init (&src1, G_TYPE_DOUBLE);
 768   g_value_set_double (&src1, 10.0);
 769   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 770   gst_value_set_double_range (&src2, 10.0, 20.0);
 771   ret = gst_value_subtract (&dest, &src1, &src2);
 772   fail_unless (ret == FALSE);
 773
 774   /* and the other way around, should keep same range as
 775    * we don't have open ranges. */
 776   ret = gst_value_subtract (&dest, &src2, &src1);
 777   fail_unless (ret == TRUE);
 778   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 779   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
 780   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
 781   g_value_unset (&dest);
 782   g_value_unset (&src1);
 783   g_value_unset (&src2);
 784
 785   /* border case 2, empty set */
 786   g_value_init (&src1, G_TYPE_DOUBLE);
 787   g_value_set_double (&src1, 20.0);
 788   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 789   gst_value_set_double_range (&src2, 10.0, 20.0);
 790   ret = gst_value_subtract (&dest, &src1, &src2);
 791   fail_unless (ret == FALSE);
 792
 793   /* and the other way around, should keep same range as
 794    * we don't have open ranges. */
 795   ret = gst_value_subtract (&dest, &src2, &src1);
 796   fail_unless (ret == TRUE);
 797   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 798   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
 799   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
 800   g_value_unset (&dest);
 801   g_value_unset (&src1);
 802   g_value_unset (&src2);
 803
 804   /* case 3, valid set */
 805   g_value_init (&src1, G_TYPE_DOUBLE);
 806   g_value_set_double (&src1, 0.0);
 807   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 808   gst_value_set_double_range (&src2, 10.0, 20.0);
 809   ret = gst_value_subtract (&dest, &src1, &src2);
 810   fail_unless (ret == TRUE);
 811   fail_unless (G_VALUE_HOLDS_DOUBLE (&dest) == TRUE);
 812   fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
 813   g_value_unset (&dest);
 814
 815   /* and the other way around, should keep the range. */
 816   ret = gst_value_subtract (&dest, &src2, &src1);
 817   fail_unless (ret == TRUE);
 818   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 819   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
 820   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
 821   g_value_unset (&dest);
 822   g_value_unset (&src1);
 823   g_value_unset (&src2);
 824
 825   /*  double_range <-> double_range
 826    */
 827
 828   /* same range, empty set */
 829   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
 830   gst_value_set_double_range (&src1, 10.0, 20.0);
 831   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 832   gst_value_set_double_range (&src2, 10.0, 20.0);
 833   ret = gst_value_subtract (&dest, &src1, &src2);
 834   fail_unless (ret == FALSE);
 835   ret = gst_value_subtract (&dest, &src2, &src1);
 836   fail_unless (ret == FALSE);
 837   g_value_unset (&src1);
 838   g_value_unset (&src2);
 839
 840   /* non overlapping ranges */
 841   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
 842   gst_value_set_double_range (&src1, 10.0, 20.0);
 843   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 844   gst_value_set_double_range (&src2, 30.0, 40.0);
 845   ret = gst_value_subtract (&dest, &src1, &src2);
 846   fail_unless (ret == TRUE);
 847   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 848   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
 849   fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
 850   g_value_unset (&dest);
 851   /* the other way */
 852   ret = gst_value_subtract (&dest, &src2, &src1);
 853   fail_unless (ret == TRUE);
 854   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 855   fail_unless (gst_value_get_double_range_min (&dest) == 30.0);
 856   fail_unless (gst_value_get_double_range_max (&dest) == 40.0);
 857   g_value_unset (&dest);
 858   g_value_unset (&src1);
 859   g_value_unset (&src2);
 860
 861   /* completely overlapping ranges */
 862   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
 863   gst_value_set_double_range (&src1, 10.0, 20.0);
 864   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 865   gst_value_set_double_range (&src2, 10.0, 30.0);
 866   ret = gst_value_subtract (&dest, &src1, &src2);
 867   fail_unless (ret == FALSE);
 868   /* the other way */
 869   ret = gst_value_subtract (&dest, &src2, &src1);
 870   fail_unless (ret == TRUE);
 871   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 872   fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
 873   fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
 874   g_value_unset (&dest);
 875   g_value_unset (&src1);
 876   g_value_unset (&src2);
 877
 878   /* partially overlapping ranges */
 879   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
 880   gst_value_set_double_range (&src1, 10.0, 20.0);
 881   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 882   gst_value_set_double_range (&src2, 15.0, 30.0);
 883   ret = gst_value_subtract (&dest, &src1, &src2);
 884   fail_unless (ret == TRUE);
 885   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 886   fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
 887   fail_unless (gst_value_get_double_range_max (&dest) == 15.0);
 888   g_value_unset (&dest);
 889   /* the other way */
 890   ret = gst_value_subtract (&dest, &src2, &src1);
 891   fail_unless (ret == TRUE);
 892   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
 893   fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
 894   fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
 895   g_value_unset (&dest);
 896   g_value_unset (&src1);
 897   g_value_unset (&src2);
 898
 899   /* create a hole { double_range, double_range } */
 900   g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
 901   gst_value_set_double_range (&src1, 10.0, 30.0);
 902   g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
 903   gst_value_set_double_range (&src2, 15.0, 20.0);
 904   ret = gst_value_subtract (&dest, &src1, &src2);
 905   fail_unless (ret == TRUE);
 906   fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
 907   tmp = gst_value_list_get_value (&dest, 0);
 908   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
 909   fail_unless (gst_value_get_double_range_min (tmp) == 10.0);
 910   fail_unless (gst_value_get_double_range_max (tmp) == 15.0);
 911   tmp = gst_value_list_get_value (&dest, 1);
 912   fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
 913   fail_unless (gst_value_get_double_range_min (tmp) == 20.0);
 914   fail_unless (gst_value_get_double_range_max (tmp) == 30.0);
 915   g_value_unset (&dest);
 916   /* the other way */
 917   ret = gst_value_subtract (&dest, &src2, &src1);
 918   fail_unless (ret == FALSE);
 919   g_value_unset (&src1);
 920   g_value_unset (&src2);
 921 }
 922
 923 GST_END_TEST;
 924
 925 GST_START_TEST (test_date)
 926 {
 927   GstStructure *s;
 928   GDate *date, *date2;
 929   gchar *str;
 930
 931   date = g_date_new_dmy (22, 9, 2005);
 932
 933   s = gst_structure_new ("media/x-type", "SOME_DATE_TAG", GST_TYPE_DATE,
 934       date, NULL);
 935
 936   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
 937           GST_TYPE_DATE));
 938   fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date2));
 939   fail_unless (date2 != NULL);
 940   fail_unless (g_date_valid (date2));
 941   fail_unless (g_date_compare (date, date2) == 0);
 942
 943   g_date_free (date);
 944   g_date_free (date2);
 945   date = NULL;
 946   date2 = NULL;
 947
 948   str = gst_structure_to_string (s);
 949   gst_structure_free (s);
 950   s = NULL;
 951
 952   fail_unless (g_str_equal (str,
 953           "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22"));
 954
 955   s = gst_structure_from_string (str, NULL);
 956   g_free (str);
 957   str = NULL;
 958
 959   fail_unless (s != NULL);
 960   fail_unless (gst_structure_has_name (s, "media/x-type"));
 961   fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
 962           GST_TYPE_DATE));
 963   fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date));
 964   fail_unless (date != NULL);
 965   fail_unless (g_date_valid (date));
 966   fail_unless (g_date_get_day (date) == 22);
 967   fail_unless (g_date_get_month (date) == 9);
 968   fail_unless (g_date_get_year (date) == 2005);
 969   g_date_free (date);
 970   date = NULL;
 971
 972   str = gst_structure_to_string (s);
 973   gst_structure_free (s);
 974   s = NULL;
 975
 976   fail_unless (g_str_equal (str,
 977           "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22"));
 978   g_free (str);
 979   str = NULL;
 980 }
 981
 982 GST_END_TEST;
 983
 984 Suite *
 985 gst_value_suite (void)
 986 {
 987   Suite *s = suite_create ("GstValue");
 988   TCase *tc_chain = tcase_create ("general");
 989
 990   suite_add_tcase (s, tc_chain);
 991   tcase_add_test (tc_chain, test_deserialize_buffer);
 992   tcase_add_test (tc_chain, test_deserialize_gint);
 993   tcase_add_test (tc_chain, test_deserialize_gint_failures);
 994   tcase_add_test (tc_chain, test_deserialize_guint);
 995   tcase_add_test (tc_chain, test_deserialize_guint_failures);
 996   tcase_add_test (tc_chain, test_deserialize_gint64);
 997   tcase_add_test (tc_chain, test_string);
 998   tcase_add_test (tc_chain, test_deserialize_string);
 999   tcase_add_test (tc_chain, test_value_compare);
1000   tcase_add_test (tc_chain, test_value_intersect);
1001   tcase_add_test (tc_chain, test_value_subtract_int);
1002   tcase_add_test (tc_chain, test_value_subtract_double);
1003   tcase_add_test (tc_chain, test_date);
1004
1005   return s;
1006 }
1007
1008 int
1009 main (int argc, char **argv)
1010 {
1011   int nf;
1012
1013   Suite *s = gst_value_suite ();
1014   SRunner *sr = srunner_create (s);
1015
1016   gst_check_init (&argc, &argv);
1017
1018   srunner_run_all (sr, CK_NORMAL);
1019   nf = srunner_ntests_failed (sr);
1020   srunner_free (sr);
1021
1022   return nf;
1023 }