2 * Copyright (C) <2004> David Schleef <david at schleef dot org>
3 * Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
5 * gstvalue.c: Unit tests for GstValue
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.
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.
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.
24 #include <gst/check/gstcheck.h>
27 GST_START_TEST (test_serialize_fourcc)
32 GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'),
33 GST_MAKE_FOURCC ('Y', '8', '0', '0'),
34 GST_MAKE_FOURCC ('Y', '8', ' ', ' '),
35 GST_MAKE_FOURCC ('Y', '1', '6', ' '),
36 GST_MAKE_FOURCC ('Y', 'U', 'Y', '_'),
37 GST_MAKE_FOURCC ('Y', 'U', 'Y', '#'),
39 gint fourccs_size = sizeof (fourccs) / sizeof (fourccs[0]);
40 const gchar *fourcc_strings[] = {
45 "0x5f595559", /* Ascii values of YUY_ */
46 "0x23595559", /* Ascii values of YUY# */
48 gint fourcc_strings_size =
49 sizeof (fourcc_strings) / sizeof (fourcc_strings[0]);
51 fail_unless (fourccs_size == fourcc_strings_size);
53 for (i = 0; i < fourccs_size; ++i) {
56 g_value_init (&value, GST_TYPE_FOURCC);
58 gst_value_set_fourcc (&value, fourccs[i]);
59 str = gst_value_serialize (&value);
61 fail_unless (strcmp (str, fourcc_strings[i]) == 0);
69 GST_START_TEST (test_deserialize_fourcc)
74 GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'),
75 GST_MAKE_FOURCC ('Y', '8', '0', '0'),
76 GST_MAKE_FOURCC ('Y', '8', ' ', ' '),
77 GST_MAKE_FOURCC ('Y', '8', ' ', ' '),
78 GST_MAKE_FOURCC ('Y', '8', ' ', ' '),
79 GST_MAKE_FOURCC ('Y', '1', '6', ' '),
80 GST_MAKE_FOURCC ('Y', 'U', 'Y', '_'),
81 GST_MAKE_FOURCC ('Y', 'U', 'Y', '#'),
83 gint fourccs_size = sizeof (fourccs) / sizeof (fourccs[0]);
84 const gchar *fourcc_strings[] = {
91 "0x5f595559", /* Ascii values of YUY_ */
92 "0x23595559", /* Ascii values of YUY# */
94 gint fourcc_strings_size =
95 sizeof (fourcc_strings) / sizeof (fourcc_strings[0]);
97 fail_unless (fourccs_size == fourcc_strings_size);
99 for (i = 0; i < fourccs_size; ++i) {
100 GValue value = { 0 };
102 g_value_init (&value, GST_TYPE_FOURCC);
104 fail_unless (gst_value_deserialize (&value, fourcc_strings[i]));
105 fail_unless_equals_int (gst_value_get_fourcc (&value), fourccs[i]);
107 g_value_unset (&value);
113 GST_START_TEST (test_deserialize_buffer)
115 GValue value = { 0 };
118 g_value_init (&value, GST_TYPE_BUFFER);
119 fail_unless (gst_value_deserialize (&value, "1234567890abcdef"));
120 /* does not increase the refcount */
121 buf = GST_BUFFER (gst_value_get_mini_object (&value));
122 ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
124 /* does not increase the refcount */
125 buf = gst_value_get_buffer (&value);
126 ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
129 g_value_unset (&value);
134 /* create and serialize a buffer */
135 GST_START_TEST (test_serialize_buffer)
137 GValue value = { 0 };
140 static const char *buf_data = "1234567890abcdef";
143 len = strlen (buf_data);
144 buf = gst_buffer_new_and_alloc (len);
145 memcpy (GST_BUFFER_DATA (buf), buf_data, len);
146 ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
148 /* and assign buffer to mini object */
149 g_value_init (&value, GST_TYPE_BUFFER);
150 gst_value_take_buffer (&value, buf);
151 ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
153 /* now serialize it */
154 serialized = gst_value_serialize (&value);
155 GST_DEBUG ("serialized buffer to %s", serialized);
156 fail_unless (serialized != NULL);
158 /* refcount should not change */
159 ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
163 g_value_unset (&value);
165 /* take NULL buffer */
166 g_value_init (&value, GST_TYPE_BUFFER);
167 GST_DEBUG ("setting NULL buffer");
168 gst_value_take_buffer (&value, NULL);
170 /* now serialize it */
171 GST_DEBUG ("serializing NULL buffer");
172 serialized = gst_value_serialize (&value);
173 /* should return NULL */
174 fail_unless (serialized == NULL);
177 g_value_unset (&value);
182 GST_START_TEST (test_deserialize_gint64)
184 GValue value = { 0 };
185 const char *strings[] = {
188 "1152921504606846976",
189 "-1152921504606846976",
194 1152921504606846976LL,
195 -1152921504606846976LL,
199 g_value_init (&value, G_TYPE_INT64);
201 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
202 fail_unless (gst_value_deserialize (&value, strings[i]),
203 "could not deserialize %s (%d)", strings[i], i);
204 fail_unless (g_value_get_int64 (&value) == results[i],
205 "resulting value is %" G_GINT64_FORMAT ", not %" G_GINT64_FORMAT
206 ", for string %s (%d)", g_value_get_int64 (&value),
207 results[i], strings[i], i);
213 GST_START_TEST (test_deserialize_guint64)
215 GValue value = { 0 };
216 const char *strings[] = {
217 "0xffffffffffffffff",
218 "9223372036854775810",
219 "-9223372036854775810",
224 guint64 results[] = {
225 0xffffffffffffffffULL,
226 9223372036854775810ULL,
227 9223372036854775806ULL,
234 g_value_init (&value, G_TYPE_UINT64);
236 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
237 fail_unless (gst_value_deserialize (&value, strings[i]),
238 "could not deserialize %s (%d)", strings[i], i);
239 fail_unless (g_value_get_uint64 (&value) == results[i],
240 "resulting value is %" G_GUINT64_FORMAT ", not %" G_GUINT64_FORMAT
241 ", for string %s (%d)", g_value_get_uint64 (&value),
242 results[i], strings[i], i);
248 GST_START_TEST (test_deserialize_guchar)
250 GValue value = { 0 };
251 const char *strings[] = {
267 g_value_init (&value, G_TYPE_UCHAR);
269 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
270 fail_unless (gst_value_deserialize (&value, strings[i]),
271 "could not deserialize %s (%d)", strings[i], i);
272 fail_unless (g_value_get_uchar (&value) == results[i],
273 "resulting value is %u not %u, for string %s (%d)",
274 g_value_get_uchar (&value), results[i], strings[i], i);
277 /* test serialisation as well while we're at it */
280 GValue value = { 0 };
281 g_value_init (&value, G_TYPE_UCHAR);
283 g_value_set_uchar (&value, 255);
284 str = gst_value_serialize (&value);
286 fail_unless_equals_string (str, "255");
293 GST_START_TEST (test_deserialize_gstfraction)
295 GValue value = { 0 };
296 const char *strings[] = {
300 gint64 result_numers[] = {
304 gint64 result_denoms[] = {
311 g_value_init (&value, GST_TYPE_FRACTION);
312 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
313 fail_unless (gst_value_deserialize (&value, strings[i]),
314 "could not deserialize %s (%d)", strings[i], i);
315 fail_unless (gst_value_get_fraction_numerator (&value) == result_numers[i],
316 "resulting numerator value is %d, not %d"
317 ", for string %s (%d)", gst_value_get_fraction_numerator (&value),
318 result_numers[i], strings[i], i);
319 fail_unless (gst_value_get_fraction_denominator (&value) ==
320 result_denoms[i], "resulting denominator value is %d, not %d"
321 ", for string %s (%d)", gst_value_get_fraction_denominator (&value),
322 result_denoms[i], strings[i], i);
328 GST_START_TEST (test_deserialize_gint)
330 GValue value = { 0 };
331 const char *strings[] = {
336 /* a positive long long, serializing to highest possible positive sint */
338 /* a positive long long, serializing to lowest possible negative sint */
340 /* a negative long long, serializing to lowest possible negative sint */
341 "0xFFFFFFFF80000000",
343 /* a positive long long serializing to -1 */
346 /* a negative long long serializing to -1 */
347 "0xFFFFFFFFFFFFFFFF",
348 "0xFFFFFFFFFFFFFFFF",
351 /* some casts need to be explicit because of unsigned -> signed */
364 (gint) 0xFFFFFFFFFFFFFFFFLL,
369 g_value_init (&value, G_TYPE_INT);
371 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
372 fail_unless (gst_value_deserialize (&value, strings[i]),
373 "could not deserialize %s (%d)", strings[i], i);
374 fail_unless (g_value_get_int (&value) == results[i],
375 "resulting value is %d, not %d, for string %s (%d)",
376 g_value_get_int (&value), results[i], strings[i], i);
382 GST_START_TEST (test_deserialize_gint_failures)
384 GValue value = { 0 };
385 const char *strings[] = {
386 "-", /* not a complete number */
387 "- TEST", /* not a complete number */
388 "0x0000000100000000", /* lowest long long that cannot fit in 32 bits */
389 "0xF000000000000000",
390 "0xFFFFFFF000000000",
391 "0xFFFFFFFF00000000",
392 "0x10000000000000000", /* first number too long to fit into a long long */
393 /* invent a new processor first before trying to make this one pass */
394 "0x10000000000000000000000000000000000000000000",
398 g_value_init (&value, G_TYPE_INT);
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);
408 GST_START_TEST (test_deserialize_guint)
410 GValue value = { 0 };
411 const char *strings[] = {
416 /* a positive long long, serializing to highest possible positive sint */
418 /* a positive long long, serializing to lowest possible negative sint */
421 /* a negative long long, serializing to lowest possible negative sint */
422 "0xFFFFFFFF80000000",
423 /* a value typically used for rgb masks */
425 /* a positive long long serializing to highest possible positive uint */
428 /* a negative long long serializing to highest possible positive uint */
429 "0xFFFFFFFFFFFFFFFF",
439 (guint) 2147483648LL,
444 (guint) 0xFFFFFFFFFFFFFFFFLL,
449 g_value_init (&value, G_TYPE_UINT);
451 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
452 fail_unless (gst_value_deserialize (&value, strings[i]),
453 "could not deserialize %s (%d)", strings[i], i);
454 fail_unless (g_value_get_uint (&value) == results[i],
455 "resulting value is %d, not %d, for string %s (%d)",
456 g_value_get_uint (&value), results[i], strings[i], i);
462 GST_START_TEST (test_deserialize_guint_failures)
464 GValue value = { 0 };
465 const char *strings[] = {
466 "-", /* not a complete number */
467 "- TEST", /* not a complete number */
469 /* FIXME: these values should not be deserializable, since they overflow
470 * the target format */
471 "0x0000000100000000", /* lowest long long that cannot fit in 32 bits */
472 "0xF000000000000000",
473 "0xFFFFFFF000000000",
474 "0xFFFFFFFF00000000",
475 "0x10000000000000000", /* first number too long to fit into a long long */
476 /* invent a new processor first before trying to make this one pass */
477 "0x10000000000000000000000000000000000000000000",
482 g_value_init (&value, G_TYPE_UINT);
484 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
485 fail_if (gst_value_deserialize (&value, strings[i]),
486 "deserialized %s (%d), while it should have failed", strings[i], i);
492 GST_START_TEST (test_serialize_flags)
494 GValue value = { 0 };
496 GstSeekFlags flags[] = {
500 GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
502 const char *results[] = {
503 "GST_SEEK_FLAG_NONE",
504 "GST_SEEK_FLAG_NONE",
505 "GST_SEEK_FLAG_FLUSH",
506 "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",
510 g_value_init (&value, GST_TYPE_SEEK_FLAGS);
512 for (i = 0; i < G_N_ELEMENTS (flags); ++i) {
513 g_value_set_flags (&value, flags[i]);
514 string = gst_value_serialize (&value);
515 fail_if (string == NULL, "could not serialize flags %d", i);
516 fail_unless (strcmp (string, results[i]) == 0,
517 "resulting value is %s, not %s, for flags #%d", string, results[i], i);
525 GST_START_TEST (test_deserialize_flags)
527 GValue value = { 0 };
528 const char *strings[] = {
531 "GST_SEEK_FLAG_NONE",
532 "GST_SEEK_FLAG_FLUSH",
533 "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",
535 GstSeekFlags results[] = {
540 GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
544 g_value_init (&value, GST_TYPE_SEEK_FLAGS);
546 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
547 fail_unless (gst_value_deserialize (&value, strings[i]),
548 "could not deserialize %s (%d)", strings[i], i);
549 fail_unless (g_value_get_flags (&value) == results[i],
550 "resulting value is %d, not %d, for string %s (%d)",
551 g_value_get_flags (&value), results[i], strings[i], i);
557 GST_START_TEST (test_string)
559 const gchar *try[] = {
563 "\"\"" /* Empty string */
569 g_value_init (&v, G_TYPE_STRING);
570 for (i = 0; i < G_N_ELEMENTS (try); i++) {
571 g_value_set_string (&v, try[i]);
572 tmp = gst_value_serialize (&v);
573 fail_if (tmp == NULL, "couldn't serialize: %s\n", try[i]);
574 fail_unless (gst_value_deserialize (&v, tmp),
575 "couldn't deserialize: %s\n", tmp);
578 fail_unless (g_str_equal (g_value_get_string (&v), try[i]),
579 "\nserialized : %s\ndeserialized: %s", try[i],
580 g_value_get_string (&v));
582 /* NULL strings should not be serializable */
583 g_value_set_string (&v, NULL);
584 fail_unless (gst_value_serialize (&v) == NULL);
590 GST_START_TEST (test_deserialize_string)
598 "", ""}, /* empty strings */
600 "\"\"", ""}, /* quoted empty string -> empty string */
601 /* Expected FAILURES: */
603 "\"", NULL}, /* missing second quote */
605 "\"Hello\\ World", NULL}, /* missing second quote */
607 "\"\\", NULL}, /* quote at end, missing second quote */
609 "\"\\0", NULL}, /* missing second quote */
611 "\"\\0\"", NULL}, /* unfinished escaped character */
613 "\" \"", NULL}, /* spaces must be escaped */
615 /* FIXME 0.9: this test should fail, but it doesn't */
617 "tüüt", NULL} /* string with special chars must be escaped */
624 g_value_init (&v, G_TYPE_STRING);
625 for (i = 0; i < G_N_ELEMENTS (tests); i++) {
626 if (gst_value_deserialize (&v, tests[i].from)) {
627 fail_if (tests[i].to == NULL,
628 "I got %s instead of a failure", g_value_get_string (&v));
629 fail_unless (g_str_equal (g_value_get_string (&v), tests[i].to),
630 "\nwanted: %s\ngot : %s", tests[i].to, g_value_get_string (&v));
632 fail_if (tests[i].to != NULL, "failed, but wanted: %s", tests[i].to);
641 GST_START_TEST (test_value_compare)
643 GValue value1 = { 0 };
644 GValue value2 = { 0 };
647 g_value_init (&value1, G_TYPE_INT);
648 g_value_set_int (&value1, 10);
649 g_value_init (&value2, G_TYPE_INT);
650 g_value_set_int (&value2, 20);
651 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
652 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
653 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
654 g_value_unset (&value1);
655 g_value_unset (&value2);
657 g_value_init (&value1, G_TYPE_DOUBLE);
658 g_value_set_double (&value1, 10);
659 g_value_init (&value2, G_TYPE_DOUBLE);
660 g_value_set_double (&value2, 20);
661 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
662 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
663 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
664 g_value_unset (&value1);
665 g_value_unset (&value2);
667 g_value_init (&value1, G_TYPE_STRING);
668 g_value_set_string (&value1, "a");
669 g_value_init (&value2, G_TYPE_STRING);
670 g_value_set_string (&value2, "b");
671 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
672 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
673 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
674 /* Test some NULL string comparisons */
675 g_value_set_string (&value2, NULL);
676 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
677 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_UNORDERED);
678 fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL);
680 g_value_unset (&value1);
681 g_value_unset (&value2);
683 g_value_init (&value1, GST_TYPE_FOURCC);
684 gst_value_set_fourcc (&value1, GST_MAKE_FOURCC ('a', 'b', 'c', 'd'));
685 g_value_init (&value2, GST_TYPE_FOURCC);
686 gst_value_set_fourcc (&value2, GST_MAKE_FOURCC ('1', '2', '3', '4'));
687 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
688 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
689 g_value_unset (&value1);
690 g_value_unset (&value2);
692 /* comparing 2/3 with 3/4 */
693 g_value_init (&value1, GST_TYPE_FRACTION);
694 gst_value_set_fraction (&value1, 2, 3);
695 g_value_init (&value2, GST_TYPE_FRACTION);
696 gst_value_set_fraction (&value2, 3, 4);
697 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
698 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
699 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
700 g_value_unset (&value1);
701 g_value_unset (&value2);
703 /* comparing -4/5 with 2/-3 */
704 g_value_init (&value1, GST_TYPE_FRACTION);
705 gst_value_set_fraction (&value1, -4, 5);
706 g_value_init (&value2, GST_TYPE_FRACTION);
707 gst_value_set_fraction (&value2, 2, -3);
708 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
709 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
710 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
711 g_value_unset (&value1);
712 g_value_unset (&value2);
714 /* comparing 10/100 with 200/2000 */
715 g_value_init (&value1, GST_TYPE_FRACTION);
716 gst_value_set_fraction (&value1, 10, 100);
717 g_value_init (&value2, GST_TYPE_FRACTION);
718 gst_value_set_fraction (&value2, 200, 2000);
719 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL);
720 g_value_unset (&value1);
721 g_value_unset (&value2);
723 /* comparing -4/5 with 2/-3 */
724 g_value_init (&value1, GST_TYPE_FRACTION);
725 gst_value_set_fraction (&value1, -4, 5);
726 g_value_init (&value2, GST_TYPE_FRACTION);
727 gst_value_set_fraction (&value2, 2, -3);
728 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
729 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
730 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
731 g_value_unset (&value1);
732 g_value_unset (&value2);
734 /* Check that lists are equal regardless of order */
735 g_value_init (&value1, GST_TYPE_LIST);
736 g_value_init (&tmp, G_TYPE_INT);
737 g_value_set_int (&tmp, 1);
738 gst_value_list_append_value (&value1, &tmp);
739 g_value_set_int (&tmp, 2);
740 gst_value_list_append_value (&value1, &tmp);
741 g_value_set_int (&tmp, 3);
742 gst_value_list_append_value (&value1, &tmp);
743 g_value_set_int (&tmp, 4);
744 gst_value_list_append_value (&value1, &tmp);
746 g_value_init (&value2, GST_TYPE_LIST);
747 g_value_set_int (&tmp, 4);
748 gst_value_list_append_value (&value2, &tmp);
749 g_value_set_int (&tmp, 3);
750 gst_value_list_append_value (&value2, &tmp);
751 g_value_set_int (&tmp, 2);
752 gst_value_list_append_value (&value2, &tmp);
753 g_value_set_int (&tmp, 1);
754 gst_value_list_append_value (&value2, &tmp);
756 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
757 "value lists with different order were not equal when they should be");
758 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL,
759 "value lists with same order were not equal when they should be");
760 fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL,
761 "value lists with same order were not equal when they should be");
763 /* Carry over the lists to this next check: */
764 /* Lists with different sizes are unequal */
765 g_value_set_int (&tmp, 1);
766 gst_value_list_append_value (&value2, &tmp);
768 fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
769 "Value lists with different size were equal when they shouldn't be");
771 /* Carry over the lists to this next check: */
772 /* Lists with same size but list1 contains one more element not in list2 */
773 g_value_set_int (&tmp, 5);
774 gst_value_list_append_value (&value1, &tmp);
776 fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
777 "Value lists with different elements were equal when they shouldn't be");
778 fail_if (gst_value_compare (&value2, &value1) == GST_VALUE_EQUAL,
779 "Value lists with different elements were equal when they shouldn't be");
781 g_value_unset (&value1);
782 g_value_unset (&value2);
783 g_value_unset (&tmp);
785 /* Arrays are only equal when in the same order */
786 g_value_init (&value1, GST_TYPE_ARRAY);
787 g_value_init (&tmp, G_TYPE_INT);
788 g_value_set_int (&tmp, 1);
789 gst_value_array_append_value (&value1, &tmp);
790 g_value_set_int (&tmp, 2);
791 gst_value_array_append_value (&value1, &tmp);
792 g_value_set_int (&tmp, 3);
793 gst_value_array_append_value (&value1, &tmp);
794 g_value_set_int (&tmp, 4);
795 gst_value_array_append_value (&value1, &tmp);
797 g_value_init (&value2, GST_TYPE_ARRAY);
798 g_value_set_int (&tmp, 4);
799 gst_value_array_append_value (&value2, &tmp);
800 g_value_set_int (&tmp, 3);
801 gst_value_array_append_value (&value2, &tmp);
802 g_value_set_int (&tmp, 2);
803 gst_value_array_append_value (&value2, &tmp);
804 g_value_set_int (&tmp, 1);
805 gst_value_array_append_value (&value2, &tmp);
807 fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
808 "Value arrays with different order were equal when they shouldn't be");
809 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL,
810 "Identical value arrays were not equal when they should be");
811 fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL,
812 "Identical value arrays were not equal when they should be");
814 /* Carry over the arrays to this next check: */
815 /* Arrays with different sizes are unequal */
816 g_value_unset (&value2);
817 g_value_init (&value2, GST_TYPE_ARRAY);
818 g_value_copy (&value1, &value2);
820 g_value_set_int (&tmp, 1);
821 gst_value_array_append_value (&value2, &tmp);
823 fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
824 "Value arrays with different size were equal when they shouldn't be");
825 /* order should not matter */
826 fail_if (gst_value_compare (&value2, &value1) == GST_VALUE_EQUAL,
827 "Value arrays with different size were equal when they shouldn't be");
829 g_value_unset (&value1);
830 g_value_unset (&value2);
831 g_value_unset (&tmp);
836 GST_START_TEST (test_value_intersect)
844 g_value_init (&src1, G_TYPE_INT);
845 g_value_set_int (&src1, 10);
846 g_value_init (&src2, G_TYPE_INT);
847 g_value_set_int (&src2, 20);
848 ret = gst_value_intersect (&dest, &src1, &src2);
849 fail_unless (ret == FALSE);
850 g_value_unset (&src1);
851 g_value_unset (&src2);
853 g_value_init (&src1, GST_TYPE_FOURCC);
854 gst_value_set_fourcc (&src1, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
855 g_value_init (&src2, GST_TYPE_LIST);
856 g_value_init (&item, GST_TYPE_FOURCC);
857 gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
858 gst_value_list_append_value (&src2, &item);
859 gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('I', '4', '2', '0'));
860 gst_value_list_append_value (&src2, &item);
861 gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('A', 'B', 'C', 'D'));
862 gst_value_list_append_value (&src2, &item);
864 fail_unless (gst_value_intersect (&dest, &src1, &src2));
865 fail_unless (GST_VALUE_HOLDS_FOURCC (&dest));
866 fail_unless (gst_value_get_fourcc (&dest) ==
867 GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
869 g_value_unset (&src1);
870 g_value_unset (&src2);
876 GST_START_TEST (test_value_subtract_int)
886 g_value_init (&src1, G_TYPE_INT);
887 g_value_set_int (&src1, 10);
888 g_value_init (&src2, G_TYPE_INT);
889 g_value_set_int (&src2, 20);
890 /* subtract as in sets, result is 10 */
891 ret = gst_value_subtract (&dest, &src1, &src2);
892 fail_unless (ret == TRUE);
893 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
894 g_value_unset (&dest);
896 /* same values, yields empty set */
897 ret = gst_value_subtract (&dest, &src1, &src1);
898 fail_unless (ret == FALSE);
899 g_value_unset (&src1);
900 g_value_unset (&src2);
905 /* would yield an empty set */
906 g_value_init (&src1, G_TYPE_INT);
907 g_value_set_int (&src1, 10);
908 g_value_init (&src2, GST_TYPE_INT_RANGE);
909 gst_value_set_int_range (&src2, 0, 20);
910 ret = gst_value_subtract (&dest, &src1, &src2);
911 fail_unless (ret == FALSE);
913 /* and the other way around, should create a list of two ranges. */
914 ret = gst_value_subtract (&dest, &src2, &src1);
915 fail_unless (ret == TRUE);
916 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
917 tmp = gst_value_list_get_value (&dest, 0);
918 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
919 fail_unless (gst_value_get_int_range_min (tmp) == 0);
920 fail_unless (gst_value_get_int_range_max (tmp) == 9);
921 tmp = gst_value_list_get_value (&dest, 1);
922 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
923 fail_unless (gst_value_get_int_range_min (tmp) == 11);
924 fail_unless (gst_value_get_int_range_max (tmp) == 20);
925 g_value_unset (&dest);
926 g_value_unset (&src1);
927 g_value_unset (&src2);
929 /* border case 1, empty set */
930 g_value_init (&src1, G_TYPE_INT);
931 g_value_set_int (&src1, 10);
932 g_value_init (&src2, GST_TYPE_INT_RANGE);
933 gst_value_set_int_range (&src2, 10, 20);
934 ret = gst_value_subtract (&dest, &src1, &src2);
935 fail_unless (ret == FALSE);
937 /* and the other way around, should create a new range. */
938 ret = gst_value_subtract (&dest, &src2, &src1);
939 fail_unless (ret == TRUE);
940 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
941 fail_unless (gst_value_get_int_range_min (&dest) == 11);
942 fail_unless (gst_value_get_int_range_max (&dest) == 20);
943 g_value_unset (&dest);
944 g_value_unset (&src1);
945 g_value_unset (&src2);
947 /* border case 2, empty set */
948 g_value_init (&src1, G_TYPE_INT);
949 g_value_set_int (&src1, 20);
950 g_value_init (&src2, GST_TYPE_INT_RANGE);
951 gst_value_set_int_range (&src2, 10, 20);
952 ret = gst_value_subtract (&dest, &src1, &src2);
953 fail_unless (ret == FALSE);
955 /* and the other way around, should create a new range. */
956 ret = gst_value_subtract (&dest, &src2, &src1);
957 fail_unless (ret == TRUE);
958 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
959 fail_unless (gst_value_get_int_range_min (&dest) == 10);
960 fail_unless (gst_value_get_int_range_max (&dest) == 19);
961 g_value_unset (&dest);
962 g_value_unset (&src1);
963 g_value_unset (&src2);
965 /* case 3, valid set */
966 g_value_init (&src1, G_TYPE_INT);
967 g_value_set_int (&src1, 0);
968 g_value_init (&src2, GST_TYPE_INT_RANGE);
969 gst_value_set_int_range (&src2, 10, 20);
970 ret = gst_value_subtract (&dest, &src1, &src2);
971 fail_unless (ret == TRUE);
972 fail_unless (G_VALUE_HOLDS_INT (&dest) == TRUE);
973 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
974 g_value_unset (&dest);
976 /* and the other way around, should keep the range. */
977 ret = gst_value_subtract (&dest, &src2, &src1);
978 fail_unless (ret == TRUE);
979 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
980 fail_unless (gst_value_get_int_range_min (&dest) == 10);
981 fail_unless (gst_value_get_int_range_max (&dest) == 20);
982 g_value_unset (&dest);
983 g_value_unset (&src1);
984 g_value_unset (&src2);
986 /* int_range <-> int_range
989 /* same range, empty set */
990 g_value_init (&src1, GST_TYPE_INT_RANGE);
991 gst_value_set_int_range (&src1, 10, 20);
992 g_value_init (&src2, GST_TYPE_INT_RANGE);
993 gst_value_set_int_range (&src2, 10, 20);
994 ret = gst_value_subtract (&dest, &src1, &src2);
995 fail_unless (ret == FALSE);
996 ret = gst_value_subtract (&dest, &src2, &src1);
997 fail_unless (ret == FALSE);
998 g_value_unset (&src1);
999 g_value_unset (&src2);
1001 /* non overlapping ranges */
1002 g_value_init (&src1, GST_TYPE_INT_RANGE);
1003 gst_value_set_int_range (&src1, 10, 20);
1004 g_value_init (&src2, GST_TYPE_INT_RANGE);
1005 gst_value_set_int_range (&src2, 30, 40);
1006 ret = gst_value_subtract (&dest, &src1, &src2);
1007 fail_unless (ret == TRUE);
1008 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1009 fail_unless (gst_value_get_int_range_min (&dest) == 10);
1010 fail_unless (gst_value_get_int_range_max (&dest) == 20);
1011 g_value_unset (&dest);
1013 ret = gst_value_subtract (&dest, &src2, &src1);
1014 fail_unless (ret == TRUE);
1015 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1016 fail_unless (gst_value_get_int_range_min (&dest) == 30);
1017 fail_unless (gst_value_get_int_range_max (&dest) == 40);
1018 g_value_unset (&dest);
1019 g_value_unset (&src1);
1020 g_value_unset (&src2);
1022 /* completely overlapping ranges */
1023 g_value_init (&src1, GST_TYPE_INT_RANGE);
1024 gst_value_set_int_range (&src1, 10, 20);
1025 g_value_init (&src2, GST_TYPE_INT_RANGE);
1026 gst_value_set_int_range (&src2, 10, 30);
1027 ret = gst_value_subtract (&dest, &src1, &src2);
1028 fail_unless (ret == FALSE);
1030 ret = gst_value_subtract (&dest, &src2, &src1);
1031 fail_unless (ret == TRUE);
1032 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1033 fail_unless (gst_value_get_int_range_min (&dest) == 21);
1034 fail_unless (gst_value_get_int_range_max (&dest) == 30);
1035 g_value_unset (&dest);
1036 g_value_unset (&src1);
1037 g_value_unset (&src2);
1039 /* partially overlapping ranges */
1040 g_value_init (&src1, GST_TYPE_INT_RANGE);
1041 gst_value_set_int_range (&src1, 10, 20);
1042 g_value_init (&src2, GST_TYPE_INT_RANGE);
1043 gst_value_set_int_range (&src2, 15, 30);
1044 ret = gst_value_subtract (&dest, &src1, &src2);
1045 fail_unless (ret == TRUE);
1046 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1047 fail_unless (gst_value_get_int_range_min (&dest) == 10);
1048 fail_unless (gst_value_get_int_range_max (&dest) == 14);
1049 g_value_unset (&dest);
1051 ret = gst_value_subtract (&dest, &src2, &src1);
1052 fail_unless (ret == TRUE);
1053 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
1054 fail_unless (gst_value_get_int_range_min (&dest) == 21);
1055 fail_unless (gst_value_get_int_range_max (&dest) == 30);
1056 g_value_unset (&dest);
1057 g_value_unset (&src1);
1058 g_value_unset (&src2);
1060 /* create a hole { int_range, int_range } */
1061 g_value_init (&src1, GST_TYPE_INT_RANGE);
1062 gst_value_set_int_range (&src1, 10, 30);
1063 g_value_init (&src2, GST_TYPE_INT_RANGE);
1064 gst_value_set_int_range (&src2, 15, 20);
1065 ret = gst_value_subtract (&dest, &src1, &src2);
1066 fail_unless (ret == TRUE);
1067 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1068 tmp = gst_value_list_get_value (&dest, 0);
1069 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1070 fail_unless (gst_value_get_int_range_min (tmp) == 10);
1071 fail_unless (gst_value_get_int_range_max (tmp) == 14);
1072 tmp = gst_value_list_get_value (&dest, 1);
1073 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1074 fail_unless (gst_value_get_int_range_min (tmp) == 21);
1075 fail_unless (gst_value_get_int_range_max (tmp) == 30);
1076 g_value_unset (&dest);
1078 ret = gst_value_subtract (&dest, &src2, &src1);
1079 fail_unless (ret == FALSE);
1080 g_value_unset (&src1);
1081 g_value_unset (&src2);
1083 /* create a hole, { int, int } */
1084 g_value_init (&src1, GST_TYPE_INT_RANGE);
1085 gst_value_set_int_range (&src1, 10, 30);
1086 g_value_init (&src2, GST_TYPE_INT_RANGE);
1087 gst_value_set_int_range (&src2, 11, 29);
1088 ret = gst_value_subtract (&dest, &src1, &src2);
1089 fail_unless (ret == TRUE);
1090 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1091 tmp = gst_value_list_get_value (&dest, 0);
1092 fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1093 fail_unless (g_value_get_int (tmp) == 10);
1094 tmp = gst_value_list_get_value (&dest, 1);
1095 fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1096 fail_unless (g_value_get_int (tmp) == 30);
1097 g_value_unset (&dest);
1099 ret = gst_value_subtract (&dest, &src2, &src1);
1100 fail_unless (ret == FALSE);
1101 g_value_unset (&src1);
1102 g_value_unset (&src2);
1104 /* create a hole, { int, int_range } */
1105 g_value_init (&src1, GST_TYPE_INT_RANGE);
1106 gst_value_set_int_range (&src1, 10, 30);
1107 g_value_init (&src2, GST_TYPE_INT_RANGE);
1108 gst_value_set_int_range (&src2, 11, 28);
1109 ret = gst_value_subtract (&dest, &src1, &src2);
1110 fail_unless (ret == TRUE);
1111 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1112 tmp = gst_value_list_get_value (&dest, 0);
1113 fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1114 fail_unless (g_value_get_int (tmp) == 10);
1115 tmp = gst_value_list_get_value (&dest, 1);
1116 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
1117 fail_unless (gst_value_get_int_range_min (tmp) == 29);
1118 fail_unless (gst_value_get_int_range_max (tmp) == 30);
1119 g_value_unset (&dest);
1121 ret = gst_value_subtract (&dest, &src2, &src1);
1122 fail_unless (ret == FALSE);
1123 g_value_unset (&src1);
1124 g_value_unset (&src2);
1126 /* create a hole, { int_range, int } */
1127 g_value_init (&src1, GST_TYPE_INT_RANGE);
1128 gst_value_set_int_range (&src1, 10, 30);
1129 g_value_init (&src2, GST_TYPE_INT_RANGE);
1130 gst_value_set_int_range (&src2, 12, 29);
1131 ret = gst_value_subtract (&dest, &src1, &src2);
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_INT_RANGE (tmp) == TRUE);
1136 fail_unless (gst_value_get_int_range_min (tmp) == 10);
1137 fail_unless (gst_value_get_int_range_max (tmp) == 11);
1138 tmp = gst_value_list_get_value (&dest, 1);
1139 fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
1140 fail_unless (g_value_get_int (tmp) == 30);
1141 g_value_unset (&dest);
1143 ret = gst_value_subtract (&dest, &src2, &src1);
1144 fail_unless (ret == FALSE);
1145 g_value_unset (&src1);
1146 g_value_unset (&src2);
1151 GST_START_TEST (test_value_subtract_int64)
1153 GValue dest = { 0 };
1154 GValue src1 = { 0 };
1155 GValue src2 = { 0 };
1161 g_value_init (&src1, G_TYPE_INT64);
1162 g_value_set_int64 (&src1, 10);
1163 g_value_init (&src2, G_TYPE_INT64);
1164 g_value_set_int64 (&src2, 20);
1165 /* subtract as in sets, result is 10 */
1166 ret = gst_value_subtract (&dest, &src1, &src2);
1167 fail_unless (ret == TRUE);
1168 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1169 g_value_unset (&dest);
1171 /* same values, yields empty set */
1172 ret = gst_value_subtract (&dest, &src1, &src1);
1173 fail_unless (ret == FALSE);
1174 g_value_unset (&src1);
1175 g_value_unset (&src2);
1177 /* int64 <-> int64_range
1180 /* would yield an empty set */
1181 g_value_init (&src1, G_TYPE_INT64);
1182 g_value_set_int64 (&src1, 10);
1183 g_value_init (&src2, GST_TYPE_INT64_RANGE);
1184 gst_value_set_int64_range (&src2, 0, 20);
1185 ret = gst_value_subtract (&dest, &src1, &src2);
1186 fail_unless (ret == FALSE);
1188 /* and the other way around, should create a list of two ranges. */
1189 ret = gst_value_subtract (&dest, &src2, &src1);
1190 fail_unless (ret == TRUE);
1191 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1192 tmp = gst_value_list_get_value (&dest, 0);
1193 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1194 fail_unless (gst_value_get_int64_range_min (tmp) == 0);
1195 fail_unless (gst_value_get_int64_range_max (tmp) == 9);
1196 tmp = gst_value_list_get_value (&dest, 1);
1197 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1198 fail_unless (gst_value_get_int64_range_min (tmp) == 11);
1199 fail_unless (gst_value_get_int64_range_max (tmp) == 20);
1200 g_value_unset (&dest);
1201 g_value_unset (&src1);
1202 g_value_unset (&src2);
1204 /* border case 1, empty set */
1205 g_value_init (&src1, G_TYPE_INT64);
1206 g_value_set_int64 (&src1, 10);
1207 g_value_init (&src2, GST_TYPE_INT64_RANGE);
1208 gst_value_set_int64_range (&src2, 10, 20);
1209 ret = gst_value_subtract (&dest, &src1, &src2);
1210 fail_unless (ret == FALSE);
1212 /* and the other way around, should create a new range. */
1213 ret = gst_value_subtract (&dest, &src2, &src1);
1214 fail_unless (ret == TRUE);
1215 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1216 fail_unless (gst_value_get_int64_range_min (&dest) == 11);
1217 fail_unless (gst_value_get_int64_range_max (&dest) == 20);
1218 g_value_unset (&dest);
1219 g_value_unset (&src1);
1220 g_value_unset (&src2);
1222 /* border case 2, empty set */
1223 g_value_init (&src1, G_TYPE_INT64);
1224 g_value_set_int64 (&src1, 20);
1225 g_value_init (&src2, GST_TYPE_INT64_RANGE);
1226 gst_value_set_int64_range (&src2, 10, 20);
1227 ret = gst_value_subtract (&dest, &src1, &src2);
1228 fail_unless (ret == FALSE);
1230 /* and the other way around, should create a new range. */
1231 ret = gst_value_subtract (&dest, &src2, &src1);
1232 fail_unless (ret == TRUE);
1233 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1234 fail_unless (gst_value_get_int64_range_min (&dest) == 10);
1235 fail_unless (gst_value_get_int64_range_max (&dest) == 19);
1236 g_value_unset (&dest);
1237 g_value_unset (&src1);
1238 g_value_unset (&src2);
1240 /* case 3, valid set */
1241 g_value_init (&src1, G_TYPE_INT64);
1242 g_value_set_int64 (&src1, 0);
1243 g_value_init (&src2, GST_TYPE_INT64_RANGE);
1244 gst_value_set_int64_range (&src2, 10, 20);
1245 ret = gst_value_subtract (&dest, &src1, &src2);
1246 fail_unless (ret == TRUE);
1247 fail_unless (G_VALUE_HOLDS_INT64 (&dest) == TRUE);
1248 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1249 g_value_unset (&dest);
1251 /* and the other way around, should keep the range. */
1252 ret = gst_value_subtract (&dest, &src2, &src1);
1253 fail_unless (ret == TRUE);
1254 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1255 fail_unless (gst_value_get_int64_range_min (&dest) == 10);
1256 fail_unless (gst_value_get_int64_range_max (&dest) == 20);
1257 g_value_unset (&dest);
1258 g_value_unset (&src1);
1259 g_value_unset (&src2);
1261 /* int64_range <-> int64_range
1264 /* same range, empty set */
1265 g_value_init (&src1, GST_TYPE_INT64_RANGE);
1266 gst_value_set_int64_range (&src1, 10, 20);
1267 g_value_init (&src2, GST_TYPE_INT64_RANGE);
1268 gst_value_set_int64_range (&src2, 10, 20);
1269 ret = gst_value_subtract (&dest, &src1, &src2);
1270 fail_unless (ret == FALSE);
1271 ret = gst_value_subtract (&dest, &src2, &src1);
1272 fail_unless (ret == FALSE);
1273 g_value_unset (&src1);
1274 g_value_unset (&src2);
1276 /* non overlapping ranges */
1277 g_value_init (&src1, GST_TYPE_INT64_RANGE);
1278 gst_value_set_int64_range (&src1, 10, 20);
1279 g_value_init (&src2, GST_TYPE_INT64_RANGE);
1280 gst_value_set_int64_range (&src2, 30, 40);
1281 ret = gst_value_subtract (&dest, &src1, &src2);
1282 fail_unless (ret == TRUE);
1283 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1284 fail_unless (gst_value_get_int64_range_min (&dest) == 10);
1285 fail_unless (gst_value_get_int64_range_max (&dest) == 20);
1286 g_value_unset (&dest);
1288 ret = gst_value_subtract (&dest, &src2, &src1);
1289 fail_unless (ret == TRUE);
1290 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1291 fail_unless (gst_value_get_int64_range_min (&dest) == 30);
1292 fail_unless (gst_value_get_int64_range_max (&dest) == 40);
1293 g_value_unset (&dest);
1294 g_value_unset (&src1);
1295 g_value_unset (&src2);
1297 /* completely overlapping ranges */
1298 g_value_init (&src1, GST_TYPE_INT64_RANGE);
1299 gst_value_set_int64_range (&src1, 10, 20);
1300 g_value_init (&src2, GST_TYPE_INT64_RANGE);
1301 gst_value_set_int64_range (&src2, 10, 30);
1302 ret = gst_value_subtract (&dest, &src1, &src2);
1303 fail_unless (ret == FALSE);
1305 ret = gst_value_subtract (&dest, &src2, &src1);
1306 fail_unless (ret == TRUE);
1307 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1308 fail_unless (gst_value_get_int64_range_min (&dest) == 21);
1309 fail_unless (gst_value_get_int64_range_max (&dest) == 30);
1310 g_value_unset (&dest);
1311 g_value_unset (&src1);
1312 g_value_unset (&src2);
1314 /* partially overlapping ranges */
1315 g_value_init (&src1, GST_TYPE_INT64_RANGE);
1316 gst_value_set_int64_range (&src1, 10, 20);
1317 g_value_init (&src2, GST_TYPE_INT64_RANGE);
1318 gst_value_set_int64_range (&src2, 15, 30);
1319 ret = gst_value_subtract (&dest, &src1, &src2);
1320 fail_unless (ret == TRUE);
1321 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1322 fail_unless (gst_value_get_int64_range_min (&dest) == 10);
1323 fail_unless (gst_value_get_int64_range_max (&dest) == 14);
1324 g_value_unset (&dest);
1326 ret = gst_value_subtract (&dest, &src2, &src1);
1327 fail_unless (ret == TRUE);
1328 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (&dest) == TRUE);
1329 fail_unless (gst_value_get_int64_range_min (&dest) == 21);
1330 fail_unless (gst_value_get_int64_range_max (&dest) == 30);
1331 g_value_unset (&dest);
1332 g_value_unset (&src1);
1333 g_value_unset (&src2);
1335 /* create a hole { int64_range, int64_range } */
1336 g_value_init (&src1, GST_TYPE_INT64_RANGE);
1337 gst_value_set_int64_range (&src1, 10, 30);
1338 g_value_init (&src2, GST_TYPE_INT64_RANGE);
1339 gst_value_set_int64_range (&src2, 15, 20);
1340 ret = gst_value_subtract (&dest, &src1, &src2);
1341 fail_unless (ret == TRUE);
1342 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1343 tmp = gst_value_list_get_value (&dest, 0);
1344 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1345 fail_unless (gst_value_get_int64_range_min (tmp) == 10);
1346 fail_unless (gst_value_get_int64_range_max (tmp) == 14);
1347 tmp = gst_value_list_get_value (&dest, 1);
1348 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1349 fail_unless (gst_value_get_int64_range_min (tmp) == 21);
1350 fail_unless (gst_value_get_int64_range_max (tmp) == 30);
1351 g_value_unset (&dest);
1353 ret = gst_value_subtract (&dest, &src2, &src1);
1354 fail_unless (ret == FALSE);
1355 g_value_unset (&src1);
1356 g_value_unset (&src2);
1358 /* create a hole, { int64, int64 } */
1359 g_value_init (&src1, GST_TYPE_INT64_RANGE);
1360 gst_value_set_int64_range (&src1, 10, 30);
1361 g_value_init (&src2, GST_TYPE_INT64_RANGE);
1362 gst_value_set_int64_range (&src2, 11, 29);
1363 ret = gst_value_subtract (&dest, &src1, &src2);
1364 fail_unless (ret == TRUE);
1365 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1366 tmp = gst_value_list_get_value (&dest, 0);
1367 fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
1368 fail_unless (g_value_get_int64 (tmp) == 10);
1369 tmp = gst_value_list_get_value (&dest, 1);
1370 fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
1371 fail_unless (g_value_get_int64 (tmp) == 30);
1372 g_value_unset (&dest);
1374 ret = gst_value_subtract (&dest, &src2, &src1);
1375 fail_unless (ret == FALSE);
1376 g_value_unset (&src1);
1377 g_value_unset (&src2);
1379 /* create a hole, { int64, int64_range } */
1380 g_value_init (&src1, GST_TYPE_INT64_RANGE);
1381 gst_value_set_int64_range (&src1, 10, 30);
1382 g_value_init (&src2, GST_TYPE_INT64_RANGE);
1383 gst_value_set_int64_range (&src2, 11, 28);
1384 ret = gst_value_subtract (&dest, &src1, &src2);
1385 fail_unless (ret == TRUE);
1386 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1387 tmp = gst_value_list_get_value (&dest, 0);
1388 fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
1389 fail_unless (g_value_get_int64 (tmp) == 10);
1390 tmp = gst_value_list_get_value (&dest, 1);
1391 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1392 fail_unless (gst_value_get_int64_range_min (tmp) == 29);
1393 fail_unless (gst_value_get_int64_range_max (tmp) == 30);
1394 g_value_unset (&dest);
1396 ret = gst_value_subtract (&dest, &src2, &src1);
1397 fail_unless (ret == FALSE);
1398 g_value_unset (&src1);
1399 g_value_unset (&src2);
1401 /* create a hole, { int64_range, int64 } */
1402 g_value_init (&src1, GST_TYPE_INT64_RANGE);
1403 gst_value_set_int64_range (&src1, 10, 30);
1404 g_value_init (&src2, GST_TYPE_INT64_RANGE);
1405 gst_value_set_int64_range (&src2, 12, 29);
1406 ret = gst_value_subtract (&dest, &src1, &src2);
1407 fail_unless (ret == TRUE);
1408 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1409 tmp = gst_value_list_get_value (&dest, 0);
1410 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
1411 fail_unless (gst_value_get_int64_range_min (tmp) == 10);
1412 fail_unless (gst_value_get_int64_range_max (tmp) == 11);
1413 tmp = gst_value_list_get_value (&dest, 1);
1414 fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
1415 fail_unless (g_value_get_int64 (tmp) == 30);
1416 g_value_unset (&dest);
1418 ret = gst_value_subtract (&dest, &src2, &src1);
1419 fail_unless (ret == FALSE);
1420 g_value_unset (&src1);
1421 g_value_unset (&src2);
1426 GST_START_TEST (test_value_subtract_double)
1428 GValue dest = { 0 };
1429 GValue src1 = { 0 };
1430 GValue src2 = { 0 };
1434 /* double <-> double
1436 g_value_init (&src1, G_TYPE_DOUBLE);
1437 g_value_set_double (&src1, 10.0);
1438 g_value_init (&src2, G_TYPE_DOUBLE);
1439 g_value_set_double (&src2, 20.0);
1440 /* subtract as in sets, result is 10 */
1441 ret = gst_value_subtract (&dest, &src1, &src2);
1442 fail_unless (ret == TRUE);
1443 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1444 g_value_unset (&dest);
1446 /* same values, yields empty set */
1447 ret = gst_value_subtract (&dest, &src1, &src1);
1448 fail_unless (ret == FALSE);
1449 g_value_unset (&src1);
1450 g_value_unset (&src2);
1452 /* double <-> double_range
1455 /* would yield an empty set */
1456 g_value_init (&src1, G_TYPE_DOUBLE);
1457 g_value_set_double (&src1, 10.0);
1458 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1459 gst_value_set_double_range (&src2, 0.0, 20.0);
1460 ret = gst_value_subtract (&dest, &src1, &src2);
1461 fail_unless (ret == FALSE);
1463 /* and the other way around, we cannot create open ranges
1464 * so the result is the range again */
1465 ret = gst_value_subtract (&dest, &src2, &src1);
1466 fail_unless (ret == TRUE);
1467 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1468 fail_unless (gst_value_get_double_range_min (&dest) == 0.0);
1469 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1470 g_value_unset (&dest);
1471 g_value_unset (&src1);
1472 g_value_unset (&src2);
1474 /* border case 1, empty set */
1475 g_value_init (&src1, G_TYPE_DOUBLE);
1476 g_value_set_double (&src1, 10.0);
1477 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1478 gst_value_set_double_range (&src2, 10.0, 20.0);
1479 ret = gst_value_subtract (&dest, &src1, &src2);
1480 fail_unless (ret == FALSE);
1482 /* and the other way around, should keep same range as
1483 * we don't have open ranges. */
1484 ret = gst_value_subtract (&dest, &src2, &src1);
1485 fail_unless (ret == TRUE);
1486 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1487 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1488 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1489 g_value_unset (&dest);
1490 g_value_unset (&src1);
1491 g_value_unset (&src2);
1493 /* border case 2, empty set */
1494 g_value_init (&src1, G_TYPE_DOUBLE);
1495 g_value_set_double (&src1, 20.0);
1496 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1497 gst_value_set_double_range (&src2, 10.0, 20.0);
1498 ret = gst_value_subtract (&dest, &src1, &src2);
1499 fail_unless (ret == FALSE);
1501 /* and the other way around, should keep same range as
1502 * we don't have open ranges. */
1503 ret = gst_value_subtract (&dest, &src2, &src1);
1504 fail_unless (ret == TRUE);
1505 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1506 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1507 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1508 g_value_unset (&dest);
1509 g_value_unset (&src1);
1510 g_value_unset (&src2);
1512 /* case 3, valid set */
1513 g_value_init (&src1, G_TYPE_DOUBLE);
1514 g_value_set_double (&src1, 0.0);
1515 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1516 gst_value_set_double_range (&src2, 10.0, 20.0);
1517 ret = gst_value_subtract (&dest, &src1, &src2);
1518 fail_unless (ret == TRUE);
1519 fail_unless (G_VALUE_HOLDS_DOUBLE (&dest) == TRUE);
1520 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1521 g_value_unset (&dest);
1523 /* and the other way around, should keep the range. */
1524 ret = gst_value_subtract (&dest, &src2, &src1);
1525 fail_unless (ret == TRUE);
1526 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1527 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1528 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1529 g_value_unset (&dest);
1530 g_value_unset (&src1);
1531 g_value_unset (&src2);
1533 /* double_range <-> double_range
1536 /* same range, empty set */
1537 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1538 gst_value_set_double_range (&src1, 10.0, 20.0);
1539 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1540 gst_value_set_double_range (&src2, 10.0, 20.0);
1541 ret = gst_value_subtract (&dest, &src1, &src2);
1542 fail_unless (ret == FALSE);
1543 ret = gst_value_subtract (&dest, &src2, &src1);
1544 fail_unless (ret == FALSE);
1545 g_value_unset (&src1);
1546 g_value_unset (&src2);
1548 /* non overlapping ranges */
1549 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1550 gst_value_set_double_range (&src1, 10.0, 20.0);
1551 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1552 gst_value_set_double_range (&src2, 30.0, 40.0);
1553 ret = gst_value_subtract (&dest, &src1, &src2);
1554 fail_unless (ret == TRUE);
1555 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1556 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1557 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1558 g_value_unset (&dest);
1560 ret = gst_value_subtract (&dest, &src2, &src1);
1561 fail_unless (ret == TRUE);
1562 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1563 fail_unless (gst_value_get_double_range_min (&dest) == 30.0);
1564 fail_unless (gst_value_get_double_range_max (&dest) == 40.0);
1565 g_value_unset (&dest);
1566 g_value_unset (&src1);
1567 g_value_unset (&src2);
1569 /* completely overlapping ranges */
1570 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1571 gst_value_set_double_range (&src1, 10.0, 20.0);
1572 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1573 gst_value_set_double_range (&src2, 10.0, 30.0);
1574 ret = gst_value_subtract (&dest, &src1, &src2);
1575 fail_unless (ret == FALSE);
1577 ret = gst_value_subtract (&dest, &src2, &src1);
1578 fail_unless (ret == TRUE);
1579 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1580 fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
1581 fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
1582 g_value_unset (&dest);
1583 g_value_unset (&src1);
1584 g_value_unset (&src2);
1586 /* partially overlapping ranges */
1587 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1588 gst_value_set_double_range (&src1, 10.0, 20.0);
1589 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1590 gst_value_set_double_range (&src2, 15.0, 30.0);
1591 ret = gst_value_subtract (&dest, &src1, &src2);
1592 fail_unless (ret == TRUE);
1593 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1594 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1595 fail_unless (gst_value_get_double_range_max (&dest) == 15.0);
1596 g_value_unset (&dest);
1598 ret = gst_value_subtract (&dest, &src2, &src1);
1599 fail_unless (ret == TRUE);
1600 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1601 fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
1602 fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
1603 g_value_unset (&dest);
1604 g_value_unset (&src1);
1605 g_value_unset (&src2);
1607 /* create a hole { double_range, double_range } */
1608 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1609 gst_value_set_double_range (&src1, 10.0, 30.0);
1610 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1611 gst_value_set_double_range (&src2, 15.0, 20.0);
1612 ret = gst_value_subtract (&dest, &src1, &src2);
1613 fail_unless (ret == TRUE);
1614 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1615 tmp = gst_value_list_get_value (&dest, 0);
1616 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
1617 fail_unless (gst_value_get_double_range_min (tmp) == 10.0);
1618 fail_unless (gst_value_get_double_range_max (tmp) == 15.0);
1619 tmp = gst_value_list_get_value (&dest, 1);
1620 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
1621 fail_unless (gst_value_get_double_range_min (tmp) == 20.0);
1622 fail_unless (gst_value_get_double_range_max (tmp) == 30.0);
1623 g_value_unset (&dest);
1625 ret = gst_value_subtract (&dest, &src2, &src1);
1626 fail_unless (ret == FALSE);
1627 g_value_unset (&src1);
1628 g_value_unset (&src2);
1633 /* Test arithmetic subtraction of fractions */
1634 GST_START_TEST (test_value_subtract_fraction)
1636 GValue result = { 0 };
1637 GValue src1 = { 0 };
1638 GValue src2 = { 0 };
1640 /* Subtract 1/4 from 1/2 */
1641 g_value_init (&src1, GST_TYPE_FRACTION);
1642 g_value_init (&src2, GST_TYPE_FRACTION);
1643 g_value_init (&result, GST_TYPE_FRACTION);
1644 gst_value_set_fraction (&src1, 1, 2);
1645 gst_value_set_fraction (&src2, 1, 4);
1646 fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1647 fail_unless (gst_value_get_fraction_numerator (&result) == 1);
1648 fail_unless (gst_value_get_fraction_denominator (&result) == 4);
1650 g_value_unset (&src1);
1651 g_value_unset (&src2);
1652 g_value_unset (&result);
1654 /* Subtract 1/12 from 7/8 */
1655 g_value_init (&src1, GST_TYPE_FRACTION);
1656 g_value_init (&src2, GST_TYPE_FRACTION);
1657 g_value_init (&result, GST_TYPE_FRACTION);
1658 gst_value_set_fraction (&src1, 7, 8);
1659 gst_value_set_fraction (&src2, 1, 12);
1660 fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1661 fail_unless (gst_value_get_fraction_numerator (&result) == 19);
1662 fail_unless (gst_value_get_fraction_denominator (&result) == 24);
1664 g_value_unset (&src1);
1665 g_value_unset (&src2);
1666 g_value_unset (&result);
1668 /* Subtract 12/13 from 4/3 */
1669 g_value_init (&src1, GST_TYPE_FRACTION);
1670 g_value_init (&src2, GST_TYPE_FRACTION);
1671 g_value_init (&result, GST_TYPE_FRACTION);
1672 gst_value_set_fraction (&src1, 4, 3);
1673 gst_value_set_fraction (&src2, 12, 13);
1674 fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1675 fail_unless (gst_value_get_fraction_numerator (&result) == 16);
1676 fail_unless (gst_value_get_fraction_denominator (&result) == 39);
1678 g_value_unset (&src1);
1679 g_value_unset (&src2);
1680 g_value_unset (&result);
1682 /* Subtract 1/12 from 7/8 */
1687 /* Test set subtraction operations on fraction ranges */
1688 GST_START_TEST (test_value_subtract_fraction_range)
1690 GValue dest = { 0 };
1691 GValue src1 = { 0 };
1692 GValue src2 = { 0 };
1697 /* Value for tests */
1698 g_value_init (&cmp, GST_TYPE_FRACTION);
1700 /* fraction <-> fraction
1702 g_value_init (&src1, GST_TYPE_FRACTION);
1703 gst_value_set_fraction (&src1, 10, 1);
1704 g_value_init (&src2, GST_TYPE_FRACTION);
1705 gst_value_set_fraction (&src2, 20, 1);
1706 gst_value_set_fraction (&src1, 10, 1);
1708 /* subtract as in sets, result is 10 */
1709 ret = gst_value_subtract (&dest, &src1, &src2);
1710 fail_unless (ret == TRUE);
1711 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1712 g_value_unset (&dest);
1714 /* same values, yields empty set */
1715 ret = gst_value_subtract (&dest, &src1, &src1);
1716 fail_unless (ret == FALSE);
1717 g_value_unset (&src1);
1718 g_value_unset (&src2);
1720 /* fraction <-> fraction_range
1723 /* would yield an empty set */
1724 g_value_init (&src1, GST_TYPE_FRACTION);
1725 gst_value_set_fraction (&src1, 10, 1);
1726 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1727 gst_value_set_fraction_range_full (&src2, 0, 1, 20, 1);
1728 ret = gst_value_subtract (&dest, &src1, &src2);
1729 fail_unless (ret == FALSE);
1731 /* and the other way around, we cannot create open ranges
1732 * so the result is the range again */
1733 ret = gst_value_subtract (&dest, &src2, &src1);
1734 fail_unless (ret == TRUE);
1735 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1736 gst_value_set_fraction (&cmp, 0, 1);
1737 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1738 &cmp) == GST_VALUE_EQUAL);
1739 gst_value_set_fraction (&cmp, 20, 1);
1740 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1741 &cmp) == GST_VALUE_EQUAL);
1742 g_value_unset (&dest);
1743 g_value_unset (&src1);
1744 g_value_unset (&src2);
1746 /* border case 1, empty set */
1747 g_value_init (&src1, GST_TYPE_FRACTION);
1748 gst_value_set_fraction (&src1, 10, 1);
1749 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1750 gst_value_set_fraction_range_full (&src2, 10, 1, 20, 1);
1751 ret = gst_value_subtract (&dest, &src1, &src2);
1752 fail_unless (ret == FALSE);
1754 /* and the other way around, should keep same range as
1755 * we don't have open ranges. */
1756 ret = gst_value_subtract (&dest, &src2, &src1);
1757 fail_unless (ret == TRUE);
1758 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1759 gst_value_set_fraction (&cmp, 10, 1);
1760 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1761 &cmp) == GST_VALUE_EQUAL);
1762 gst_value_set_fraction (&cmp, 20, 1);
1763 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1764 &cmp) == GST_VALUE_EQUAL);
1765 g_value_unset (&dest);
1766 g_value_unset (&src1);
1767 g_value_unset (&src2);
1769 /* case 2, valid set */
1770 g_value_init (&src1, GST_TYPE_FRACTION);
1771 gst_value_set_fraction (&src1, 0, 1);
1772 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1773 gst_value_set_fraction_range_full (&src2, 10, 1, 20, 1);
1774 ret = gst_value_subtract (&dest, &src1, &src2);
1775 fail_unless (ret == TRUE);
1776 fail_unless (GST_VALUE_HOLDS_FRACTION (&dest) == TRUE);
1777 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1778 g_value_unset (&dest);
1780 /* and the other way around, should keep the range. */
1781 ret = gst_value_subtract (&dest, &src2, &src1);
1782 fail_unless (ret == TRUE);
1783 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1784 fail_unless (gst_value_compare (&dest, &src2) == GST_VALUE_EQUAL);
1785 g_value_unset (&dest);
1786 g_value_unset (&src1);
1787 g_value_unset (&src2);
1789 /* fraction_range <-> fraction_range
1792 /* same range, empty set */
1793 g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1794 gst_value_set_fraction_range_full (&src1, 10, 2, 20, 2);
1795 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1796 gst_value_set_fraction_range_full (&src2, 10, 2, 20, 2);
1797 ret = gst_value_subtract (&dest, &src1, &src2);
1798 fail_unless (ret == FALSE);
1799 ret = gst_value_subtract (&dest, &src2, &src1);
1800 fail_unless (ret == FALSE);
1801 g_value_unset (&src1);
1802 g_value_unset (&src2);
1804 /* non overlapping ranges */
1805 g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1806 gst_value_set_fraction_range_full (&src1, 10, 2, 10, 1);
1807 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1808 gst_value_set_fraction_range_full (&src2, 30, 2, 40, 2);
1809 ret = gst_value_subtract (&dest, &src1, &src2);
1810 fail_unless (ret == TRUE);
1811 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1812 gst_value_set_fraction (&cmp, 5, 1);
1813 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1814 &cmp) == GST_VALUE_EQUAL);
1815 gst_value_set_fraction (&cmp, 10, 1);
1816 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1817 &cmp) == GST_VALUE_EQUAL);
1819 g_value_unset (&dest);
1821 ret = gst_value_subtract (&dest, &src2, &src1);
1822 fail_unless (ret == TRUE);
1823 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1824 gst_value_set_fraction (&cmp, 15, 1);
1825 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1826 &cmp) == GST_VALUE_EQUAL);
1827 gst_value_set_fraction (&cmp, 20, 1);
1828 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1829 &cmp) == GST_VALUE_EQUAL);
1830 g_value_unset (&dest);
1831 g_value_unset (&src1);
1832 g_value_unset (&src2);
1834 /* completely overlapping ranges */
1835 g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1836 gst_value_set_fraction_range_full (&src1, 10, 1, 20, 1);
1837 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1838 gst_value_set_fraction_range_full (&src2, 10, 1, 30, 1);
1839 ret = gst_value_subtract (&dest, &src1, &src2);
1840 fail_unless (ret == FALSE);
1842 ret = gst_value_subtract (&dest, &src2, &src1);
1843 fail_unless (ret == TRUE);
1844 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1845 gst_value_set_fraction (&cmp, 20, 1);
1846 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1847 &cmp) == GST_VALUE_EQUAL);
1848 gst_value_set_fraction (&cmp, 30, 1);
1849 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1850 &cmp) == GST_VALUE_EQUAL);
1851 g_value_unset (&dest);
1852 g_value_unset (&src1);
1853 g_value_unset (&src2);
1855 /* partially overlapping ranges */
1856 g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1857 gst_value_set_fraction_range_full (&src1, 10, 1, 20, 1);
1858 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1859 gst_value_set_fraction_range_full (&src2, 15, 1, 30, 1);
1860 ret = gst_value_subtract (&dest, &src1, &src2);
1861 fail_unless (ret == TRUE);
1862 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1863 gst_value_set_fraction (&cmp, 10, 1);
1864 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1865 &cmp) == GST_VALUE_EQUAL);
1866 gst_value_set_fraction (&cmp, 15, 1);
1867 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1868 &cmp) == GST_VALUE_EQUAL);
1869 g_value_unset (&dest);
1872 ret = gst_value_subtract (&dest, &src2, &src1);
1873 fail_unless (ret == TRUE);
1874 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1875 gst_value_set_fraction (&cmp, 20, 1);
1876 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1877 &cmp) == GST_VALUE_EQUAL);
1878 gst_value_set_fraction (&cmp, 30, 1);
1879 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1880 &cmp) == GST_VALUE_EQUAL);
1881 g_value_unset (&dest);
1882 g_value_unset (&src1);
1883 g_value_unset (&src2);
1885 /* create a hole { double_range, double_range } */
1886 g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1887 gst_value_set_fraction_range_full (&src1, 10, 1, 30, 1);
1888 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1889 gst_value_set_fraction_range_full (&src2, 15, 1, 20, 1);
1890 ret = gst_value_subtract (&dest, &src1, &src2);
1891 fail_unless (ret == TRUE);
1892 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1893 /* 1st list entry */
1894 tmp = gst_value_list_get_value (&dest, 0);
1895 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (tmp) == TRUE);
1896 gst_value_set_fraction (&cmp, 10, 1);
1897 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (tmp),
1898 &cmp) == GST_VALUE_EQUAL);
1899 gst_value_set_fraction (&cmp, 15, 1);
1900 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (tmp),
1901 &cmp) == GST_VALUE_EQUAL);
1902 /* 2nd list entry */
1903 tmp = gst_value_list_get_value (&dest, 1);
1904 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (tmp) == TRUE);
1905 gst_value_set_fraction (&cmp, 20, 1);
1906 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (tmp),
1907 &cmp) == GST_VALUE_EQUAL);
1908 gst_value_set_fraction (&cmp, 30, 1);
1909 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (tmp),
1910 &cmp) == GST_VALUE_EQUAL);
1911 g_value_unset (&dest);
1913 ret = gst_value_subtract (&dest, &src2, &src1);
1914 fail_unless (ret == FALSE);
1915 g_value_unset (&src1);
1916 g_value_unset (&src2);
1918 g_value_unset (&cmp);
1923 /* Test set subtraction operations on fraction lists */
1924 GST_START_TEST (test_value_subtract_fraction_list)
1926 GValue list1 = { 0 };
1927 GValue list2 = { 0 };
1928 GValue val1 = { 0 };
1929 GValue val2 = { 0 };
1933 g_value_init (&list1, GST_TYPE_LIST);
1934 g_value_init (&val1, GST_TYPE_FRACTION);
1935 gst_value_set_fraction (&val1, 15, 2);
1936 gst_value_list_append_value (&list1, &val1);
1937 g_value_init (&tmp, GST_TYPE_FRACTION);
1938 gst_value_set_fraction (&tmp, 5, 1);
1939 gst_value_list_append_value (&list1, &tmp);
1940 g_value_unset (&tmp);
1942 g_value_init (&list2, GST_TYPE_LIST);
1943 g_value_init (&val2, GST_TYPE_FRACTION);
1944 gst_value_set_fraction (&val2, 15, 1);
1945 gst_value_list_append_value (&list2, &val2);
1946 g_value_init (&tmp, GST_TYPE_FRACTION);
1947 gst_value_set_fraction (&tmp, 5, 1);
1948 gst_value_list_append_value (&list2, &tmp);
1949 g_value_unset (&tmp);
1951 /* should subtract all common elements */
1952 ret = gst_value_subtract (&tmp, &list1, &list2);
1953 fail_unless (ret == TRUE);
1954 fail_unless (gst_value_compare (&tmp, &val1) == GST_VALUE_EQUAL);
1955 g_value_unset (&val1);
1956 g_value_unset (&tmp);
1958 ret = gst_value_subtract (&tmp, &list2, &list1);
1959 fail_unless (ret == TRUE);
1960 fail_unless (gst_value_compare (&tmp, &val2) == GST_VALUE_EQUAL);
1961 g_value_unset (&val2);
1962 g_value_unset (&tmp);
1964 g_value_unset (&list1);
1965 g_value_unset (&list2);
1971 GST_START_TEST (test_date)
1974 GDate *date, *date2;
1977 date = g_date_new_dmy (22, 9, 2005);
1979 s = gst_structure_new ("media/x-type", "SOME_DATE_TAG", GST_TYPE_DATE,
1982 fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
1984 fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date2));
1985 fail_unless (date2 != NULL);
1986 fail_unless (g_date_valid (date2));
1987 fail_unless (g_date_compare (date, date2) == 0);
1990 g_date_free (date2);
1994 str = gst_structure_to_string (s);
1995 gst_structure_free (s);
1998 fail_unless (g_str_equal (str,
1999 "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22;"));
2001 s = gst_structure_from_string (str, NULL);
2005 fail_unless (s != NULL);
2006 fail_unless (gst_structure_has_name (s, "media/x-type"));
2007 fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
2009 fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date));
2010 fail_unless (date != NULL);
2011 fail_unless (g_date_valid (date));
2012 fail_unless (g_date_get_day (date) == 22);
2013 fail_unless (g_date_get_month (date) == 9);
2014 fail_unless (g_date_get_year (date) == 2005);
2018 str = gst_structure_to_string (s);
2019 gst_structure_free (s);
2022 fail_unless (g_str_equal (str,
2023 "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22;"));
2031 date_time_equal (GstDateTime * a, GstDateTime * b)
2033 if (gst_date_time_get_year (a) != gst_date_time_get_year (b) ||
2034 gst_date_time_get_month (a) != gst_date_time_get_month (b) ||
2035 gst_date_time_get_day (a) != gst_date_time_get_day (b))
2038 if (gst_date_time_get_hour (a) != gst_date_time_get_hour (b) ||
2039 gst_date_time_get_minute (a) != gst_date_time_get_minute (b) ||
2040 gst_date_time_get_second (a) != gst_date_time_get_second (b) ||
2041 gst_date_time_get_microsecond (a) != gst_date_time_get_microsecond (b))
2044 if (gst_date_time_get_time_zone_offset (a) !=
2045 gst_date_time_get_time_zone_offset (b))
2051 GST_START_TEST (test_date_time)
2054 GstDateTime *datetime, *datetime2;
2058 datetime = gst_date_time_new (0, 2010, 6, 23, 7, 40, 10);
2060 s = gst_structure_new ("media/x-type", "SOME_DATE_TIME_TAG",
2061 GST_TYPE_DATE_TIME, datetime, NULL);
2063 fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2064 GST_TYPE_DATE_TIME));
2065 fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2067 fail_unless (datetime2 != NULL);
2068 fail_unless (date_time_equal (datetime, datetime2));
2070 gst_date_time_unref (datetime);
2071 gst_date_time_unref (datetime2);
2075 str = gst_structure_to_string (s);
2076 gst_structure_free (s);
2079 fail_unless (g_str_equal (str,
2080 "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000000+0000\";"));
2082 s = gst_structure_from_string (str, NULL);
2086 fail_unless (s != NULL);
2087 fail_unless (gst_structure_has_name (s, "media/x-type"));
2088 fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2089 GST_TYPE_DATE_TIME));
2090 fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2092 fail_unless (datetime != NULL);
2093 fail_unless (gst_date_time_get_year (datetime) == 2010);
2094 fail_unless (gst_date_time_get_month (datetime) == 6);
2095 fail_unless (gst_date_time_get_day (datetime) == 23);
2096 fail_unless (gst_date_time_get_hour (datetime) == 7);
2097 fail_unless (gst_date_time_get_minute (datetime) == 40);
2098 fail_unless (gst_date_time_get_second (datetime) == 10);
2099 fail_unless (gst_date_time_get_microsecond (datetime) == 0);
2100 fail_unless (gst_date_time_get_time_zone_offset (datetime) == 0);
2101 gst_date_time_unref (datetime);
2104 str = gst_structure_to_string (s);
2105 gst_structure_free (s);
2108 fail_unless (g_str_equal (str,
2109 "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000000+0000\";"));
2114 datetime = gst_date_time_new (-3.0, 2010, 6, 23, 7, 40, 10.000001);
2116 s = gst_structure_new ("media/x-type", "SOME_DATE_TIME_TAG",
2117 GST_TYPE_DATE_TIME, datetime, NULL);
2119 fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2120 GST_TYPE_DATE_TIME));
2121 fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2123 fail_unless (datetime2 != NULL);
2124 fail_unless (date_time_equal (datetime, datetime2));
2126 gst_date_time_unref (datetime);
2127 gst_date_time_unref (datetime2);
2131 str = gst_structure_to_string (s);
2132 gst_structure_free (s);
2135 fail_unless (g_str_equal (str,
2136 "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000001-0300\";"));
2138 s = gst_structure_from_string (str, NULL);
2142 fail_unless (s != NULL);
2143 fail_unless (gst_structure_has_name (s, "media/x-type"));
2144 fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2145 GST_TYPE_DATE_TIME));
2146 fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2148 fail_unless (datetime != NULL);
2149 fail_unless (gst_date_time_get_year (datetime) == 2010);
2150 fail_unless (gst_date_time_get_month (datetime) == 6);
2151 fail_unless (gst_date_time_get_day (datetime) == 23);
2152 fail_unless (gst_date_time_get_hour (datetime) == 7);
2153 fail_unless (gst_date_time_get_minute (datetime) == 40);
2154 fail_unless (gst_date_time_get_second (datetime) == 10);
2155 fail_unless (gst_date_time_get_microsecond (datetime) == 1);
2156 fail_unless (gst_date_time_get_time_zone_offset (datetime) == -3);
2157 gst_date_time_unref (datetime);
2160 str = gst_structure_to_string (s);
2161 gst_structure_free (s);
2163 fail_unless (g_str_equal (str,
2164 "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000001-0300\";"));
2169 /* with positive timezone */
2170 datetime = gst_date_time_new (2.0, 2010, 6, 23, 7, 40, 10.000001);
2172 s = gst_structure_new ("media/x-type", "SOME_DATE_TIME_TAG",
2173 GST_TYPE_DATE_TIME, datetime, NULL);
2175 fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2176 GST_TYPE_DATE_TIME));
2177 fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2179 fail_unless (datetime2 != NULL);
2180 fail_unless (date_time_equal (datetime, datetime2));
2182 gst_date_time_unref (datetime);
2183 gst_date_time_unref (datetime2);
2187 str = gst_structure_to_string (s);
2188 gst_structure_free (s);
2191 fail_unless (g_str_equal (str,
2192 "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000001+0200\";"));
2194 s = gst_structure_from_string (str, NULL);
2198 fail_unless (s != NULL);
2199 fail_unless (gst_structure_has_name (s, "media/x-type"));
2200 fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
2201 GST_TYPE_DATE_TIME));
2202 fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
2204 fail_unless (datetime != NULL);
2205 fail_unless (gst_date_time_get_year (datetime) == 2010);
2206 fail_unless (gst_date_time_get_month (datetime) == 6);
2207 fail_unless (gst_date_time_get_day (datetime) == 23);
2208 fail_unless (gst_date_time_get_hour (datetime) == 7);
2209 fail_unless (gst_date_time_get_minute (datetime) == 40);
2210 fail_unless (gst_date_time_get_second (datetime) == 10);
2211 fail_unless (gst_date_time_get_microsecond (datetime) == 1);
2212 fail_unless (gst_date_time_get_time_zone_offset (datetime) == 2);
2213 gst_date_time_unref (datetime);
2216 str = gst_structure_to_string (s);
2217 gst_structure_free (s);
2219 fail_unless (g_str_equal (str,
2220 "media/x-type, SOME_DATE_TIME_TAG=(datetime)\"2010-06-23T07:40:10.000001+0200\";"));
2229 GST_START_TEST (test_fraction_range)
2231 GValue range = { 0, };
2232 GValue start = { 0, };
2233 GValue end = { 0, };
2234 GValue src = { 0, };
2235 GValue dest = { 0, };
2236 GValue range2 = { 0, };
2238 g_value_init (&range, GST_TYPE_FRACTION_RANGE);
2239 g_value_init (&range2, GST_TYPE_FRACTION_RANGE);
2240 g_value_init (&start, GST_TYPE_FRACTION);
2241 g_value_init (&end, GST_TYPE_FRACTION);
2242 g_value_init (&src, GST_TYPE_FRACTION);
2244 gst_value_set_fraction (&src, 1, 2);
2246 /* Check that a intersection of fraction & range = fraction */
2247 gst_value_set_fraction (&start, 1, 4);
2248 gst_value_set_fraction (&end, 2, 3);
2249 gst_value_set_fraction_range (&range, &start, &end);
2251 fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
2252 fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION);
2253 fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
2255 /* Check that a intersection selects the overlapping range */
2256 gst_value_set_fraction (&start, 1, 3);
2257 gst_value_set_fraction (&end, 2, 3);
2258 gst_value_set_fraction_range (&range2, &start, &end);
2259 g_value_unset (&dest);
2260 fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
2261 fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
2263 gst_value_set_fraction_range (&range2, &start, &end);
2264 fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
2266 /* Check that non intersection ranges don't intersect */
2267 gst_value_set_fraction (&start, 4, 2);
2268 gst_value_set_fraction (&end, 5, 2);
2269 gst_value_set_fraction_range (&range2, &start, &end);
2270 g_value_unset (&dest);
2271 fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
2273 g_value_unset (&start);
2274 g_value_unset (&end);
2275 g_value_unset (&range);
2276 g_value_unset (&range2);
2277 g_value_unset (&src);
2282 GST_START_TEST (test_serialize_deserialize_format_enum)
2284 GstStructure *s, *s2;
2285 GstFormat foobar_fmt;
2286 gchar *str, *str2, *end = NULL;
2288 /* make sure custom formats are serialised properly as well */
2289 foobar_fmt = gst_format_register ("foobar", "GST_FORMAT_FOOBAR");
2290 fail_unless (foobar_fmt != GST_FORMAT_UNDEFINED);
2292 s = gst_structure_new ("foo/bar", "format1", GST_TYPE_FORMAT,
2293 GST_FORMAT_BYTES, "format2", GST_TYPE_FORMAT, GST_FORMAT_TIME,
2294 "format3", GST_TYPE_FORMAT, GST_FORMAT_DEFAULT, "format4",
2295 GST_TYPE_FORMAT, foobar_fmt, NULL);
2297 str = gst_structure_to_string (s);
2298 GST_LOG ("Got structure string '%s'", GST_STR_NULL (str));
2299 fail_unless (str != NULL);
2300 fail_unless (strstr (str, "TIME") != NULL);
2301 fail_unless (strstr (str, "BYTE") != NULL);
2302 fail_unless (strstr (str, "DEFAULT") != NULL);
2303 fail_unless (strstr (str, "FOOBAR") != NULL);
2305 s2 = gst_structure_from_string (str, &end);
2306 fail_unless (s2 != NULL);
2308 str2 = gst_structure_to_string (s2);
2309 fail_unless (str2 != NULL);
2311 fail_unless (g_str_equal (str, str2));
2315 gst_structure_free (s);
2316 gst_structure_free (s2);
2321 GST_START_TEST (test_serialize_deserialize_caps)
2323 GValue value = { 0 }
2326 GstCaps *caps, *caps2;
2329 caps = gst_caps_new_simple ("test/caps",
2330 "foo", G_TYPE_INT, 10, "bar", G_TYPE_STRING, "test", NULL);
2331 fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
2333 /* and assign caps to gvalue */
2334 g_value_init (&value, GST_TYPE_CAPS);
2335 g_value_take_boxed (&value, caps);
2336 fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
2338 /* now serialize it */
2339 serialized = gst_value_serialize (&value);
2340 GST_DEBUG ("serialized caps to %s", serialized);
2341 fail_unless (serialized != NULL);
2343 /* refcount should not change */
2344 fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
2346 /* now deserialize again */
2347 g_value_init (&value2, GST_TYPE_CAPS);
2348 gst_value_deserialize (&value2, serialized);
2350 caps2 = g_value_get_boxed (&value2);
2351 fail_if (GST_CAPS_REFCOUNT_VALUE (caps2) != 1);
2353 /* they should be equal */
2354 fail_unless (gst_caps_is_equal (caps, caps2));
2357 g_value_unset (&value);
2358 g_value_unset (&value2);
2359 g_free (serialized);
2364 GST_START_TEST (test_int_range)
2366 GValue range = { 0, };
2367 GValue start = { 0, };
2368 GValue end = { 0, };
2369 GValue src = { 0, };
2370 GValue dest = { 0, };
2371 GValue range2 = { 0, };
2373 g_value_init (&range, GST_TYPE_INT_RANGE);
2374 g_value_init (&range2, GST_TYPE_INT_RANGE);
2375 g_value_init (&start, G_TYPE_INT);
2376 g_value_init (&end, G_TYPE_INT);
2377 g_value_init (&src, G_TYPE_INT);
2379 g_value_set_int (&src, 2);
2381 /* Check that a intersection of int & range = int */
2382 gst_value_set_int_range (&range, 1, 5);
2384 fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
2385 fail_unless (G_VALUE_TYPE (&dest) == G_TYPE_INT);
2386 fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
2388 /* Check that a intersection selects the overlapping range */
2389 gst_value_set_int_range (&range2, 2, 3);
2390 g_value_unset (&dest);
2391 fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
2392 fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
2394 fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
2396 /* Check that non intersection ranges don't intersect */
2397 gst_value_set_int_range (&range2, 6, 7);
2398 g_value_unset (&dest);
2399 fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
2401 g_value_unset (&start);
2402 g_value_unset (&end);
2403 g_value_unset (&range);
2404 g_value_unset (&range2);
2405 g_value_unset (&src);
2410 GST_START_TEST (test_int64_range)
2412 GValue range = { 0, };
2413 GValue start = { 0, };
2414 GValue end = { 0, };
2415 GValue src = { 0, };
2416 GValue dest = { 0, };
2417 GValue range2 = { 0, };
2419 g_value_init (&range, GST_TYPE_INT64_RANGE);
2420 g_value_init (&range2, GST_TYPE_INT64_RANGE);
2421 g_value_init (&start, G_TYPE_INT64);
2422 g_value_init (&end, G_TYPE_INT64);
2423 g_value_init (&src, G_TYPE_INT64);
2425 g_value_set_int64 (&src, 2);
2427 /* Check that a intersection of int64 & range = int64 */
2428 gst_value_set_int64_range (&range, 1, 5);
2430 fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
2431 fail_unless (G_VALUE_TYPE (&dest) == G_TYPE_INT64);
2432 fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
2434 /* Check that a intersection selects the overlapping range */
2435 gst_value_set_int64_range (&range2, 2, 3);
2436 g_value_unset (&dest);
2437 fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
2438 fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
2440 fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
2442 /* Check that non intersection ranges don't intersect */
2443 gst_value_set_int64_range (&range2, 6, 7);
2444 g_value_unset (&dest);
2445 fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
2447 g_value_unset (&start);
2448 g_value_unset (&end);
2449 g_value_unset (&range);
2450 g_value_unset (&range2);
2451 g_value_unset (&src);
2456 GST_START_TEST (test_serialize_int64_range)
2460 gint64 int64_ranges[] = {
2466 gint int64_ranges_size = sizeof (int64_ranges) / sizeof (int64_ranges[0]) / 2;
2468 gchar *int64_range_strings[] = {
2469 g_strdup ("[ 0, 5 ]"),
2470 g_strdup_printf ("[ 0, %" G_GINT64_FORMAT " ]", (gint64) G_MAXINT),
2471 g_strdup_printf ("[ 5, %" G_GINT64_FORMAT " ]", (gint64) G_MAXINT32),
2472 g_strdup_printf ("[ 5, %" G_GINT64_FORMAT " ]", G_MAXINT64),
2474 gint int64_range_strings_size =
2475 sizeof (int64_range_strings) / sizeof (int64_range_strings[0]);
2477 fail_unless (int64_ranges_size == int64_range_strings_size);
2479 while (i + 1 < (int64_ranges_size * 2)) {
2483 GValue value = { 0 };
2484 const GValue *deserialized_value;
2488 g_value_init (&value, GST_TYPE_INT64_RANGE);
2490 /* check serialization */
2491 gst_value_set_int64_range (&value, int64_ranges[i], int64_ranges[i + 1]);
2492 str = gst_value_serialize (&value);
2493 fail_unless (strcmp (str, int64_range_strings[idx]) == 0);
2494 g_free (int64_range_strings[idx]);
2496 /* now deserialize again to an int64 range */
2497 s = gst_structure_new ("foo/bar", "range", GST_TYPE_INT64_RANGE,
2498 int64_ranges[i], int64_ranges[i + 1], NULL);
2499 deserialized_value = gst_structure_get_value (s, "range");
2500 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (deserialized_value) == TRUE);
2501 str2 = gst_value_serialize (deserialized_value);
2503 fail_unless (gst_value_get_int64_range_min (deserialized_value) ==
2505 fail_unless (gst_value_get_int64_range_max (deserialized_value) ==
2506 int64_ranges[i + 1]);
2508 gst_structure_free (s);
2518 GST_START_TEST (test_deserialize_int_range)
2523 const GValue *deserialized_value;
2525 /* check a valid int_range deserialization */
2526 str = g_strdup_printf ("foo/bar, range=[ 1, %d ];", G_MAXINT);
2527 s = gst_structure_from_string (str, &end);
2528 fail_unless (*end == '\0');
2529 deserialized_value = gst_structure_get_value (s, "range");
2530 fail_unless (GST_VALUE_HOLDS_INT_RANGE (deserialized_value) == TRUE);
2531 fail_unless (gst_value_get_int_range_min (deserialized_value) == 1);
2532 fail_unless (gst_value_get_int_range_max (deserialized_value) == G_MAXINT);
2533 gst_structure_free (s);
2537 /* check invalid int_range deserialization */
2539 g_strdup_printf ("foo/bar, range=[ 1, %" G_GINT64_FORMAT " ];",
2540 (gint64) G_MAXINT + 1);
2541 ASSERT_CRITICAL (s = gst_structure_from_string (str, &end));
2543 gst_structure_free (s);
2545 g_strdup_printf ("foo/bar, range=[ %" G_GINT64_FORMAT ", %"
2546 G_GINT64_FORMAT " ];", (gint64) G_MAXINT, (gint64) G_MAXINT + 1);
2547 ASSERT_CRITICAL (s = gst_structure_from_string (str, NULL));
2550 gst_structure_free (s);
2552 /* check a valid int64_range deserialization. Those ranges need to
2553 * be explicit about their storage type. */
2554 str = g_strdup_printf ("foo/bar, range=(gint64)[ 1, %d ];", G_MAXINT);
2555 s = gst_structure_from_string (str, &end);
2556 fail_unless (*end == '\0');
2557 deserialized_value = gst_structure_get_value (s, "range");
2558 fail_unless (GST_VALUE_HOLDS_INT64_RANGE (deserialized_value) == TRUE);
2559 fail_unless (gst_value_get_int64_range_min (deserialized_value) == 1);
2560 fail_unless (gst_value_get_int64_range_max (deserialized_value) == G_MAXINT);
2561 str2 = gst_structure_to_string (s);
2562 fail_unless (strcmp (str, str2) == 0);
2563 gst_structure_free (s);
2568 /* check invalid int64_range (starting with a gint) deserialization */
2570 g_strdup_printf ("foo/bar, range=(gint64)[ 1, %" G_GUINT64_FORMAT " ];",
2571 (guint64) G_MAXINT64 + 1);
2572 ASSERT_CRITICAL (s = gst_structure_from_string (str, &end));
2573 fail_unless (*end == '\0');
2574 gst_structure_free (s);
2578 /* check invalid int64_range deserialization into a int64_range */
2580 g_strdup_printf ("foo/bar, range=(gint64)[ %" G_GINT64_FORMAT ", %"
2581 G_GUINT64_FORMAT " ];", (gint64) G_MAXINT, (guint64) G_MAXINT64 + 1);
2582 ASSERT_CRITICAL (s = gst_structure_from_string (str, NULL));
2584 gst_structure_free (s);
2586 /* check invalid int64_range deserialization into a int_range */
2588 g_strdup_printf ("foo/bar, range=[ %" G_GINT64_FORMAT ", %"
2589 G_GUINT64_FORMAT " ];", (gint64) G_MAXINT, (guint64) G_MAXINT64 + 1);
2590 s = gst_structure_from_string (str, &end);
2591 fail_unless (s == NULL);
2592 fail_unless (end == NULL);
2596 GST_END_TEST static Suite *
2597 gst_value_suite (void)
2599 Suite *s = suite_create ("GstValue");
2600 TCase *tc_chain = tcase_create ("general");
2602 suite_add_tcase (s, tc_chain);
2603 tcase_add_test (tc_chain, test_serialize_fourcc);
2604 tcase_add_test (tc_chain, test_deserialize_fourcc);
2605 tcase_add_test (tc_chain, test_deserialize_buffer);
2606 tcase_add_test (tc_chain, test_serialize_buffer);
2607 tcase_add_test (tc_chain, test_deserialize_gint);
2608 tcase_add_test (tc_chain, test_deserialize_gint_failures);
2609 tcase_add_test (tc_chain, test_deserialize_guint);
2610 tcase_add_test (tc_chain, test_deserialize_guint_failures);
2611 tcase_add_test (tc_chain, test_deserialize_gint64);
2612 tcase_add_test (tc_chain, test_deserialize_guint64);
2613 tcase_add_test (tc_chain, test_deserialize_guchar);
2614 tcase_add_test (tc_chain, test_deserialize_gstfraction);
2615 tcase_add_test (tc_chain, test_serialize_flags);
2616 tcase_add_test (tc_chain, test_deserialize_flags);
2617 tcase_add_test (tc_chain, test_serialize_deserialize_format_enum);
2618 tcase_add_test (tc_chain, test_string);
2619 tcase_add_test (tc_chain, test_deserialize_string);
2620 tcase_add_test (tc_chain, test_value_compare);
2621 tcase_add_test (tc_chain, test_value_intersect);
2622 tcase_add_test (tc_chain, test_value_subtract_int);
2623 tcase_add_test (tc_chain, test_value_subtract_int64);
2624 tcase_add_test (tc_chain, test_value_subtract_double);
2625 tcase_add_test (tc_chain, test_value_subtract_fraction);
2626 tcase_add_test (tc_chain, test_value_subtract_fraction_range);
2627 tcase_add_test (tc_chain, test_value_subtract_fraction_list);
2628 tcase_add_test (tc_chain, test_date);
2629 tcase_add_test (tc_chain, test_date_time);
2630 tcase_add_test (tc_chain, test_fraction_range);
2631 tcase_add_test (tc_chain, test_serialize_deserialize_caps);
2632 tcase_add_test (tc_chain, test_int_range);
2633 tcase_add_test (tc_chain, test_int64_range);
2634 tcase_add_test (tc_chain, test_serialize_int64_range);
2635 tcase_add_test (tc_chain, test_deserialize_int_range);
2640 GST_CHECK_MAIN (gst_value);