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 buf = GST_BUFFER (gst_value_get_mini_object (&value));
36 ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
39 gst_buffer_unref (buf);
44 GST_START_TEST (test_deserialize_gint64)
47 const char *strings[] = {
57 g_value_init (&value, G_TYPE_INT64);
59 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
60 fail_unless (gst_value_deserialize (&value, strings[i]),
61 "could not deserialize %s (%d)", strings[i], i);
62 fail_unless (g_value_get_int64 (&value) == results[i],
63 "resulting value is %" G_GINT64_FORMAT ", not %" G_GINT64_FORMAT
64 ", for string %s (%d)", value, results[i], strings[i], i);
70 GST_START_TEST (test_deserialize_gint)
73 const char *strings[] = {
78 /* a positive long long, serializing to highest possible positive sint */
80 /* a positive long long, serializing to lowest possible negative sint */
82 /* a negative long long, serializing to lowest possible negative sint */
85 /* a positive long long serializing to -1 */
88 /* a negative long long serializing to -1 */
105 /* cast needs to be explicit because of unsigned -> signed */
106 (gint) 0xFFFFFFFFFFFFFFFFLL,
111 g_value_init (&value, G_TYPE_INT);
113 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
114 fail_unless (gst_value_deserialize (&value, strings[i]),
115 "could not deserialize %s (%d)", strings[i], i);
116 fail_unless (g_value_get_int (&value) == results[i],
117 "resulting value is %d, not %d, for string %s (%d)",
118 g_value_get_int (&value), results[i], strings[i], i);
124 GST_START_TEST (test_deserialize_gint_failures)
126 GValue value = { 0 };
127 const char *strings[] = {
128 "-", /* not a complete number */
129 "- TEST", /* not a complete number */
130 "0x0000000100000000", /* lowest long long that cannot fit in 32 bits */
131 "0xF000000000000000",
132 "0xFFFFFFF000000000",
133 "0xFFFFFFFF00000000",
134 "0x10000000000000000", /* first number too long to fit into a long long */
135 /* invent a new processor first before trying to make this one pass */
136 "0x10000000000000000000000000000000000000000000",
140 g_value_init (&value, G_TYPE_INT);
142 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
143 fail_if (gst_value_deserialize (&value, strings[i]),
144 "deserialized %s (%d), while it should have failed", strings[i], i);
150 GST_START_TEST (test_deserialize_guint)
152 GValue value = { 0 };
153 const char *strings[] = {
158 /* a positive long long, serializing to highest possible positive sint */
160 /* a positive long long, serializing to lowest possible negative sint */
163 /* a negative long long, serializing to lowest possible negative sint */
164 "0xFFFFFFFF80000000",
165 /* a value typically used for rgb masks */
167 /* a positive long long serializing to highest possible positive uint */
170 /* a negative long long serializing to highest possible positive uint */
171 "0xFFFFFFFFFFFFFFFF",
181 (guint) 2147483648LL,
186 (guint) 0xFFFFFFFFFFFFFFFFLL,
191 g_value_init (&value, G_TYPE_UINT);
193 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
194 fail_unless (gst_value_deserialize (&value, strings[i]),
195 "could not deserialize %s (%d)", strings[i], i);
196 fail_unless (g_value_get_uint (&value) == results[i],
197 "resulting value is %d, not %d, for string %s (%d)",
198 g_value_get_uint (&value), results[i], strings[i], i);
204 GST_START_TEST (test_deserialize_guint_failures)
206 GValue value = { 0 };
207 const char *strings[] = {
208 "-", /* not a complete number */
209 "- TEST", /* not a complete number */
211 /* FIXME: these values should not be deserializable, since they overflow
212 * the target format */
213 "0x0000000100000000", /* lowest long long that cannot fit in 32 bits */
214 "0xF000000000000000",
215 "0xFFFFFFF000000000",
216 "0xFFFFFFFF00000000",
217 "0x10000000000000000", /* first number too long to fit into a long long */
218 /* invent a new processor first before trying to make this one pass */
219 "0x10000000000000000000000000000000000000000000",
224 g_value_init (&value, G_TYPE_UINT);
226 for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
227 fail_if (gst_value_deserialize (&value, strings[i]),
228 "deserialized %s (%d), while it should have failed", strings[i], i);
235 GST_START_TEST (test_string)
246 g_value_init (&v, G_TYPE_STRING);
247 for (i = 0; i < G_N_ELEMENTS (try); i++) {
248 g_value_set_string (&v, try[i]);
249 tmp = gst_value_serialize (&v);
250 fail_if (tmp == NULL, "couldn't serialize: %s\n", try[i]);
251 fail_unless (gst_value_deserialize (&v, tmp),
252 "couldn't deserialize: %s\n", tmp);
255 fail_unless (g_str_equal (g_value_get_string (&v), try[i]),
256 "\nserialized : %s\ndeserialized: %s", try[i],
257 g_value_get_string (&v));
264 GST_START_TEST (test_deserialize_string)
272 "", ""}, /* empty strings */
274 "\"\"", ""}, /* FAILURES */
276 "\"", NULL}, /* missing second quote */
278 "\"Hello\\ World", NULL}, /* missing second quote */
280 "\"\\", NULL}, /* quote at end, missing second quote */
282 "\"\\0", NULL}, /* missing second quote */
284 "\"\\0\"", NULL}, /* unfinished escaped character */
286 "\" \"", NULL}, /* spaces must be escaped */
288 /* FIXME 0.9: this test should fail, but it doesn't */
290 "tüüt", NULL} /* string with special chars must be escaped */
297 g_value_init (&v, G_TYPE_STRING);
298 for (i = 0; i < G_N_ELEMENTS (tests); i++) {
299 if (gst_value_deserialize (&v, tests[i].from)) {
300 fail_if (tests[i].to == NULL,
301 "I got %s instead of a failure", g_value_get_string (&v));
302 fail_unless (g_str_equal (g_value_get_string (&v), tests[i].to),
303 "\nwanted: %s\ngot : %s", tests[i].to, g_value_get_string (&v));
305 fail_if (tests[i].to != NULL, "failed, but wanted: %s", tests[i].to);
314 GST_START_TEST (test_value_compare)
316 GValue value1 = { 0 };
317 GValue value2 = { 0 };
319 g_value_init (&value1, G_TYPE_INT);
320 g_value_set_int (&value1, 10);
321 g_value_init (&value2, G_TYPE_INT);
322 g_value_set_int (&value2, 20);
323 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
324 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
325 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
326 g_value_unset (&value1);
327 g_value_unset (&value2);
329 g_value_init (&value1, G_TYPE_DOUBLE);
330 g_value_set_double (&value1, 10);
331 g_value_init (&value2, G_TYPE_DOUBLE);
332 g_value_set_double (&value2, 20);
333 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
334 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
335 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
336 g_value_unset (&value1);
337 g_value_unset (&value2);
339 g_value_init (&value1, G_TYPE_STRING);
340 g_value_set_string (&value1, "a");
341 g_value_init (&value2, G_TYPE_STRING);
342 g_value_set_string (&value2, "b");
343 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
344 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
345 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
346 g_value_unset (&value1);
347 g_value_unset (&value2);
349 g_value_init (&value1, GST_TYPE_FOURCC);
350 gst_value_set_fourcc (&value1, GST_MAKE_FOURCC ('a', 'b', 'c', 'd'));
351 g_value_init (&value2, GST_TYPE_FOURCC);
352 gst_value_set_fourcc (&value2, GST_MAKE_FOURCC ('1', '2', '3', '4'));
353 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
354 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
355 g_value_unset (&value1);
356 g_value_unset (&value2);
358 /* comparing 2/3 with 3/4 */
359 g_value_init (&value1, GST_TYPE_FRACTION);
360 gst_value_set_fraction (&value1, 2, 3);
361 g_value_init (&value2, GST_TYPE_FRACTION);
362 gst_value_set_fraction (&value2, 3, 4);
363 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
364 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
365 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
366 g_value_unset (&value1);
367 g_value_unset (&value2);
369 /* comparing -4/5 with 2/-3 */
370 g_value_init (&value1, GST_TYPE_FRACTION);
371 gst_value_set_fraction (&value1, -4, 5);
372 g_value_init (&value2, GST_TYPE_FRACTION);
373 gst_value_set_fraction (&value2, 2, -3);
374 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
375 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
376 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
377 g_value_unset (&value1);
378 g_value_unset (&value2);
380 /* comparing 10/100 with 200/2000 */
381 g_value_init (&value1, GST_TYPE_FRACTION);
382 gst_value_set_fraction (&value1, 10, 100);
383 g_value_init (&value2, GST_TYPE_FRACTION);
384 gst_value_set_fraction (&value2, 200, 2000);
385 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL);
386 g_value_unset (&value1);
387 g_value_unset (&value2);
389 /* comparing -4/5 with 2/-3 */
390 g_value_init (&value1, GST_TYPE_FRACTION);
391 gst_value_set_fraction (&value1, -4, 5);
392 g_value_init (&value2, GST_TYPE_FRACTION);
393 gst_value_set_fraction (&value2, 2, -3);
394 fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
395 fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
396 fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
397 g_value_unset (&value1);
398 g_value_unset (&value2);
403 GST_START_TEST (test_value_intersect)
411 g_value_init (&src1, G_TYPE_INT);
412 g_value_set_int (&src1, 10);
413 g_value_init (&src2, G_TYPE_INT);
414 g_value_set_int (&src2, 20);
415 ret = gst_value_intersect (&dest, &src1, &src2);
416 fail_unless (ret == FALSE);
417 g_value_unset (&src1);
418 g_value_unset (&src2);
420 g_value_init (&src1, GST_TYPE_FOURCC);
421 gst_value_set_fourcc (&src1, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
422 g_value_init (&src2, GST_TYPE_LIST);
423 g_value_init (&item, GST_TYPE_FOURCC);
424 gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
425 gst_value_list_append_value (&src2, &item);
426 gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('I', '4', '2', '0'));
427 gst_value_list_append_value (&src2, &item);
428 gst_value_set_fourcc (&item, GST_MAKE_FOURCC ('A', 'B', 'C', 'D'));
429 gst_value_list_append_value (&src2, &item);
431 fail_unless (gst_value_intersect (&dest, &src1, &src2));
432 fail_unless (GST_VALUE_HOLDS_FOURCC (&dest));
433 fail_unless (gst_value_get_fourcc (&dest) ==
434 GST_MAKE_FOURCC ('Y', 'U', 'Y', '2'));
440 GST_START_TEST (test_value_subtract_int)
450 g_value_init (&src1, G_TYPE_INT);
451 g_value_set_int (&src1, 10);
452 g_value_init (&src2, G_TYPE_INT);
453 g_value_set_int (&src2, 20);
454 /* subtract as in sets, result is 10 */
455 ret = gst_value_subtract (&dest, &src1, &src2);
456 fail_unless (ret == TRUE);
457 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
458 g_value_unset (&dest);
460 /* same values, yields empty set */
461 ret = gst_value_subtract (&dest, &src1, &src1);
462 fail_unless (ret == FALSE);
463 g_value_unset (&src1);
464 g_value_unset (&src2);
469 /* would yield an empty set */
470 g_value_init (&src1, G_TYPE_INT);
471 g_value_set_int (&src1, 10);
472 g_value_init (&src2, GST_TYPE_INT_RANGE);
473 gst_value_set_int_range (&src2, 0, 20);
474 ret = gst_value_subtract (&dest, &src1, &src2);
475 fail_unless (ret == FALSE);
477 /* and the other way around, should create a list of two ranges. */
478 ret = gst_value_subtract (&dest, &src2, &src1);
479 fail_unless (ret == TRUE);
480 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
481 tmp = gst_value_list_get_value (&dest, 0);
482 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
483 fail_unless (gst_value_get_int_range_min (tmp) == 0);
484 fail_unless (gst_value_get_int_range_max (tmp) == 9);
485 tmp = gst_value_list_get_value (&dest, 1);
486 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
487 fail_unless (gst_value_get_int_range_min (tmp) == 11);
488 fail_unless (gst_value_get_int_range_max (tmp) == 20);
489 g_value_unset (&dest);
490 g_value_unset (&src1);
491 g_value_unset (&src2);
493 /* border case 1, empty set */
494 g_value_init (&src1, G_TYPE_INT);
495 g_value_set_int (&src1, 10);
496 g_value_init (&src2, GST_TYPE_INT_RANGE);
497 gst_value_set_int_range (&src2, 10, 20);
498 ret = gst_value_subtract (&dest, &src1, &src2);
499 fail_unless (ret == FALSE);
501 /* and the other way around, should create a new range. */
502 ret = gst_value_subtract (&dest, &src2, &src1);
503 fail_unless (ret == TRUE);
504 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
505 fail_unless (gst_value_get_int_range_min (&dest) == 11);
506 fail_unless (gst_value_get_int_range_max (&dest) == 20);
507 g_value_unset (&dest);
508 g_value_unset (&src1);
509 g_value_unset (&src2);
511 /* border case 2, empty set */
512 g_value_init (&src1, G_TYPE_INT);
513 g_value_set_int (&src1, 20);
514 g_value_init (&src2, GST_TYPE_INT_RANGE);
515 gst_value_set_int_range (&src2, 10, 20);
516 ret = gst_value_subtract (&dest, &src1, &src2);
517 fail_unless (ret == FALSE);
519 /* and the other way around, should create a new range. */
520 ret = gst_value_subtract (&dest, &src2, &src1);
521 fail_unless (ret == TRUE);
522 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
523 fail_unless (gst_value_get_int_range_min (&dest) == 10);
524 fail_unless (gst_value_get_int_range_max (&dest) == 19);
525 g_value_unset (&dest);
526 g_value_unset (&src1);
527 g_value_unset (&src2);
529 /* case 3, valid set */
530 g_value_init (&src1, G_TYPE_INT);
531 g_value_set_int (&src1, 0);
532 g_value_init (&src2, GST_TYPE_INT_RANGE);
533 gst_value_set_int_range (&src2, 10, 20);
534 ret = gst_value_subtract (&dest, &src1, &src2);
535 fail_unless (ret == TRUE);
536 fail_unless (G_VALUE_HOLDS_INT (&dest) == TRUE);
537 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
538 g_value_unset (&dest);
540 /* and the other way around, should keep the range. */
541 ret = gst_value_subtract (&dest, &src2, &src1);
542 fail_unless (ret == TRUE);
543 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
544 fail_unless (gst_value_get_int_range_min (&dest) == 10);
545 fail_unless (gst_value_get_int_range_max (&dest) == 20);
546 g_value_unset (&dest);
547 g_value_unset (&src1);
548 g_value_unset (&src2);
550 /* int_range <-> int_range
553 /* same range, empty set */
554 g_value_init (&src1, GST_TYPE_INT_RANGE);
555 gst_value_set_int_range (&src1, 10, 20);
556 g_value_init (&src2, GST_TYPE_INT_RANGE);
557 gst_value_set_int_range (&src2, 10, 20);
558 ret = gst_value_subtract (&dest, &src1, &src2);
559 fail_unless (ret == FALSE);
560 ret = gst_value_subtract (&dest, &src2, &src1);
561 fail_unless (ret == FALSE);
562 g_value_unset (&src1);
563 g_value_unset (&src2);
565 /* non overlapping ranges */
566 g_value_init (&src1, GST_TYPE_INT_RANGE);
567 gst_value_set_int_range (&src1, 10, 20);
568 g_value_init (&src2, GST_TYPE_INT_RANGE);
569 gst_value_set_int_range (&src2, 30, 40);
570 ret = gst_value_subtract (&dest, &src1, &src2);
571 fail_unless (ret == TRUE);
572 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
573 fail_unless (gst_value_get_int_range_min (&dest) == 10);
574 fail_unless (gst_value_get_int_range_max (&dest) == 20);
575 g_value_unset (&dest);
577 ret = gst_value_subtract (&dest, &src2, &src1);
578 fail_unless (ret == TRUE);
579 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
580 fail_unless (gst_value_get_int_range_min (&dest) == 30);
581 fail_unless (gst_value_get_int_range_max (&dest) == 40);
582 g_value_unset (&dest);
583 g_value_unset (&src1);
584 g_value_unset (&src2);
586 /* completely overlapping ranges */
587 g_value_init (&src1, GST_TYPE_INT_RANGE);
588 gst_value_set_int_range (&src1, 10, 20);
589 g_value_init (&src2, GST_TYPE_INT_RANGE);
590 gst_value_set_int_range (&src2, 10, 30);
591 ret = gst_value_subtract (&dest, &src1, &src2);
592 fail_unless (ret == FALSE);
594 ret = gst_value_subtract (&dest, &src2, &src1);
595 fail_unless (ret == TRUE);
596 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
597 fail_unless (gst_value_get_int_range_min (&dest) == 21);
598 fail_unless (gst_value_get_int_range_max (&dest) == 30);
599 g_value_unset (&dest);
600 g_value_unset (&src1);
601 g_value_unset (&src2);
603 /* partially overlapping ranges */
604 g_value_init (&src1, GST_TYPE_INT_RANGE);
605 gst_value_set_int_range (&src1, 10, 20);
606 g_value_init (&src2, GST_TYPE_INT_RANGE);
607 gst_value_set_int_range (&src2, 15, 30);
608 ret = gst_value_subtract (&dest, &src1, &src2);
609 fail_unless (ret == TRUE);
610 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
611 fail_unless (gst_value_get_int_range_min (&dest) == 10);
612 fail_unless (gst_value_get_int_range_max (&dest) == 14);
613 g_value_unset (&dest);
615 ret = gst_value_subtract (&dest, &src2, &src1);
616 fail_unless (ret == TRUE);
617 fail_unless (GST_VALUE_HOLDS_INT_RANGE (&dest) == TRUE);
618 fail_unless (gst_value_get_int_range_min (&dest) == 21);
619 fail_unless (gst_value_get_int_range_max (&dest) == 30);
620 g_value_unset (&dest);
621 g_value_unset (&src1);
622 g_value_unset (&src2);
624 /* create a hole { int_range, int_range } */
625 g_value_init (&src1, GST_TYPE_INT_RANGE);
626 gst_value_set_int_range (&src1, 10, 30);
627 g_value_init (&src2, GST_TYPE_INT_RANGE);
628 gst_value_set_int_range (&src2, 15, 20);
629 ret = gst_value_subtract (&dest, &src1, &src2);
630 fail_unless (ret == TRUE);
631 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
632 tmp = gst_value_list_get_value (&dest, 0);
633 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
634 fail_unless (gst_value_get_int_range_min (tmp) == 10);
635 fail_unless (gst_value_get_int_range_max (tmp) == 14);
636 tmp = gst_value_list_get_value (&dest, 1);
637 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
638 fail_unless (gst_value_get_int_range_min (tmp) == 21);
639 fail_unless (gst_value_get_int_range_max (tmp) == 30);
640 g_value_unset (&dest);
642 ret = gst_value_subtract (&dest, &src2, &src1);
643 fail_unless (ret == FALSE);
644 g_value_unset (&src1);
645 g_value_unset (&src2);
647 /* create a hole, { int, int } */
648 g_value_init (&src1, GST_TYPE_INT_RANGE);
649 gst_value_set_int_range (&src1, 10, 30);
650 g_value_init (&src2, GST_TYPE_INT_RANGE);
651 gst_value_set_int_range (&src2, 11, 29);
652 ret = gst_value_subtract (&dest, &src1, &src2);
653 fail_unless (ret == TRUE);
654 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
655 tmp = gst_value_list_get_value (&dest, 0);
656 fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
657 fail_unless (g_value_get_int (tmp) == 10);
658 tmp = gst_value_list_get_value (&dest, 1);
659 fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
660 fail_unless (g_value_get_int (tmp) == 30);
661 g_value_unset (&dest);
663 ret = gst_value_subtract (&dest, &src2, &src1);
664 fail_unless (ret == FALSE);
665 g_value_unset (&src1);
666 g_value_unset (&src2);
668 /* create a hole, { int, int_range } */
669 g_value_init (&src1, GST_TYPE_INT_RANGE);
670 gst_value_set_int_range (&src1, 10, 30);
671 g_value_init (&src2, GST_TYPE_INT_RANGE);
672 gst_value_set_int_range (&src2, 11, 28);
673 ret = gst_value_subtract (&dest, &src1, &src2);
674 fail_unless (ret == TRUE);
675 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
676 tmp = gst_value_list_get_value (&dest, 0);
677 fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
678 fail_unless (g_value_get_int (tmp) == 10);
679 tmp = gst_value_list_get_value (&dest, 1);
680 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
681 fail_unless (gst_value_get_int_range_min (tmp) == 29);
682 fail_unless (gst_value_get_int_range_max (tmp) == 30);
683 g_value_unset (&dest);
685 ret = gst_value_subtract (&dest, &src2, &src1);
686 fail_unless (ret == FALSE);
687 g_value_unset (&src1);
688 g_value_unset (&src2);
690 /* create a hole, { int_range, int } */
691 g_value_init (&src1, GST_TYPE_INT_RANGE);
692 gst_value_set_int_range (&src1, 10, 30);
693 g_value_init (&src2, GST_TYPE_INT_RANGE);
694 gst_value_set_int_range (&src2, 12, 29);
695 ret = gst_value_subtract (&dest, &src1, &src2);
696 fail_unless (ret == TRUE);
697 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
698 tmp = gst_value_list_get_value (&dest, 0);
699 fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
700 fail_unless (gst_value_get_int_range_min (tmp) == 10);
701 fail_unless (gst_value_get_int_range_max (tmp) == 11);
702 tmp = gst_value_list_get_value (&dest, 1);
703 fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
704 fail_unless (g_value_get_int (tmp) == 30);
705 g_value_unset (&dest);
707 ret = gst_value_subtract (&dest, &src2, &src1);
708 fail_unless (ret == FALSE);
709 g_value_unset (&src1);
710 g_value_unset (&src2);
715 GST_START_TEST (test_value_subtract_double)
725 g_value_init (&src1, G_TYPE_DOUBLE);
726 g_value_set_double (&src1, 10.0);
727 g_value_init (&src2, G_TYPE_DOUBLE);
728 g_value_set_double (&src2, 20.0);
729 /* subtract as in sets, result is 10 */
730 ret = gst_value_subtract (&dest, &src1, &src2);
731 fail_unless (ret == TRUE);
732 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
733 g_value_unset (&dest);
735 /* same values, yields empty set */
736 ret = gst_value_subtract (&dest, &src1, &src1);
737 fail_unless (ret == FALSE);
738 g_value_unset (&src1);
739 g_value_unset (&src2);
741 /* double <-> double_range
744 /* would yield an empty set */
745 g_value_init (&src1, G_TYPE_DOUBLE);
746 g_value_set_double (&src1, 10.0);
747 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
748 gst_value_set_double_range (&src2, 0.0, 20.0);
749 ret = gst_value_subtract (&dest, &src1, &src2);
750 fail_unless (ret == FALSE);
752 /* and the other way around, we cannot create open ranges
753 * so the result is the range again */
754 ret = gst_value_subtract (&dest, &src2, &src1);
755 fail_unless (ret == TRUE);
756 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
757 fail_unless (gst_value_get_double_range_min (&dest) == 0.0);
758 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
759 g_value_unset (&dest);
760 g_value_unset (&src1);
761 g_value_unset (&src2);
763 /* border case 1, empty set */
764 g_value_init (&src1, G_TYPE_DOUBLE);
765 g_value_set_double (&src1, 10.0);
766 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
767 gst_value_set_double_range (&src2, 10.0, 20.0);
768 ret = gst_value_subtract (&dest, &src1, &src2);
769 fail_unless (ret == FALSE);
771 /* and the other way around, should keep same range as
772 * we don't have open ranges. */
773 ret = gst_value_subtract (&dest, &src2, &src1);
774 fail_unless (ret == TRUE);
775 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
776 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
777 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
778 g_value_unset (&dest);
779 g_value_unset (&src1);
780 g_value_unset (&src2);
782 /* border case 2, empty set */
783 g_value_init (&src1, G_TYPE_DOUBLE);
784 g_value_set_double (&src1, 20.0);
785 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
786 gst_value_set_double_range (&src2, 10.0, 20.0);
787 ret = gst_value_subtract (&dest, &src1, &src2);
788 fail_unless (ret == FALSE);
790 /* and the other way around, should keep same range as
791 * we don't have open ranges. */
792 ret = gst_value_subtract (&dest, &src2, &src1);
793 fail_unless (ret == TRUE);
794 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
795 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
796 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
797 g_value_unset (&dest);
798 g_value_unset (&src1);
799 g_value_unset (&src2);
801 /* case 3, valid set */
802 g_value_init (&src1, G_TYPE_DOUBLE);
803 g_value_set_double (&src1, 0.0);
804 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
805 gst_value_set_double_range (&src2, 10.0, 20.0);
806 ret = gst_value_subtract (&dest, &src1, &src2);
807 fail_unless (ret == TRUE);
808 fail_unless (G_VALUE_HOLDS_DOUBLE (&dest) == TRUE);
809 fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
810 g_value_unset (&dest);
812 /* and the other way around, should keep the range. */
813 ret = gst_value_subtract (&dest, &src2, &src1);
814 fail_unless (ret == TRUE);
815 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
816 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
817 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
818 g_value_unset (&dest);
819 g_value_unset (&src1);
820 g_value_unset (&src2);
822 /* double_range <-> double_range
825 /* same range, empty set */
826 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
827 gst_value_set_double_range (&src1, 10.0, 20.0);
828 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
829 gst_value_set_double_range (&src2, 10.0, 20.0);
830 ret = gst_value_subtract (&dest, &src1, &src2);
831 fail_unless (ret == FALSE);
832 ret = gst_value_subtract (&dest, &src2, &src1);
833 fail_unless (ret == FALSE);
834 g_value_unset (&src1);
835 g_value_unset (&src2);
837 /* non overlapping ranges */
838 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
839 gst_value_set_double_range (&src1, 10.0, 20.0);
840 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
841 gst_value_set_double_range (&src2, 30.0, 40.0);
842 ret = gst_value_subtract (&dest, &src1, &src2);
843 fail_unless (ret == TRUE);
844 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
845 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
846 fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
847 g_value_unset (&dest);
849 ret = gst_value_subtract (&dest, &src2, &src1);
850 fail_unless (ret == TRUE);
851 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
852 fail_unless (gst_value_get_double_range_min (&dest) == 30.0);
853 fail_unless (gst_value_get_double_range_max (&dest) == 40.0);
854 g_value_unset (&dest);
855 g_value_unset (&src1);
856 g_value_unset (&src2);
858 /* completely overlapping ranges */
859 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
860 gst_value_set_double_range (&src1, 10.0, 20.0);
861 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
862 gst_value_set_double_range (&src2, 10.0, 30.0);
863 ret = gst_value_subtract (&dest, &src1, &src2);
864 fail_unless (ret == FALSE);
866 ret = gst_value_subtract (&dest, &src2, &src1);
867 fail_unless (ret == TRUE);
868 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
869 fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
870 fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
871 g_value_unset (&dest);
872 g_value_unset (&src1);
873 g_value_unset (&src2);
875 /* partially overlapping ranges */
876 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
877 gst_value_set_double_range (&src1, 10.0, 20.0);
878 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
879 gst_value_set_double_range (&src2, 15.0, 30.0);
880 ret = gst_value_subtract (&dest, &src1, &src2);
881 fail_unless (ret == TRUE);
882 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
883 fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
884 fail_unless (gst_value_get_double_range_max (&dest) == 15.0);
885 g_value_unset (&dest);
887 ret = gst_value_subtract (&dest, &src2, &src1);
888 fail_unless (ret == TRUE);
889 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (&dest) == TRUE);
890 fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
891 fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
892 g_value_unset (&dest);
893 g_value_unset (&src1);
894 g_value_unset (&src2);
896 /* create a hole { double_range, double_range } */
897 g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
898 gst_value_set_double_range (&src1, 10.0, 30.0);
899 g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
900 gst_value_set_double_range (&src2, 15.0, 20.0);
901 ret = gst_value_subtract (&dest, &src1, &src2);
902 fail_unless (ret == TRUE);
903 fail_unless (GST_VALUE_HOLDS_LIST (&dest) == TRUE);
904 tmp = gst_value_list_get_value (&dest, 0);
905 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
906 fail_unless (gst_value_get_double_range_min (tmp) == 10.0);
907 fail_unless (gst_value_get_double_range_max (tmp) == 15.0);
908 tmp = gst_value_list_get_value (&dest, 1);
909 fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
910 fail_unless (gst_value_get_double_range_min (tmp) == 20.0);
911 fail_unless (gst_value_get_double_range_max (tmp) == 30.0);
912 g_value_unset (&dest);
914 ret = gst_value_subtract (&dest, &src2, &src1);
915 fail_unless (ret == FALSE);
916 g_value_unset (&src1);
917 g_value_unset (&src2);
922 GST_START_TEST (test_date)
928 date = g_date_new_dmy (22, 9, 2005);
930 s = gst_structure_new ("media/x-type", "SOME_DATE_TAG", GST_TYPE_DATE,
933 fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
935 fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date2));
936 fail_unless (date2 != NULL);
937 fail_unless (g_date_valid (date2));
938 fail_unless (g_date_compare (date, date2) == 0);
945 str = gst_structure_to_string (s);
946 gst_structure_free (s);
949 fail_unless (g_str_equal (str,
950 "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22"));
952 s = gst_structure_from_string (str, NULL);
956 fail_unless (s != NULL);
957 fail_unless (gst_structure_has_name (s, "media/x-type"));
958 fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG",
960 fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date));
961 fail_unless (date != NULL);
962 fail_unless (g_date_valid (date));
963 fail_unless (g_date_get_day (date) == 22);
964 fail_unless (g_date_get_month (date) == 9);
965 fail_unless (g_date_get_year (date) == 2005);
969 str = gst_structure_to_string (s);
970 gst_structure_free (s);
973 fail_unless (g_str_equal (str,
974 "media/x-type, SOME_DATE_TAG=(GstDate)2005-09-22"));
982 gst_value_suite (void)
984 Suite *s = suite_create ("GstValue");
985 TCase *tc_chain = tcase_create ("general");
987 suite_add_tcase (s, tc_chain);
988 tcase_add_test (tc_chain, test_deserialize_buffer);
989 tcase_add_test (tc_chain, test_deserialize_gint);
990 tcase_add_test (tc_chain, test_deserialize_gint_failures);
991 tcase_add_test (tc_chain, test_deserialize_guint);
992 tcase_add_test (tc_chain, test_deserialize_guint_failures);
993 tcase_add_test (tc_chain, test_deserialize_gint64);
994 tcase_add_test (tc_chain, test_string);
995 tcase_add_test (tc_chain, test_deserialize_string);
996 tcase_add_test (tc_chain, test_value_compare);
997 tcase_add_test (tc_chain, test_value_intersect);
998 tcase_add_test (tc_chain, test_value_subtract_int);
999 tcase_add_test (tc_chain, test_value_subtract_double);
1000 tcase_add_test (tc_chain, test_date);
1006 main (int argc, char **argv)
1010 Suite *s = gst_value_suite ();
1011 SRunner *sr = srunner_create (s);
1013 gst_check_init (&argc, &argv);
1015 srunner_run_all (sr, CK_NORMAL);
1016 nf = srunner_ntests_failed (sr);