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_deserialize_buffer)
32 g_value_init (&value, GST_TYPE_BUFFER);
33 fail_unless (gst_value_deserialize (&value, "1234567890abcdef"));
34 /* does not increase the refcount */
35 buf = GST_BUFFER (gst_value_get_mini_object (&value));
36 ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
38 /* does not increase the refcount */
39 buf = gst_value_get_buffer (&value);
40 ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
43 g_value_unset (&value);
48 /* create and serialize a buffer */
49 GST_START_TEST (test_serialize_buffer)
54 static const char *buf_data = "1234567890abcdef";
57 len = strlen (buf_data);
58 buf = gst_buffer_new_and_alloc (len);
59 memcpy (GST_BUFFER_DATA (buf), buf_data, len);
60 ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
62 /* and assign buffer to mini object */
63 g_value_init (&value, GST_TYPE_BUFFER);
64 gst_value_take_buffer (&value, buf);
65 ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
67 /* now serialize it */
68 serialized = gst_value_serialize (&value);
69 GST_DEBUG ("serialized buffer to %s", serialized);
70 fail_unless (serialized != NULL);
72 /* refcount should not change */
73 ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
77 g_value_unset (&value);
79 /* take NULL buffer */
80 g_value_init (&value, GST_TYPE_BUFFER);
81 GST_DEBUG ("setting NULL buffer");
82 gst_value_take_buffer (&value, NULL);
84 /* now serialize it */
85 GST_DEBUG ("serializing NULL buffer");
86 serialized = gst_value_serialize (&value);
87 /* should return NULL */
88 fail_unless (serialized == NULL);
91 g_value_unset (&value);
96 GST_START_TEST (test_deserialize_gint64)
99 const char *strings[] = {
109 g_value_init (&value, G_TYPE_INT64);
111 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
112 fail_unless (gst_value_deserialize (&value, strings[i]),
113 "could not deserialize %s (%d)", strings[i], i);
114 fail_unless (g_value_get_int64 (&value) == results[i],
115 "resulting value is %" G_GINT64_FORMAT ", not %" G_GINT64_FORMAT
116 ", for string %s (%d)", g_value_get_int64 (&value),
117 results[i], strings[i], i);
123 GST_START_TEST (test_deserialize_gstfraction)
125 GValue value = { 0 };
126 const char *strings[] = {
130 gint64 result_numers[] = {
134 gint64 result_denoms[] = {
141 g_value_init (&value, GST_TYPE_FRACTION);
142 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
143 fail_unless (gst_value_deserialize (&value, strings[i]),
144 "could not deserialize %s (%d)", strings[i], i);
145 fail_unless (gst_value_get_fraction_numerator (&value) == result_numers[i],
146 "resulting numerator value is %d, not %d"
147 ", for string %s (%d)", gst_value_get_fraction_numerator (&value),
148 result_numers[i], strings[i], i);
149 fail_unless (gst_value_get_fraction_denominator (&value) ==
150 result_denoms[i], "resulting denominator value is %d, not %d"
151 ", for string %s (%d)", gst_value_get_fraction_denominator (&value),
152 result_denoms[i], strings[i], i);
158 GST_START_TEST (test_deserialize_gint)
160 GValue value = { 0 };
161 const char *strings[] = {
166 /* a positive long long, serializing to highest possible positive sint */
168 /* a positive long long, serializing to lowest possible negative sint */
170 /* a negative long long, serializing to lowest possible negative sint */
171 "0xFFFFFFFF80000000",
173 /* a positive long long serializing to -1 */
176 /* a negative long long serializing to -1 */
177 "0xFFFFFFFFFFFFFFFF",
178 "0xFFFFFFFFFFFFFFFF",
193 /* cast needs to be explicit because of unsigned -> signed */
194 (gint) 0xFFFFFFFFFFFFFFFFLL,
199 g_value_init (&value, G_TYPE_INT);
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_int (&value) == results[i],
205 "resulting value is %d, not %d, for string %s (%d)",
206 g_value_get_int (&value), results[i], strings[i], i);
212 GST_START_TEST (test_deserialize_gint_failures)
214 GValue value = { 0 };
215 const char *strings[] = {
216 "-", /* not a complete number */
217 "- TEST", /* not a complete number */
218 "0x0000000100000000", /* lowest long long that cannot fit in 32 bits */
219 "0xF000000000000000",
220 "0xFFFFFFF000000000",
221 "0xFFFFFFFF00000000",
222 "0x10000000000000000", /* first number too long to fit into a long long */
223 /* invent a new processor first before trying to make this one pass */
224 "0x10000000000000000000000000000000000000000000",
228 g_value_init (&value, G_TYPE_INT);
230 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
231 fail_if (gst_value_deserialize (&value, strings[i]),
232 "deserialized %s (%d), while it should have failed", strings[i], i);
238 GST_START_TEST (test_deserialize_guint)
240 GValue value = { 0 };
241 const char *strings[] = {
246 /* a positive long long, serializing to highest possible positive sint */
248 /* a positive long long, serializing to lowest possible negative sint */
251 /* a negative long long, serializing to lowest possible negative sint */
252 "0xFFFFFFFF80000000",
253 /* a value typically used for rgb masks */
255 /* a positive long long serializing to highest possible positive uint */
258 /* a negative long long serializing to highest possible positive uint */
259 "0xFFFFFFFFFFFFFFFF",
269 (guint) 2147483648LL,
274 (guint) 0xFFFFFFFFFFFFFFFFLL,
279 g_value_init (&value, G_TYPE_UINT);
281 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
282 fail_unless (gst_value_deserialize (&value, strings[i]),
283 "could not deserialize %s (%d)", strings[i], i);
284 fail_unless (g_value_get_uint (&value) == results[i],
285 "resulting value is %d, not %d, for string %s (%d)",
286 g_value_get_uint (&value), results[i], strings[i], i);
292 GST_START_TEST (test_deserialize_guint_failures)
294 GValue value = { 0 };
295 const char *strings[] = {
296 "-", /* not a complete number */
297 "- TEST", /* not a complete number */
299 /* FIXME: these values should not be deserializable, since they overflow
300 * the target format */
301 "0x0000000100000000", /* lowest long long that cannot fit in 32 bits */
302 "0xF000000000000000",
303 "0xFFFFFFF000000000",
304 "0xFFFFFFFF00000000",
305 "0x10000000000000000", /* first number too long to fit into a long long */
306 /* invent a new processor first before trying to make this one pass */
307 "0x10000000000000000000000000000000000000000000",
312 g_value_init (&value, G_TYPE_UINT);
314 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
315 fail_if (gst_value_deserialize (&value, strings[i]),
316 "deserialized %s (%d), while it should have failed", strings[i], i);
322 GST_START_TEST (test_serialize_flags)
324 GValue value = { 0 };
326 GstSeekFlags flags[] = {
330 GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
332 const char *results[] = {
333 "GST_SEEK_FLAG_NONE",
334 "GST_SEEK_FLAG_NONE",
335 "GST_SEEK_FLAG_FLUSH",
336 "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",
340 g_value_init (&value, GST_TYPE_SEEK_FLAGS);
342 for (i = 0; i < G_N_ELEMENTS (flags); ++i) {
343 g_value_set_flags (&value, flags[i]);
344 string = gst_value_serialize (&value);
345 fail_if (string == NULL, "could not serialize flags %d", i);
346 fail_unless (strcmp (string, results[i]) == 0,
347 "resulting value is %s, not %s, for flags #%d", string, results[i], i);
355 GST_START_TEST (test_deserialize_flags)
357 GValue value = { 0 };
358 const char *strings[] = {
361 "GST_SEEK_FLAG_NONE",
362 "GST_SEEK_FLAG_FLUSH",
363 "GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",
365 GstSeekFlags results[] = {
370 GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
374 g_value_init (&value, GST_TYPE_SEEK_FLAGS);
376 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
377 fail_unless (gst_value_deserialize (&value, strings[i]),
378 "could not deserialize %s (%d)", strings[i], i);
379 fail_unless (g_value_get_flags (&value) == results[i],
380 "resulting value is %d, not %d, for string %s (%d)",
381 g_value_get_flags (&value), results[i], strings[i], i);
387 GST_START_TEST (test_string)
398 g_value_init (&v, G_TYPE_STRING);
399 for (i = 0; i < G_N_ELEMENTS (try); i++) {
400 g_value_set_string (&v, try[i]);
401 tmp = gst_value_serialize (&v);
402 fail_if (tmp == NULL, "couldn't serialize: %s\n", try[i]);
403 fail_unless (gst_value_deserialize (&v, tmp),
404 "couldn't deserialize: %s\n", tmp);
407 fail_unless (g_str_equal (g_value_get_string (&v), try[i]),
408 "\nserialized : %s\ndeserialized: %s", try[i],
409 g_value_get_string (&v));
411 /* NULL strings should not be serializable */
412 g_value_set_string (&v, NULL);
413 fail_unless (gst_value_serialize (&v) == NULL);
419 GST_START_TEST (test_deserialize_string)
427 "", ""}, /* empty strings */
429 "\"\"", ""}, /* FAILURES */
431 "\"", NULL}, /* missing second quote */
433 "\"Hello\\ World", NULL}, /* missing second quote */
435 "\"\\", NULL}, /* quote at end, missing second quote */
437 "\"\\0", NULL}, /* missing second quote */
439 "\"\\0\"", NULL}, /* unfinished escaped character */
441 "\" \"", NULL}, /* spaces must be escaped */
443 /* FIXME 0.9: this test should fail, but it doesn't */
445 "tüüt", NULL} /* string with special chars must be escaped */
452 g_value_init (&v, G_TYPE_STRING);
453 for (i = 0; i < G_N_ELEMENTS (tests); i++) {
454 if (gst_value_deserialize (&v, tests[i].from)) {
455 fail_if (tests[i].to == NULL,
456 "I got %s instead of a failure", g_value_get_string (&v));
457 fail_unless (g_str_equal (g_value_get_string (&v), tests[i].to),
458 "\nwanted: %s\ngot : %s", tests[i].to, g_value_get_string (&v));
460 fail_if (tests[i].to != NULL, "failed, but wanted: %s", tests[i].to);
469 GST_START_TEST (test_value_compare)
471 GValue value1 = { 0 };
472 GValue value2 = { 0 };
474 g_value_init (&value1, G_TYPE_INT);
475 g_value_set_int (&value1, 10);
476 g_value_init (&value2, G_TYPE_INT);
477 g_value_set_int (&value2, 20);
478 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
479 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
480 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
481 g_value_unset (&value1);
482 g_value_unset (&value2);
484 g_value_init (&value1, G_TYPE_DOUBLE);
485 g_value_set_double (&value1, 10);
486 g_value_init (&value2, G_TYPE_DOUBLE);
487 g_value_set_double (&value2, 20);
488 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
489 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
490 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
491 g_value_unset (&value1);
492 g_value_unset (&value2);
494 g_value_init (&value1, G_TYPE_STRING);
495 g_value_set_string (&value1, "a");
496 g_value_init (&value2, G_TYPE_STRING);
497 g_value_set_string (&value2, "b");
498 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
499 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
500 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
501 g_value_unset (&value1);
502 g_value_unset (&value2);
504 g_value_init (&value1, GST_TYPE_FOURCC);
505 gst_value_set_fourcc (&value1, GST_MAKE_FOURCC ('a', 'b', 'c', 'd'));
506 g_value_init (&value2, GST_TYPE_FOURCC);
507 gst_value_set_fourcc (&value2, GST_MAKE_FOURCC ('1', '2', '3', '4'));
508 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
509 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
510 g_value_unset (&value1);
511 g_value_unset (&value2);
513 /* comparing 2/3 with 3/4 */
514 g_value_init (&value1, GST_TYPE_FRACTION);
515 gst_value_set_fraction (&value1, 2, 3);
516 g_value_init (&value2, GST_TYPE_FRACTION);
517 gst_value_set_fraction (&value2, 3, 4);
518 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
519 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
520 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
521 g_value_unset (&value1);
522 g_value_unset (&value2);
524 /* comparing -4/5 with 2/-3 */
525 g_value_init (&value1, GST_TYPE_FRACTION);
526 gst_value_set_fraction (&value1, -4, 5);
527 g_value_init (&value2, GST_TYPE_FRACTION);
528 gst_value_set_fraction (&value2, 2, -3);
529 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
530 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
531 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
532 g_value_unset (&value1);
533 g_value_unset (&value2);
535 /* comparing 10/100 with 200/2000 */
536 g_value_init (&value1, GST_TYPE_FRACTION);
537 gst_value_set_fraction (&value1, 10, 100);
538 g_value_init (&value2, GST_TYPE_FRACTION);
539 gst_value_set_fraction (&value2, 200, 2000);
540 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL);
541 g_value_unset (&value1);
542 g_value_unset (&value2);
544 /* comparing -4/5 with 2/-3 */
545 g_value_init (&value1, GST_TYPE_FRACTION);
546 gst_value_set_fraction (&value1, -4, 5);
547 g_value_init (&value2, GST_TYPE_FRACTION);
548 gst_value_set_fraction (&value2, 2, -3);
549 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
550 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
551 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
552 g_value_unset (&value1);
553 g_value_unset (&value2);
559 GST_START_TEST (test_value_intersect)
567 g_value_init (&src1, G_TYPE_INT);
568 g_value_set_int (&src1, 10);
569 g_value_init (&src2, G_TYPE_INT);
570 g_value_set_int (&src2, 20);
571 ret = gst_value_intersect (&dest, &src1, &src2);
572 fail_unless (ret == FALSE);
573 g_value_unset (&src1);
574 g_value_unset (&src2);
576 g_value_init (&src1, GST_TYPE_FOURCC);
577 gst_value_set_fourcc (&src1, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
578 g_value_init (&src2, GST_TYPE_LIST);
579 g_value_init (&item, GST_TYPE_FOURCC);
580 gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
581 gst_value_list_append_value (&src2, &item);
582 gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('I', '4', '2', '0'));
583 gst_value_list_append_value (&src2, &item);
584 gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('A', 'B', 'C', 'D'));
585 gst_value_list_append_value (&src2, &item);
587 fail_unless (gst_value_intersect (&dest, &src1, &src2));
588 fail_unless (GST_VALUE_HOLDS_FOURCC (&dest));
589 fail_unless (gst_value_get_fourcc (&dest) ==
590 GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
592 g_value_unset (&src1);
593 g_value_unset (&src2);
599 GST_START_TEST (test_value_subtract_int)
609 g_value_init (&src1, G_TYPE_INT);
610 g_value_set_int (&src1, 10);
611 g_value_init (&src2, G_TYPE_INT);
612 g_value_set_int (&src2, 20);
613 /* subtract as in sets, result is 10 */
614 ret = gst_value_subtract (&dest, &src1, &src2);
615 fail_unless (ret == TRUE);
616 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
617 g_value_unset (&dest);
619 /* same values, yields empty set */
620 ret = gst_value_subtract (&dest, &src1, &src1);
621 fail_unless (ret == FALSE);
622 g_value_unset (&src1);
623 g_value_unset (&src2);
628 /* would yield an empty set */
629 g_value_init (&src1, G_TYPE_INT);
630 g_value_set_int (&src1, 10);
631 g_value_init (&src2, GST_TYPE_INT_RANGE);
632 gst_value_set_int_range (&src2, 0, 20);
633 ret = gst_value_subtract (&dest, &src1, &src2);
634 fail_unless (ret == FALSE);
636 /* and the other way around, should create a list of two ranges. */
637 ret = gst_value_subtract (&dest, &src2, &src1);
638 fail_unless (ret == TRUE);
639 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
640 tmp = gst_value_list_get_value (&dest, 0);
641 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
642 fail_unless (gst_value_get_int_range_min (tmp) == 0);
643 fail_unless (gst_value_get_int_range_max (tmp) == 9);
644 tmp = gst_value_list_get_value (&dest, 1);
645 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
646 fail_unless (gst_value_get_int_range_min (tmp) == 11);
647 fail_unless (gst_value_get_int_range_max (tmp) == 20);
648 g_value_unset (&dest);
649 g_value_unset (&src1);
650 g_value_unset (&src2);
652 /* border case 1, empty set */
653 g_value_init (&src1, G_TYPE_INT);
654 g_value_set_int (&src1, 10);
655 g_value_init (&src2, GST_TYPE_INT_RANGE);
656 gst_value_set_int_range (&src2, 10, 20);
657 ret = gst_value_subtract (&dest, &src1, &src2);
658 fail_unless (ret == FALSE);
660 /* and the other way around, should create a new range. */
661 ret = gst_value_subtract (&dest, &src2, &src1);
662 fail_unless (ret == TRUE);
663 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
664 fail_unless (gst_value_get_int_range_min (&dest) == 11);
665 fail_unless (gst_value_get_int_range_max (&dest) == 20);
666 g_value_unset (&dest);
667 g_value_unset (&src1);
668 g_value_unset (&src2);
670 /* border case 2, empty set */
671 g_value_init (&src1, G_TYPE_INT);
672 g_value_set_int (&src1, 20);
673 g_value_init (&src2, GST_TYPE_INT_RANGE);
674 gst_value_set_int_range (&src2, 10, 20);
675 ret = gst_value_subtract (&dest, &src1, &src2);
676 fail_unless (ret == FALSE);
678 /* and the other way around, should create a new range. */
679 ret = gst_value_subtract (&dest, &src2, &src1);
680 fail_unless (ret == TRUE);
681 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
682 fail_unless (gst_value_get_int_range_min (&dest) == 10);
683 fail_unless (gst_value_get_int_range_max (&dest) == 19);
684 g_value_unset (&dest);
685 g_value_unset (&src1);
686 g_value_unset (&src2);
688 /* case 3, valid set */
689 g_value_init (&src1, G_TYPE_INT);
690 g_value_set_int (&src1, 0);
691 g_value_init (&src2, GST_TYPE_INT_RANGE);
692 gst_value_set_int_range (&src2, 10, 20);
693 ret = gst_value_subtract (&dest, &src1, &src2);
694 fail_unless (ret == TRUE);
695 fail_unless (G_VALUE_HOLDS_INT (&dest) == TRUE);
696 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
697 g_value_unset (&dest);
699 /* and the other way around, should keep the range. */
700 ret = gst_value_subtract (&dest, &src2, &src1);
701 fail_unless (ret == TRUE);
702 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
703 fail_unless (gst_value_get_int_range_min (&dest) == 10);
704 fail_unless (gst_value_get_int_range_max (&dest) == 20);
705 g_value_unset (&dest);
706 g_value_unset (&src1);
707 g_value_unset (&src2);
709 /* int_range <-> int_range
712 /* same range, empty set */
713 g_value_init (&src1, GST_TYPE_INT_RANGE);
714 gst_value_set_int_range (&src1, 10, 20);
715 g_value_init (&src2, GST_TYPE_INT_RANGE);
716 gst_value_set_int_range (&src2, 10, 20);
717 ret = gst_value_subtract (&dest, &src1, &src2);
718 fail_unless (ret == FALSE);
719 ret = gst_value_subtract (&dest, &src2, &src1);
720 fail_unless (ret == FALSE);
721 g_value_unset (&src1);
722 g_value_unset (&src2);
724 /* non overlapping ranges */
725 g_value_init (&src1, GST_TYPE_INT_RANGE);
726 gst_value_set_int_range (&src1, 10, 20);
727 g_value_init (&src2, GST_TYPE_INT_RANGE);
728 gst_value_set_int_range (&src2, 30, 40);
729 ret = gst_value_subtract (&dest, &src1, &src2);
730 fail_unless (ret == TRUE);
731 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
732 fail_unless (gst_value_get_int_range_min (&dest) == 10);
733 fail_unless (gst_value_get_int_range_max (&dest) == 20);
734 g_value_unset (&dest);
736 ret = gst_value_subtract (&dest, &src2, &src1);
737 fail_unless (ret == TRUE);
738 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
739 fail_unless (gst_value_get_int_range_min (&dest) == 30);
740 fail_unless (gst_value_get_int_range_max (&dest) == 40);
741 g_value_unset (&dest);
742 g_value_unset (&src1);
743 g_value_unset (&src2);
745 /* completely overlapping ranges */
746 g_value_init (&src1, GST_TYPE_INT_RANGE);
747 gst_value_set_int_range (&src1, 10, 20);
748 g_value_init (&src2, GST_TYPE_INT_RANGE);
749 gst_value_set_int_range (&src2, 10, 30);
750 ret = gst_value_subtract (&dest, &src1, &src2);
751 fail_unless (ret == FALSE);
753 ret = gst_value_subtract (&dest, &src2, &src1);
754 fail_unless (ret == TRUE);
755 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
756 fail_unless (gst_value_get_int_range_min (&dest) == 21);
757 fail_unless (gst_value_get_int_range_max (&dest) == 30);
758 g_value_unset (&dest);
759 g_value_unset (&src1);
760 g_value_unset (&src2);
762 /* partially overlapping ranges */
763 g_value_init (&src1, GST_TYPE_INT_RANGE);
764 gst_value_set_int_range (&src1, 10, 20);
765 g_value_init (&src2, GST_TYPE_INT_RANGE);
766 gst_value_set_int_range (&src2, 15, 30);
767 ret = gst_value_subtract (&dest, &src1, &src2);
768 fail_unless (ret == TRUE);
769 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
770 fail_unless (gst_value_get_int_range_min (&dest) == 10);
771 fail_unless (gst_value_get_int_range_max (&dest) == 14);
772 g_value_unset (&dest);
774 ret = gst_value_subtract (&dest, &src2, &src1);
775 fail_unless (ret == TRUE);
776 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
777 fail_unless (gst_value_get_int_range_min (&dest) == 21);
778 fail_unless (gst_value_get_int_range_max (&dest) == 30);
779 g_value_unset (&dest);
780 g_value_unset (&src1);
781 g_value_unset (&src2);
783 /* create a hole { int_range, int_range } */
784 g_value_init (&src1, GST_TYPE_INT_RANGE);
785 gst_value_set_int_range (&src1, 10, 30);
786 g_value_init (&src2, GST_TYPE_INT_RANGE);
787 gst_value_set_int_range (&src2, 15, 20);
788 ret = gst_value_subtract (&dest, &src1, &src2);
789 fail_unless (ret == TRUE);
790 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
791 tmp = gst_value_list_get_value (&dest, 0);
792 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
793 fail_unless (gst_value_get_int_range_min (tmp) == 10);
794 fail_unless (gst_value_get_int_range_max (tmp) == 14);
795 tmp = gst_value_list_get_value (&dest, 1);
796 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
797 fail_unless (gst_value_get_int_range_min (tmp) == 21);
798 fail_unless (gst_value_get_int_range_max (tmp) == 30);
799 g_value_unset (&dest);
801 ret = gst_value_subtract (&dest, &src2, &src1);
802 fail_unless (ret == FALSE);
803 g_value_unset (&src1);
804 g_value_unset (&src2);
806 /* create a hole, { int, int } */
807 g_value_init (&src1, GST_TYPE_INT_RANGE);
808 gst_value_set_int_range (&src1, 10, 30);
809 g_value_init (&src2, GST_TYPE_INT_RANGE);
810 gst_value_set_int_range (&src2, 11, 29);
811 ret = gst_value_subtract (&dest, &src1, &src2);
812 fail_unless (ret == TRUE);
813 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
814 tmp = gst_value_list_get_value (&dest, 0);
815 fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
816 fail_unless (g_value_get_int (tmp) == 10);
817 tmp = gst_value_list_get_value (&dest, 1);
818 fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
819 fail_unless (g_value_get_int (tmp) == 30);
820 g_value_unset (&dest);
822 ret = gst_value_subtract (&dest, &src2, &src1);
823 fail_unless (ret == FALSE);
824 g_value_unset (&src1);
825 g_value_unset (&src2);
827 /* create a hole, { int, int_range } */
828 g_value_init (&src1, GST_TYPE_INT_RANGE);
829 gst_value_set_int_range (&src1, 10, 30);
830 g_value_init (&src2, GST_TYPE_INT_RANGE);
831 gst_value_set_int_range (&src2, 11, 28);
832 ret = gst_value_subtract (&dest, &src1, &src2);
833 fail_unless (ret == TRUE);
834 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
835 tmp = gst_value_list_get_value (&dest, 0);
836 fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
837 fail_unless (g_value_get_int (tmp) == 10);
838 tmp = gst_value_list_get_value (&dest, 1);
839 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
840 fail_unless (gst_value_get_int_range_min (tmp) == 29);
841 fail_unless (gst_value_get_int_range_max (tmp) == 30);
842 g_value_unset (&dest);
844 ret = gst_value_subtract (&dest, &src2, &src1);
845 fail_unless (ret == FALSE);
846 g_value_unset (&src1);
847 g_value_unset (&src2);
849 /* create a hole, { int_range, int } */
850 g_value_init (&src1, GST_TYPE_INT_RANGE);
851 gst_value_set_int_range (&src1, 10, 30);
852 g_value_init (&src2, GST_TYPE_INT_RANGE);
853 gst_value_set_int_range (&src2, 12, 29);
854 ret = gst_value_subtract (&dest, &src1, &src2);
855 fail_unless (ret == TRUE);
856 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
857 tmp = gst_value_list_get_value (&dest, 0);
858 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
859 fail_unless (gst_value_get_int_range_min (tmp) == 10);
860 fail_unless (gst_value_get_int_range_max (tmp) == 11);
861 tmp = gst_value_list_get_value (&dest, 1);
862 fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
863 fail_unless (g_value_get_int (tmp) == 30);
864 g_value_unset (&dest);
866 ret = gst_value_subtract (&dest, &src2, &src1);
867 fail_unless (ret == FALSE);
868 g_value_unset (&src1);
869 g_value_unset (&src2);
874 GST_START_TEST (test_value_subtract_double)
884 g_value_init (&src1, G_TYPE_DOUBLE);
885 g_value_set_double (&src1, 10.0);
886 g_value_init (&src2, G_TYPE_DOUBLE);
887 g_value_set_double (&src2, 20.0);
888 /* subtract as in sets, result is 10 */
889 ret = gst_value_subtract (&dest, &src1, &src2);
890 fail_unless (ret == TRUE);
891 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
892 g_value_unset (&dest);
894 /* same values, yields empty set */
895 ret = gst_value_subtract (&dest, &src1, &src1);
896 fail_unless (ret == FALSE);
897 g_value_unset (&src1);
898 g_value_unset (&src2);
900 /* double <-> double_range
903 /* would yield an empty set */
904 g_value_init (&src1, G_TYPE_DOUBLE);
905 g_value_set_double (&src1, 10.0);
906 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
907 gst_value_set_double_range (&src2, 0.0, 20.0);
908 ret = gst_value_subtract (&dest, &src1, &src2);
909 fail_unless (ret == FALSE);
911 /* and the other way around, we cannot create open ranges
912 * so the result is the range again */
913 ret = gst_value_subtract (&dest, &src2, &src1);
914 fail_unless (ret == TRUE);
915 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
916 fail_unless (gst_value_get_double_range_min (&dest) == 0.0);
917 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
918 g_value_unset (&dest);
919 g_value_unset (&src1);
920 g_value_unset (&src2);
922 /* border case 1, empty set */
923 g_value_init (&src1, G_TYPE_DOUBLE);
924 g_value_set_double (&src1, 10.0);
925 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
926 gst_value_set_double_range (&src2, 10.0, 20.0);
927 ret = gst_value_subtract (&dest, &src1, &src2);
928 fail_unless (ret == FALSE);
930 /* and the other way around, should keep same range as
931 * we don't have open ranges. */
932 ret = gst_value_subtract (&dest, &src2, &src1);
933 fail_unless (ret == TRUE);
934 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
935 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
936 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
937 g_value_unset (&dest);
938 g_value_unset (&src1);
939 g_value_unset (&src2);
941 /* border case 2, empty set */
942 g_value_init (&src1, G_TYPE_DOUBLE);
943 g_value_set_double (&src1, 20.0);
944 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
945 gst_value_set_double_range (&src2, 10.0, 20.0);
946 ret = gst_value_subtract (&dest, &src1, &src2);
947 fail_unless (ret == FALSE);
949 /* and the other way around, should keep same range as
950 * we don't have open ranges. */
951 ret = gst_value_subtract (&dest, &src2, &src1);
952 fail_unless (ret == TRUE);
953 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
954 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
955 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
956 g_value_unset (&dest);
957 g_value_unset (&src1);
958 g_value_unset (&src2);
960 /* case 3, valid set */
961 g_value_init (&src1, G_TYPE_DOUBLE);
962 g_value_set_double (&src1, 0.0);
963 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
964 gst_value_set_double_range (&src2, 10.0, 20.0);
965 ret = gst_value_subtract (&dest, &src1, &src2);
966 fail_unless (ret == TRUE);
967 fail_unless (G_VALUE_HOLDS_DOUBLE (&dest) == TRUE);
968 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
969 g_value_unset (&dest);
971 /* and the other way around, should keep the range. */
972 ret = gst_value_subtract (&dest, &src2, &src1);
973 fail_unless (ret == TRUE);
974 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
975 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
976 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
977 g_value_unset (&dest);
978 g_value_unset (&src1);
979 g_value_unset (&src2);
981 /* double_range <-> double_range
984 /* same range, empty set */
985 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
986 gst_value_set_double_range (&src1, 10.0, 20.0);
987 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
988 gst_value_set_double_range (&src2, 10.0, 20.0);
989 ret = gst_value_subtract (&dest, &src1, &src2);
990 fail_unless (ret == FALSE);
991 ret = gst_value_subtract (&dest, &src2, &src1);
992 fail_unless (ret == FALSE);
993 g_value_unset (&src1);
994 g_value_unset (&src2);
996 /* non overlapping ranges */
997 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
998 gst_value_set_double_range (&src1, 10.0, 20.0);
999 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1000 gst_value_set_double_range (&src2, 30.0, 40.0);
1001 ret = gst_value_subtract (&dest, &src1, &src2);
1002 fail_unless (ret == TRUE);
1003 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1004 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1005 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
1006 g_value_unset (&dest);
1008 ret = gst_value_subtract (&dest, &src2, &src1);
1009 fail_unless (ret == TRUE);
1010 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1011 fail_unless (gst_value_get_double_range_min (&dest) == 30.0);
1012 fail_unless (gst_value_get_double_range_max (&dest) == 40.0);
1013 g_value_unset (&dest);
1014 g_value_unset (&src1);
1015 g_value_unset (&src2);
1017 /* completely overlapping ranges */
1018 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1019 gst_value_set_double_range (&src1, 10.0, 20.0);
1020 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1021 gst_value_set_double_range (&src2, 10.0, 30.0);
1022 ret = gst_value_subtract (&dest, &src1, &src2);
1023 fail_unless (ret == FALSE);
1025 ret = gst_value_subtract (&dest, &src2, &src1);
1026 fail_unless (ret == TRUE);
1027 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1028 fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
1029 fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
1030 g_value_unset (&dest);
1031 g_value_unset (&src1);
1032 g_value_unset (&src2);
1034 /* partially overlapping ranges */
1035 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1036 gst_value_set_double_range (&src1, 10.0, 20.0);
1037 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1038 gst_value_set_double_range (&src2, 15.0, 30.0);
1039 ret = gst_value_subtract (&dest, &src1, &src2);
1040 fail_unless (ret == TRUE);
1041 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1042 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
1043 fail_unless (gst_value_get_double_range_max (&dest) == 15.0);
1044 g_value_unset (&dest);
1046 ret = gst_value_subtract (&dest, &src2, &src1);
1047 fail_unless (ret == TRUE);
1048 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
1049 fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
1050 fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
1051 g_value_unset (&dest);
1052 g_value_unset (&src1);
1053 g_value_unset (&src2);
1055 /* create a hole { double_range, double_range } */
1056 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
1057 gst_value_set_double_range (&src1, 10.0, 30.0);
1058 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
1059 gst_value_set_double_range (&src2, 15.0, 20.0);
1060 ret = gst_value_subtract (&dest, &src1, &src2);
1061 fail_unless (ret == TRUE);
1062 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1063 tmp = gst_value_list_get_value (&dest, 0);
1064 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
1065 fail_unless (gst_value_get_double_range_min (tmp) == 10.0);
1066 fail_unless (gst_value_get_double_range_max (tmp) == 15.0);
1067 tmp = gst_value_list_get_value (&dest, 1);
1068 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
1069 fail_unless (gst_value_get_double_range_min (tmp) == 20.0);
1070 fail_unless (gst_value_get_double_range_max (tmp) == 30.0);
1071 g_value_unset (&dest);
1073 ret = gst_value_subtract (&dest, &src2, &src1);
1074 fail_unless (ret == FALSE);
1075 g_value_unset (&src1);
1076 g_value_unset (&src2);
1081 /* Test arithmetic subtraction of fractions */
1082 GST_START_TEST (test_value_subtract_fraction)
1084 GValue result = { 0 };
1085 GValue src1 = { 0 };
1086 GValue src2 = { 0 };
1088 /* Subtract 1/4 from 1/2 */
1089 g_value_init (&src1, GST_TYPE_FRACTION);
1090 g_value_init (&src2, GST_TYPE_FRACTION);
1091 g_value_init (&result, GST_TYPE_FRACTION);
1092 gst_value_set_fraction (&src1, 1, 2);
1093 gst_value_set_fraction (&src2, 1, 4);
1094 fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1095 fail_unless (gst_value_get_fraction_numerator (&result) == 1);
1096 fail_unless (gst_value_get_fraction_denominator (&result) == 4);
1098 g_value_unset (&src1);
1099 g_value_unset (&src2);
1100 g_value_unset (&result);
1102 /* Subtract 1/12 from 7/8 */
1103 g_value_init (&src1, GST_TYPE_FRACTION);
1104 g_value_init (&src2, GST_TYPE_FRACTION);
1105 g_value_init (&result, GST_TYPE_FRACTION);
1106 gst_value_set_fraction (&src1, 7, 8);
1107 gst_value_set_fraction (&src2, 1, 12);
1108 fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1109 fail_unless (gst_value_get_fraction_numerator (&result) == 19);
1110 fail_unless (gst_value_get_fraction_denominator (&result) == 24);
1112 g_value_unset (&src1);
1113 g_value_unset (&src2);
1114 g_value_unset (&result);
1116 /* Subtract 12/13 from 4/3 */
1117 g_value_init (&src1, GST_TYPE_FRACTION);
1118 g_value_init (&src2, GST_TYPE_FRACTION);
1119 g_value_init (&result, GST_TYPE_FRACTION);
1120 gst_value_set_fraction (&src1, 4, 3);
1121 gst_value_set_fraction (&src2, 12, 13);
1122 fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
1123 fail_unless (gst_value_get_fraction_numerator (&result) == 16);
1124 fail_unless (gst_value_get_fraction_denominator (&result) == 39);
1126 g_value_unset (&src1);
1127 g_value_unset (&src2);
1128 g_value_unset (&result);
1130 /* Subtract 1/12 from 7/8 */
1135 /* Test set subtraction operations on fraction ranges */
1136 GST_START_TEST (test_value_subtract_fraction_range)
1138 GValue dest = { 0 };
1139 GValue src1 = { 0 };
1140 GValue src2 = { 0 };
1145 /* Value for tests */
1146 g_value_init (&cmp, GST_TYPE_FRACTION);
1148 /* fraction <-> fraction
1150 g_value_init (&src1, GST_TYPE_FRACTION);
1151 gst_value_set_fraction (&src1, 10, 1);
1152 g_value_init (&src2, GST_TYPE_FRACTION);
1153 gst_value_set_fraction (&src2, 20, 1);
1154 gst_value_set_fraction (&src1, 10, 1);
1156 /* subtract as in sets, result is 10 */
1157 ret = gst_value_subtract (&dest, &src1, &src2);
1158 fail_unless (ret == TRUE);
1159 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1160 g_value_unset (&dest);
1162 /* same values, yields empty set */
1163 ret = gst_value_subtract (&dest, &src1, &src1);
1164 fail_unless (ret == FALSE);
1165 g_value_unset (&src1);
1166 g_value_unset (&src2);
1168 /* fraction <-> fraction_range
1171 /* would yield an empty set */
1172 g_value_init (&src1, GST_TYPE_FRACTION);
1173 gst_value_set_fraction (&src1, 10, 1);
1174 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1175 gst_value_set_fraction_range_full (&src2, 0, 1, 20, 1);
1176 ret = gst_value_subtract (&dest, &src1, &src2);
1177 fail_unless (ret == FALSE);
1179 /* and the other way around, we cannot create open ranges
1180 * so the result is the range again */
1181 ret = gst_value_subtract (&dest, &src2, &src1);
1182 fail_unless (ret == TRUE);
1183 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1184 gst_value_set_fraction (&cmp, 0, 1);
1185 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1186 &cmp) == GST_VALUE_EQUAL);
1187 gst_value_set_fraction (&cmp, 20, 1);
1188 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1189 &cmp) == GST_VALUE_EQUAL);
1190 g_value_unset (&dest);
1191 g_value_unset (&src1);
1192 g_value_unset (&src2);
1194 /* border case 1, empty set */
1195 g_value_init (&src1, GST_TYPE_FRACTION);
1196 gst_value_set_fraction (&src1, 10, 1);
1197 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1198 gst_value_set_fraction_range_full (&src2, 10, 1, 20, 1);
1199 ret = gst_value_subtract (&dest, &src1, &src2);
1200 fail_unless (ret == FALSE);
1202 /* and the other way around, should keep same range as
1203 * we don't have open ranges. */
1204 ret = gst_value_subtract (&dest, &src2, &src1);
1205 fail_unless (ret == TRUE);
1206 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1207 gst_value_set_fraction (&cmp, 10, 1);
1208 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1209 &cmp) == GST_VALUE_EQUAL);
1210 gst_value_set_fraction (&cmp, 20, 1);
1211 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1212 &cmp) == GST_VALUE_EQUAL);
1213 g_value_unset (&dest);
1214 g_value_unset (&src1);
1215 g_value_unset (&src2);
1217 /* case 2, valid set */
1218 g_value_init (&src1, GST_TYPE_FRACTION);
1219 gst_value_set_fraction (&src1, 0, 1);
1220 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1221 gst_value_set_fraction_range_full (&src2, 10, 1, 20, 1);
1222 ret = gst_value_subtract (&dest, &src1, &src2);
1223 fail_unless (ret == TRUE);
1224 fail_unless (GST_VALUE_HOLDS_FRACTION (&dest) == TRUE);
1225 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
1226 g_value_unset (&dest);
1228 /* and the other way around, should keep the range. */
1229 ret = gst_value_subtract (&dest, &src2, &src1);
1230 fail_unless (ret == TRUE);
1231 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1232 fail_unless (gst_value_compare (&dest, &src2) == GST_VALUE_EQUAL);
1233 g_value_unset (&dest);
1234 g_value_unset (&src1);
1235 g_value_unset (&src2);
1237 /* fraction_range <-> fraction_range
1240 /* same range, empty set */
1241 g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1242 gst_value_set_fraction_range_full (&src1, 10, 2, 20, 2);
1243 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1244 gst_value_set_fraction_range_full (&src2, 10, 2, 20, 2);
1245 ret = gst_value_subtract (&dest, &src1, &src2);
1246 fail_unless (ret == FALSE);
1247 ret = gst_value_subtract (&dest, &src2, &src1);
1248 fail_unless (ret == FALSE);
1249 g_value_unset (&src1);
1250 g_value_unset (&src2);
1252 /* non overlapping ranges */
1253 g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1254 gst_value_set_fraction_range_full (&src1, 10, 2, 10, 1);
1255 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1256 gst_value_set_fraction_range_full (&src2, 30, 2, 40, 2);
1257 ret = gst_value_subtract (&dest, &src1, &src2);
1258 fail_unless (ret == TRUE);
1259 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1260 gst_value_set_fraction (&cmp, 5, 1);
1261 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1262 &cmp) == GST_VALUE_EQUAL);
1263 gst_value_set_fraction (&cmp, 10, 1);
1264 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1265 &cmp) == GST_VALUE_EQUAL);
1267 g_value_unset (&dest);
1269 ret = gst_value_subtract (&dest, &src2, &src1);
1270 fail_unless (ret == TRUE);
1271 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1272 gst_value_set_fraction (&cmp, 15, 1);
1273 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1274 &cmp) == GST_VALUE_EQUAL);
1275 gst_value_set_fraction (&cmp, 20, 1);
1276 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1277 &cmp) == GST_VALUE_EQUAL);
1278 g_value_unset (&dest);
1279 g_value_unset (&src1);
1280 g_value_unset (&src2);
1282 /* completely overlapping ranges */
1283 g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1284 gst_value_set_fraction_range_full (&src1, 10, 1, 20, 1);
1285 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1286 gst_value_set_fraction_range_full (&src2, 10, 1, 30, 1);
1287 ret = gst_value_subtract (&dest, &src1, &src2);
1288 fail_unless (ret == FALSE);
1290 ret = gst_value_subtract (&dest, &src2, &src1);
1291 fail_unless (ret == TRUE);
1292 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1293 gst_value_set_fraction (&cmp, 20, 1);
1294 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1295 &cmp) == GST_VALUE_EQUAL);
1296 gst_value_set_fraction (&cmp, 30, 1);
1297 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1298 &cmp) == GST_VALUE_EQUAL);
1299 g_value_unset (&dest);
1300 g_value_unset (&src1);
1301 g_value_unset (&src2);
1303 /* partially overlapping ranges */
1304 g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1305 gst_value_set_fraction_range_full (&src1, 10, 1, 20, 1);
1306 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1307 gst_value_set_fraction_range_full (&src2, 15, 1, 30, 1);
1308 ret = gst_value_subtract (&dest, &src1, &src2);
1309 fail_unless (ret == TRUE);
1310 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1311 gst_value_set_fraction (&cmp, 10, 1);
1312 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1313 &cmp) == GST_VALUE_EQUAL);
1314 gst_value_set_fraction (&cmp, 15, 1);
1315 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1316 &cmp) == GST_VALUE_EQUAL);
1317 g_value_unset (&dest);
1320 ret = gst_value_subtract (&dest, &src2, &src1);
1321 fail_unless (ret == TRUE);
1322 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (&dest) == TRUE);
1323 gst_value_set_fraction (&cmp, 20, 1);
1324 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
1325 &cmp) == GST_VALUE_EQUAL);
1326 gst_value_set_fraction (&cmp, 30, 1);
1327 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
1328 &cmp) == GST_VALUE_EQUAL);
1329 g_value_unset (&dest);
1330 g_value_unset (&src1);
1331 g_value_unset (&src2);
1333 /* create a hole { double_range, double_range } */
1334 g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
1335 gst_value_set_fraction_range_full (&src1, 10, 1, 30, 1);
1336 g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
1337 gst_value_set_fraction_range_full (&src2, 15, 1, 20, 1);
1338 ret = gst_value_subtract (&dest, &src1, &src2);
1339 fail_unless (ret == TRUE);
1340 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
1341 /* 1st list entry */
1342 tmp = gst_value_list_get_value (&dest, 0);
1343 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (tmp) == TRUE);
1344 gst_value_set_fraction (&cmp, 10, 1);
1345 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (tmp),
1346 &cmp) == GST_VALUE_EQUAL);
1347 gst_value_set_fraction (&cmp, 15, 1);
1348 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (tmp),
1349 &cmp) == GST_VALUE_EQUAL);
1350 /* 2nd list entry */
1351 tmp = gst_value_list_get_value (&dest, 1);
1352 fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (tmp) == TRUE);
1353 gst_value_set_fraction (&cmp, 20, 1);
1354 fail_unless (gst_value_compare (gst_value_get_fraction_range_min (tmp),
1355 &cmp) == GST_VALUE_EQUAL);
1356 gst_value_set_fraction (&cmp, 30, 1);
1357 fail_unless (gst_value_compare (gst_value_get_fraction_range_max (tmp),
1358 &cmp) == GST_VALUE_EQUAL);
1359 g_value_unset (&dest);
1361 ret = gst_value_subtract (&dest, &src2, &src1);
1362 fail_unless (ret == FALSE);
1363 g_value_unset (&src1);
1364 g_value_unset (&src2);
1366 g_value_unset (&cmp);
1371 GST_START_TEST (test_date)
1374 GDate *date, *date2;
1377 date = g_date_new_dmy (22, 9, 2005);
1379 s = gst_structure_new ("media/x-type", "SOME_DATE_TAG", GST_TYPE_DATE,
1382 fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
1384 fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date2));
1385 fail_unless (date2 != NULL);
1386 fail_unless (g_date_valid (date2));
1387 fail_unless (g_date_compare (date, date2) == 0);
1390 g_date_free (date2);
1394 str = gst_structure_to_string (s);
1395 gst_structure_free (s);
1398 fail_unless (g_str_equal (str,
1399 "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22"));
1401 s = gst_structure_from_string (str, NULL);
1405 fail_unless (s != NULL);
1406 fail_unless (gst_structure_has_name (s, "media/x-type"));
1407 fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
1409 fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date));
1410 fail_unless (date != NULL);
1411 fail_unless (g_date_valid (date));
1412 fail_unless (g_date_get_day (date) == 22);
1413 fail_unless (g_date_get_month (date) == 9);
1414 fail_unless (g_date_get_year (date) == 2005);
1418 str = gst_structure_to_string (s);
1419 gst_structure_free (s);
1422 fail_unless (g_str_equal (str,
1423 "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22"));
1430 GST_START_TEST (test_fraction_range)
1432 GValue range = { 0, };
1433 GValue start = { 0, }, end = {
1435 GValue src = { 0, }, dest = {
1437 GValue range2 = { 0, };
1439 g_value_init (&range, GST_TYPE_FRACTION_RANGE);
1440 g_value_init (&range2, GST_TYPE_FRACTION_RANGE);
1441 g_value_init (&start, GST_TYPE_FRACTION);
1442 g_value_init (&end, GST_TYPE_FRACTION);
1443 g_value_init (&src, GST_TYPE_FRACTION);
1445 gst_value_set_fraction (&src, 1, 2);
1447 /* Check that a intersection of fraction & range = fraction */
1448 gst_value_set_fraction (&start, 1, 4);
1449 gst_value_set_fraction (&end, 2, 3);
1450 gst_value_set_fraction_range (&range, &start, &end);
1452 fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
1453 fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION);
1454 fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
1456 /* Check that a intersection selects the overlapping range */
1457 gst_value_set_fraction (&start, 1, 3);
1458 gst_value_set_fraction (&end, 2, 3);
1459 gst_value_set_fraction_range (&range2, &start, &end);
1460 g_value_unset (&dest);
1461 fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
1462 fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
1464 gst_value_set_fraction_range (&range2, &start, &end);
1465 fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
1467 /* Check that non intersection ranges don't intersect */
1468 gst_value_set_fraction (&start, 4, 2);
1469 gst_value_set_fraction (&end, 5, 2);
1470 gst_value_set_fraction_range (&range2, &start, &end);
1471 g_value_unset (&dest);
1472 fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
1474 g_value_unset (&start);
1475 g_value_unset (&end);
1476 g_value_unset (&range);
1477 g_value_unset (&range2);
1478 g_value_unset (&src);
1484 gst_value_suite (void)
1486 Suite *s = suite_create ("GstValue");
1487 TCase *tc_chain = tcase_create ("general");
1489 suite_add_tcase (s, tc_chain);
1490 tcase_add_test (tc_chain, test_deserialize_buffer);
1491 tcase_add_test (tc_chain, test_serialize_buffer);
1492 tcase_add_test (tc_chain, test_deserialize_gint);
1493 tcase_add_test (tc_chain, test_deserialize_gint_failures);
1494 tcase_add_test (tc_chain, test_deserialize_guint);
1495 tcase_add_test (tc_chain, test_deserialize_guint_failures);
1496 tcase_add_test (tc_chain, test_deserialize_gint64);
1497 tcase_add_test (tc_chain, test_deserialize_gstfraction);
1498 tcase_add_test (tc_chain, test_serialize_flags);
1499 tcase_add_test (tc_chain, test_deserialize_flags);
1500 tcase_add_test (tc_chain, test_string);
1501 tcase_add_test (tc_chain, test_deserialize_string);
1502 tcase_add_test (tc_chain, test_value_compare);
1503 tcase_add_test (tc_chain, test_value_intersect);
1504 tcase_add_test (tc_chain, test_value_subtract_int);
1505 tcase_add_test (tc_chain, test_value_subtract_double);
1506 tcase_add_test (tc_chain, test_value_subtract_fraction);
1507 tcase_add_test (tc_chain, test_value_subtract_fraction_range);
1508 tcase_add_test (tc_chain, test_date);
1509 tcase_add_test (tc_chain, test_fraction_range);
1514 GST_CHECK_MAIN (gst_value);