mirror of
https://gitlab.freedesktop.org/gstreamer/gstreamer.git
synced 2024-12-04 23:46:43 +00:00
445df0c799
Allow a string in gst_string_unwrap to include unescaped characters that are not in GST_STRING_IS_ASCII. This extra leniency allows gst_structure_from_string to, e.g., receive name, val=(string)"string with space"; Note that many gst tests, and potentially users, exploited this behaviour by giving name, val="string with space"; i.e. without the (string) type specifier. This was allowed before because, without a type specifier, the string was passed to _priv_gst_value_parse_string with unescape set to TRUE, *rather* than being sent to gst_string_unwrap. This caused a difference in behaviour between strings that are or are not preceded by (string). E.g. name, val=(string)"string with space"; would fail, whilst name, val="string with space"; would not. And name, val=(string)"\316\261"; would produce a val="α", whereas name, val=(string)"\316\261"; would produce a val="316261" (a bug). The current behaviour is to treat both of these cases the same, which is desirable. But in order to not break potentially common usage of this discrepancy (it was in our own tests), the best option is to make string parsing less strict in general. New behaviour would be for name, val=(string)"string with space"; to pass and give val="string with space", and name, val="\316\261"; would produce a val="α". Also changed deserializing string test to expect successes where previously a failure was expected. In a similar way, this also effected the deserializing of GstStructure, GstCaps, GstTagList and GstCapsFeatures. So, now name, val=(structure)"sub-name, sub-val=(string)\"a: \\316\\261\";"; will also pass and give sub-val="a: α". Note that the quote marks and backslash still need to be escaped for the sub-structure, but other characters need not be. Part-of: <https://gitlab.freedesktop.org/gstreamer/gstreamer/-/merge_requests/303>
3983 lines
130 KiB
C
3983 lines
130 KiB
C
/* GStreamer
|
|
* Copyright (C) <2004> David Schleef <david at schleef dot org>
|
|
* Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
|
|
*
|
|
* gstvalue.c: Unit tests for GstValue
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Library General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Library General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Library General Public
|
|
* License along with this library; if not, write to the
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
* Boston, MA 02110-1301, USA.
|
|
*/
|
|
#ifdef HAVE_CONFIG_H
|
|
#include "config.h"
|
|
#endif
|
|
|
|
#define GLIB_DISABLE_DEPRECATION_WARNINGS
|
|
#include <gst/check/gstcheck.h>
|
|
|
|
|
|
GST_START_TEST (test_deserialize_buffer)
|
|
{
|
|
GValue value = { 0 };
|
|
GstBuffer *buf;
|
|
guint8 data[8];
|
|
guint64 val;
|
|
|
|
g_value_init (&value, GST_TYPE_BUFFER);
|
|
fail_unless (gst_value_deserialize (&value, "1234567890abcdef"));
|
|
/* does not increase the refcount */
|
|
buf = GST_BUFFER (g_value_get_boxed (&value));
|
|
ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
|
|
|
|
/* does not increase the refcount */
|
|
buf = gst_value_get_buffer (&value);
|
|
ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
|
|
|
|
gst_buffer_extract (buf, 0, data, 8);
|
|
val = GST_READ_UINT64_BE (data);
|
|
fail_unless_equals_uint64 (val, G_GUINT64_CONSTANT (0x1234567890abcdef));
|
|
|
|
/* cleanup */
|
|
g_value_unset (&value);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
/* create and serialize a buffer */
|
|
GST_START_TEST (test_serialize_buffer)
|
|
{
|
|
GValue value = { 0 };
|
|
GstBuffer *buf;
|
|
gchar *serialized;
|
|
const guint8 buf_data[8] = { 0x12, 0x34, 0x56, 0x78, 0x90, 0xab, 0xcd, 0xef };
|
|
gint len;
|
|
|
|
len = sizeof (buf_data);
|
|
buf = gst_buffer_new_and_alloc (len);
|
|
|
|
gst_buffer_fill (buf, 0, (gchar *) buf_data, len);
|
|
|
|
ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
|
|
|
|
/* and assign buffer to mini object */
|
|
g_value_init (&value, GST_TYPE_BUFFER);
|
|
gst_value_take_buffer (&value, buf);
|
|
ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
|
|
|
|
/* now serialize it */
|
|
serialized = gst_value_serialize (&value);
|
|
GST_DEBUG ("serialized buffer to %s", serialized);
|
|
fail_unless (serialized != NULL);
|
|
fail_unless_equals_string (serialized, "1234567890abcdef");
|
|
|
|
/* refcount should not change */
|
|
ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
|
|
|
|
/* cleanup */
|
|
g_free (serialized);
|
|
g_value_unset (&value);
|
|
|
|
/* take NULL buffer */
|
|
g_value_init (&value, GST_TYPE_BUFFER);
|
|
GST_DEBUG ("setting NULL buffer");
|
|
gst_value_take_buffer (&value, NULL);
|
|
|
|
/* now serialize it */
|
|
GST_DEBUG ("serializing NULL buffer");
|
|
serialized = gst_value_serialize (&value);
|
|
/* should return NULL */
|
|
fail_unless (serialized == NULL);
|
|
|
|
g_free (serialized);
|
|
g_value_unset (&value);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_gint64)
|
|
{
|
|
GValue value = { 0 };
|
|
const char *strings[] = {
|
|
"12345678901",
|
|
"-12345678901",
|
|
"1152921504606846976",
|
|
"-1152921504606846976",
|
|
};
|
|
gint64 results[] = {
|
|
12345678901LL,
|
|
-12345678901LL,
|
|
1152921504606846976LL,
|
|
-1152921504606846976LL,
|
|
};
|
|
int i;
|
|
|
|
g_value_init (&value, G_TYPE_INT64);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
fail_unless (gst_value_deserialize (&value, strings[i]),
|
|
"could not deserialize %s (%d)", strings[i], i);
|
|
fail_unless (g_value_get_int64 (&value) == results[i],
|
|
"resulting value is %" G_GINT64_FORMAT ", not %" G_GINT64_FORMAT
|
|
", for string %s (%d)", g_value_get_int64 (&value),
|
|
results[i], strings[i], i);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_guint64)
|
|
{
|
|
GValue value = { 0 };
|
|
const char *strings[] = {
|
|
"0xffffffffffffffff",
|
|
"9223372036854775810",
|
|
"-9223372036854775810",
|
|
"-1",
|
|
"1",
|
|
"-0",
|
|
};
|
|
guint64 results[] = {
|
|
0xffffffffffffffffULL,
|
|
9223372036854775810ULL,
|
|
9223372036854775806ULL,
|
|
(guint64) - 1,
|
|
1,
|
|
0,
|
|
};
|
|
int i;
|
|
|
|
g_value_init (&value, G_TYPE_UINT64);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
fail_unless (gst_value_deserialize (&value, strings[i]),
|
|
"could not deserialize %s (%d)", strings[i], i);
|
|
fail_unless (g_value_get_uint64 (&value) == results[i],
|
|
"resulting value is %" G_GUINT64_FORMAT ", not %" G_GUINT64_FORMAT
|
|
", for string %s (%d)", g_value_get_uint64 (&value),
|
|
results[i], strings[i], i);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_guchar)
|
|
{
|
|
GValue value = { 0 };
|
|
const char *strings[] = {
|
|
"0xff",
|
|
"255",
|
|
"-1",
|
|
"1",
|
|
"-0",
|
|
};
|
|
guchar results[] = {
|
|
0xff,
|
|
255,
|
|
(guchar) - 1,
|
|
1,
|
|
0,
|
|
};
|
|
int i;
|
|
|
|
g_value_init (&value, G_TYPE_UCHAR);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
fail_unless (gst_value_deserialize (&value, strings[i]),
|
|
"could not deserialize %s (%d)", strings[i], i);
|
|
fail_unless (g_value_get_uchar (&value) == results[i],
|
|
"resulting value is %u not %u, for string %s (%d)",
|
|
g_value_get_uchar (&value), results[i], strings[i], i);
|
|
}
|
|
|
|
/* test serialisation as well while we're at it */
|
|
{
|
|
gchar *str;
|
|
GValue value = { 0 };
|
|
g_value_init (&value, G_TYPE_UCHAR);
|
|
|
|
g_value_set_uchar (&value, 255);
|
|
str = gst_value_serialize (&value);
|
|
|
|
fail_unless_equals_string (str, "255");
|
|
g_free (str);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_gstfraction)
|
|
{
|
|
GValue value = { 0 };
|
|
const char *strings[] = {
|
|
"4/5",
|
|
"-8/9"
|
|
};
|
|
gint64 result_numers[] = {
|
|
4,
|
|
-8
|
|
};
|
|
gint64 result_denoms[] = {
|
|
5,
|
|
9
|
|
};
|
|
|
|
int i;
|
|
|
|
g_value_init (&value, GST_TYPE_FRACTION);
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
fail_unless (gst_value_deserialize (&value, strings[i]),
|
|
"could not deserialize %s (%d)", strings[i], i);
|
|
fail_unless (gst_value_get_fraction_numerator (&value) == result_numers[i],
|
|
"resulting numerator value is %d, not %d"
|
|
", for string %s (%d)", gst_value_get_fraction_numerator (&value),
|
|
result_numers[i], strings[i], i);
|
|
fail_unless (gst_value_get_fraction_denominator (&value) ==
|
|
result_denoms[i], "resulting denominator value is %d, not %d"
|
|
", for string %s (%d)", gst_value_get_fraction_denominator (&value),
|
|
result_denoms[i], strings[i], i);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_gint)
|
|
{
|
|
GValue value = { 0 };
|
|
const char *strings[] = {
|
|
"123456",
|
|
"-123456",
|
|
"0xFFFF",
|
|
"0x0000FFFF",
|
|
/* a positive long long, serializing to highest possible positive sint */
|
|
"0x7FFFFFFF",
|
|
/* a positive long long, serializing to lowest possible negative sint */
|
|
"0x80000000",
|
|
/* a negative long long, serializing to lowest possible negative sint */
|
|
"0xFFFFFFFF80000000",
|
|
"0xFF000000",
|
|
/* a positive long long serializing to -1 */
|
|
"0xFFFFFFFF",
|
|
"0xFFFFFFFF",
|
|
/* a negative long long serializing to -1 */
|
|
"0xFFFFFFFFFFFFFFFF",
|
|
"0xFFFFFFFFFFFFFFFF",
|
|
"0xEFFFFFFF",
|
|
};
|
|
/* some casts need to be explicit because of unsigned -> signed */
|
|
gint results[] = {
|
|
123456,
|
|
-123456,
|
|
0xFFFF,
|
|
0xFFFF,
|
|
0x7FFFFFFF,
|
|
(gint) 0x80000000,
|
|
(gint) 0x80000000,
|
|
(gint) 0xFF000000,
|
|
-1,
|
|
(gint) 0xFFFFFFFF,
|
|
-1,
|
|
(gint) 0xFFFFFFFFFFFFFFFFLL,
|
|
(gint) 0xEFFFFFFF,
|
|
};
|
|
int i;
|
|
|
|
g_value_init (&value, G_TYPE_INT);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
fail_unless (gst_value_deserialize (&value, strings[i]),
|
|
"could not deserialize %s (%d)", strings[i], i);
|
|
fail_unless (g_value_get_int (&value) == results[i],
|
|
"resulting value is %d, not %d, for string %s (%d)",
|
|
g_value_get_int (&value), results[i], strings[i], i);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_gint_failures)
|
|
{
|
|
GValue value = { 0 };
|
|
const char *strings[] = {
|
|
"-", /* not a complete number */
|
|
"- TEST", /* not a complete number */
|
|
"0x0000000100000000", /* lowest long long that cannot fit in 32 bits */
|
|
"0xF000000000000000",
|
|
"0xFFFFFFF000000000",
|
|
"0xFFFFFFFF00000000",
|
|
"0x10000000000000000", /* first number too long to fit into a long long */
|
|
/* invent a new processor first before trying to make this one pass */
|
|
"0x10000000000000000000000000000000000000000000",
|
|
};
|
|
int i;
|
|
|
|
g_value_init (&value, G_TYPE_INT);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
fail_if (gst_value_deserialize (&value, strings[i]),
|
|
"deserialized %s (%d), while it should have failed", strings[i], i);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_guint)
|
|
{
|
|
GValue value = { 0 };
|
|
const char *strings[] = {
|
|
"123456",
|
|
"-123456",
|
|
"0xFFFF",
|
|
"0x0000FFFF",
|
|
/* a positive long long, serializing to highest possible positive sint */
|
|
"0x7FFFFFFF",
|
|
/* a positive long long, serializing to lowest possible negative sint */
|
|
"0x80000000",
|
|
"2147483648",
|
|
/* a negative long long, serializing to lowest possible negative sint */
|
|
"0xFFFFFFFF80000000",
|
|
/* a value typically used for rgb masks */
|
|
"0xFF000000",
|
|
/* a positive long long serializing to highest possible positive uint */
|
|
"0xFFFFFFFF",
|
|
"0xFFFFFFFF",
|
|
/* a negative long long serializing to highest possible positive uint */
|
|
"0xFFFFFFFFFFFFFFFF",
|
|
"0xEFFFFFFF",
|
|
};
|
|
guint results[] = {
|
|
123456,
|
|
(guint) - 123456,
|
|
0xFFFF,
|
|
0xFFFF,
|
|
0x7FFFFFFF,
|
|
0x80000000,
|
|
(guint) 2147483648LL,
|
|
0x80000000,
|
|
0xFF000000,
|
|
0xFFFFFFFF,
|
|
G_MAXUINT,
|
|
(guint) 0xFFFFFFFFFFFFFFFFLL,
|
|
0xEFFFFFFF,
|
|
};
|
|
int i;
|
|
|
|
g_value_init (&value, G_TYPE_UINT);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
fail_unless (gst_value_deserialize (&value, strings[i]),
|
|
"could not deserialize %s (%d)", strings[i], i);
|
|
fail_unless (g_value_get_uint (&value) == results[i],
|
|
"resulting value is %d, not %d, for string %s (%d)",
|
|
g_value_get_uint (&value), results[i], strings[i], i);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_guint_failures)
|
|
{
|
|
GValue value = { 0 };
|
|
const char *strings[] = {
|
|
"-", /* not a complete number */
|
|
"- TEST", /* not a complete number */
|
|
#if 0
|
|
/* FIXME: these values should not be deserializable, since they overflow
|
|
* the target format */
|
|
"0x0000000100000000", /* lowest long long that cannot fit in 32 bits */
|
|
"0xF000000000000000",
|
|
"0xFFFFFFF000000000",
|
|
"0xFFFFFFFF00000000",
|
|
"0x10000000000000000", /* first number too long to fit into a long long */
|
|
/* invent a new processor first before trying to make this one pass */
|
|
"0x10000000000000000000000000000000000000000000",
|
|
#endif
|
|
};
|
|
int i;
|
|
|
|
g_value_init (&value, G_TYPE_UINT);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
fail_if (gst_value_deserialize (&value, strings[i]),
|
|
"deserialized %s (%d), while it should have failed", strings[i], i);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_serialize_flags)
|
|
{
|
|
GValue value = { 0 };
|
|
gchar *string;
|
|
GstSeekFlags flags[] = {
|
|
0,
|
|
GST_SEEK_FLAG_NONE,
|
|
GST_SEEK_FLAG_FLUSH,
|
|
GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
|
|
};
|
|
const char *results[] = {
|
|
"GST_SEEK_FLAG_NONE",
|
|
"GST_SEEK_FLAG_NONE",
|
|
"GST_SEEK_FLAG_FLUSH",
|
|
"GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",
|
|
};
|
|
int i;
|
|
|
|
g_value_init (&value, GST_TYPE_SEEK_FLAGS);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (flags); ++i) {
|
|
g_value_set_flags (&value, flags[i]);
|
|
string = gst_value_serialize (&value);
|
|
fail_if (string == NULL, "could not serialize flags %d", i);
|
|
fail_unless (strcmp (string, results[i]) == 0,
|
|
"resulting value is %s, not %s, for flags #%d", string, results[i], i);
|
|
g_free (string);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
GST_START_TEST (test_deserialize_flags)
|
|
{
|
|
GValue value = { 0 };
|
|
const char *strings[] = {
|
|
"",
|
|
"0",
|
|
"GST_SEEK_FLAG_NONE",
|
|
"GST_SEEK_FLAG_FLUSH",
|
|
"0xf",
|
|
"15",
|
|
"GST_SEEK_FLAG_FLUSH+GST_SEEK_FLAG_ACCURATE",
|
|
};
|
|
GstSeekFlags results[] = {
|
|
GST_SEEK_FLAG_NONE,
|
|
GST_SEEK_FLAG_NONE,
|
|
GST_SEEK_FLAG_NONE,
|
|
GST_SEEK_FLAG_FLUSH,
|
|
0xf,
|
|
15,
|
|
GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_ACCURATE,
|
|
};
|
|
int i;
|
|
|
|
g_value_init (&value, GST_TYPE_SEEK_FLAGS);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
fail_unless (gst_value_deserialize (&value, strings[i]),
|
|
"could not deserialize %s (%d)", strings[i], i);
|
|
fail_unless (g_value_get_flags (&value) == results[i],
|
|
"resulting value is %d, not %d, for string %s (%d)",
|
|
g_value_get_flags (&value), results[i], strings[i], i);
|
|
}
|
|
|
|
fail_if (gst_value_deserialize (&value, "foo"),
|
|
"flag deserializing for bogus value should have failed!");
|
|
fail_if (gst_value_deserialize (&value, "GST_SEEK_FLAG_FLUSH+foo"),
|
|
"flag deserializing for bogus value should have failed!");
|
|
fail_if (gst_value_deserialize (&value,
|
|
"GST_SEEK_FLAG_FLUSH+foo+GST_SEEK_FLAG_ACCURATE"),
|
|
"flag deserializing for bogus value should have failed!");
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_gtype)
|
|
{
|
|
GValue value = { 0 };
|
|
const char *strings[] = {
|
|
"gchararray",
|
|
"gint",
|
|
};
|
|
GType results[] = {
|
|
G_TYPE_STRING,
|
|
G_TYPE_INT,
|
|
};
|
|
int i;
|
|
|
|
g_value_init (&value, G_TYPE_GTYPE);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
fail_unless (gst_value_deserialize (&value, strings[i]),
|
|
"could not deserialize %s (%d)", strings[i], i);
|
|
fail_unless (g_value_get_gtype (&value) == results[i],
|
|
"resulting value is %" G_GSIZE_FORMAT ", not %" G_GSIZE_FORMAT
|
|
", for string %s (%d)",
|
|
g_value_get_gtype (&value), results[i], strings[i], i);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_gtype_failures)
|
|
{
|
|
GValue value = { 0 };
|
|
const char *strings[] = {
|
|
"-", /* not a gtype */
|
|
};
|
|
int i;
|
|
|
|
g_value_init (&value, G_TYPE_GTYPE);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
fail_if (gst_value_deserialize (&value, strings[i]),
|
|
"deserialized %s (%d), while it should have failed", strings[i], i);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_bitmask)
|
|
{
|
|
GValue value = { 0 };
|
|
const char *strings[] = {
|
|
"0xffffffffffffffff",
|
|
"0x1234567890ABCDEF",
|
|
};
|
|
guint64 results[] = {
|
|
0xffffffffffffffffULL,
|
|
0x1234567890ABCDEFULL,
|
|
};
|
|
int i;
|
|
|
|
g_value_init (&value, GST_TYPE_BITMASK);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
fail_unless (gst_value_deserialize (&value, strings[i]),
|
|
"could not deserialize %s (%d)", strings[i], i);
|
|
fail_unless (gst_value_get_bitmask (&value) == results[i],
|
|
"resulting value is 0x%016" G_GINT64_MODIFIER "x, not 0x%016"
|
|
G_GINT64_MODIFIER "x, for string %s (%d)",
|
|
gst_value_get_bitmask (&value), results[i], strings[i], i);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static void
|
|
check_flagset_mask_serialisation (GValue * value, guint test_flags,
|
|
guint test_mask)
|
|
{
|
|
gchar *string;
|
|
gst_value_set_flagset (value, test_flags, test_mask);
|
|
|
|
/* Normalise our test flags against the mask now for easier testing,
|
|
* as that's what we expect to get back from the flagset after it
|
|
* normalises internally */
|
|
test_flags &= test_mask;
|
|
|
|
/* Check the values got stored correctly */
|
|
fail_unless (gst_value_get_flagset_flags (value) == test_flags,
|
|
"resulting flags value is 0x%u, not 0x%x",
|
|
gst_value_get_flagset_flags (value), test_flags);
|
|
fail_unless (gst_value_get_flagset_mask (value) == test_mask,
|
|
"resulting mask is 0x%u, not 0x%x",
|
|
gst_value_get_flagset_mask (value), test_mask);
|
|
|
|
string = gst_value_serialize (value);
|
|
fail_if (string == NULL, "could not serialize flagset");
|
|
|
|
GST_DEBUG ("Serialized flagset to: %s", string);
|
|
|
|
fail_unless (gst_value_deserialize (value, string),
|
|
"could not deserialize %s", string);
|
|
|
|
fail_unless (gst_value_get_flagset_flags (value) == test_flags,
|
|
"resulting flags value is 0x%u, not 0x%x, for string %s",
|
|
gst_value_get_flagset_flags (value), test_flags, string);
|
|
|
|
fail_unless (gst_value_get_flagset_mask (value) == test_mask,
|
|
"resulting mask is 0x%u, not 0x%x, for string %s",
|
|
gst_value_get_flagset_mask (value), test_mask, string);
|
|
|
|
g_free (string);
|
|
}
|
|
|
|
GST_START_TEST (test_flagset)
|
|
{
|
|
GValue value = G_VALUE_INIT;
|
|
GValue value2 = G_VALUE_INIT;
|
|
GValue dest = G_VALUE_INIT;
|
|
gchar *string;
|
|
GType test_flagset_type;
|
|
guint test_flags, test_mask;
|
|
|
|
/* Test serialisation of abstract type */
|
|
g_value_init (&value, GST_TYPE_FLAG_SET);
|
|
|
|
test_flags = 0xf1f1;
|
|
test_mask = 0xffff;
|
|
|
|
gst_value_set_flagset (&value, test_flags, test_mask);
|
|
string = gst_value_serialize (&value);
|
|
fail_if (string == NULL, "could not serialize flagset");
|
|
|
|
fail_unless (gst_value_deserialize (&value, string),
|
|
"could not deserialize %s", string);
|
|
|
|
fail_unless (gst_value_get_flagset_flags (&value) == test_flags,
|
|
"resulting value is 0x%u, not 0x%x, for string %s",
|
|
gst_value_get_flagset_flags (&value), test_flags, string);
|
|
|
|
fail_unless (gst_value_get_flagset_mask (&value) == test_mask,
|
|
"resulting value is 0x%u, not 0x%x, for string %s",
|
|
gst_value_get_flagset_mask (&value), test_mask, string);
|
|
|
|
g_free (string);
|
|
g_value_unset (&value);
|
|
|
|
/* Check we can't wrap a random non-flags type */
|
|
ASSERT_CRITICAL (gst_flagset_register (GST_TYPE_OBJECT));
|
|
|
|
test_flagset_type = gst_flagset_register (GST_TYPE_SEEK_FLAGS);
|
|
|
|
fail_unless (g_type_is_a (test_flagset_type, GST_TYPE_FLAG_SET));
|
|
|
|
g_value_init (&value, test_flagset_type);
|
|
|
|
test_flags =
|
|
GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_TRICKMODE |
|
|
GST_SEEK_FLAG_TRICKMODE_KEY_UNITS;
|
|
test_mask =
|
|
GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_TRICKMODE |
|
|
GST_SEEK_FLAG_TRICKMODE_NO_AUDIO;
|
|
|
|
check_flagset_mask_serialisation (&value, test_flags, test_mask);
|
|
/* Check serialisation works with the generic 'exact' flag */
|
|
check_flagset_mask_serialisation (&value, test_flags,
|
|
GST_FLAG_SET_MASK_EXACT);
|
|
|
|
/* Check deserialisation of flagset in 'flags' form, without
|
|
* the hex strings at the start */
|
|
test_flags = GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_TRICKMODE;
|
|
test_mask = GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_TRICKMODE |
|
|
GST_SEEK_FLAG_TRICKMODE_NO_AUDIO;
|
|
string = g_strdup ("+flush+trickmode/trickmode-no-audio");
|
|
|
|
fail_unless (gst_value_deserialize (&value, string),
|
|
"could not deserialize %s", string);
|
|
|
|
GST_DEBUG ("Deserialized %s to 0x%x:0x%x", string,
|
|
gst_value_get_flagset_flags (&value),
|
|
gst_value_get_flagset_mask (&value));
|
|
|
|
fail_unless (gst_value_get_flagset_flags (&value) == test_flags,
|
|
"resulting flags value is 0x%u, not 0x%x, for string %s",
|
|
gst_value_get_flagset_flags (&value), (test_flags & test_mask), string);
|
|
|
|
fail_unless (gst_value_get_flagset_mask (&value) == test_mask,
|
|
"resulting mask is 0x%u, not 0x%x, for string %s",
|
|
gst_value_get_flagset_mask (&value), test_mask, string);
|
|
|
|
g_free (string);
|
|
g_value_unset (&value);
|
|
|
|
/* Test that fixating don't-care fields works, using our
|
|
* sub-type flagset for good measure */
|
|
g_value_init (&value, test_flagset_type);
|
|
gst_value_set_flagset (&value, test_flags, test_mask);
|
|
|
|
fail_unless (gst_value_fixate (&dest, &value));
|
|
fail_unless (gst_value_get_flagset_flags (&dest) == test_flags);
|
|
fail_unless (gst_value_get_flagset_mask (&dest) == GST_FLAG_SET_MASK_EXACT);
|
|
|
|
g_value_unset (&value);
|
|
|
|
/* Intersection tests */
|
|
g_value_init (&value, GST_TYPE_FLAG_SET);
|
|
g_value_init (&value2, test_flagset_type);
|
|
|
|
/* We want Accurate, but not Snap-Before */
|
|
gst_value_set_flagset (&value, GST_SEEK_FLAG_ACCURATE,
|
|
GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_SNAP_BEFORE);
|
|
|
|
/* This only cares that things are flushing */
|
|
gst_value_set_flagset (&value2, GST_SEEK_FLAG_FLUSH, GST_SEEK_FLAG_FLUSH);
|
|
|
|
test_flags = GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_FLUSH;
|
|
test_mask =
|
|
GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SNAP_BEFORE;
|
|
|
|
/* GstFlagSet should always intersect with itself */
|
|
g_value_unset (&dest);
|
|
fail_unless (gst_value_can_intersect (&value, &value));
|
|
fail_unless (gst_value_intersect (&dest, &value, &value));
|
|
|
|
/* GstFlagSet subtype should intersect with itself */
|
|
g_value_unset (&dest);
|
|
fail_unless (gst_value_can_intersect (&value2, &value2));
|
|
fail_unless (gst_value_intersect (&dest, &value2, &value2));
|
|
|
|
/* Check we can intersect custom flagset subtype with flagset */
|
|
g_value_unset (&dest);
|
|
fail_unless (gst_value_can_intersect (&value2, &value));
|
|
fail_unless (gst_value_intersect (&dest, &value2, &value));
|
|
|
|
/* and in the other order */
|
|
g_value_unset (&dest);
|
|
fail_unless (gst_value_can_intersect (&value, &value2));
|
|
fail_unless (gst_value_intersect (&dest, &value, &value2));
|
|
|
|
fail_unless (gst_value_get_flagset_flags (&dest) == test_flags,
|
|
"resulting flags value is 0x%u, not 0x%x",
|
|
gst_value_get_flagset_flags (&dest), test_flags);
|
|
|
|
fail_unless (gst_value_get_flagset_mask (&dest) == test_mask,
|
|
"resulting mask is 0x%u, not 0x%x",
|
|
gst_value_get_flagset_mask (&dest), test_mask);
|
|
|
|
gst_value_set_flagset (&value,
|
|
GST_SEEK_FLAG_ACCURATE, GST_SEEK_FLAG_ACCURATE);
|
|
gst_value_set_flagset (&value2, GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_FLUSH,
|
|
GST_SEEK_FLAG_ACCURATE | GST_SEEK_FLAG_SNAP_BEFORE | GST_SEEK_FLAG_FLUSH);
|
|
/* Check that accurate alone is a subset of accurate+!snap_before+flush,
|
|
* but not vice-versa */
|
|
fail_unless (gst_value_is_subset (&value, &value2));
|
|
fail_if (gst_value_is_subset (&value2, &value));
|
|
|
|
g_value_unset (&dest);
|
|
g_value_unset (&value);
|
|
g_value_unset (&value2);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
GST_START_TEST (test_string)
|
|
{
|
|
const gchar *try[] = {
|
|
"Dude",
|
|
"Hi, I'm a string",
|
|
"tüüüt!",
|
|
"\"\"" /* Empty string */
|
|
};
|
|
gchar *tmp;
|
|
GValue v = { 0, };
|
|
guint i;
|
|
|
|
g_value_init (&v, G_TYPE_STRING);
|
|
for (i = 0; i < G_N_ELEMENTS (try); i++) {
|
|
g_value_set_string (&v, try[i]);
|
|
tmp = gst_value_serialize (&v);
|
|
fail_if (tmp == NULL, "couldn't serialize: %s\n", try[i]);
|
|
fail_unless (gst_value_deserialize (&v, tmp),
|
|
"couldn't deserialize: %s\n", tmp);
|
|
g_free (tmp);
|
|
|
|
fail_unless (g_str_equal (g_value_get_string (&v), try[i]),
|
|
"\nserialized : %s\ndeserialized: %s", try[i],
|
|
g_value_get_string (&v));
|
|
}
|
|
/* NULL strings should not be serializable */
|
|
g_value_set_string (&v, NULL);
|
|
fail_unless (gst_value_serialize (&v) == NULL);
|
|
g_value_unset (&v);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_string)
|
|
{
|
|
struct
|
|
{
|
|
const gchar *from;
|
|
const gchar *to;
|
|
} tests[] = {
|
|
{
|
|
"\"foo\"", "foo"}, {
|
|
"\"foo\\%\"", "foo%"}, {
|
|
"\"0123456789_-+/:.\"", "0123456789_-+/:."}, {
|
|
"\"Hello\\ World\"", "Hello World"}, {
|
|
"\"Hello\\ World", "\"Hello\\ World"}, {
|
|
"\"\\", "\"\\"}, {
|
|
"\"\\0", "\"\\0"}, {
|
|
"\"t\\303\\274t\"", "tüt"}, {
|
|
/* utf8 octal sequence */
|
|
"", ""}, /* empty strings */
|
|
{
|
|
"\"\"", ""}, { /* quoted empty string -> empty string */
|
|
"\" \"", " "}, { /* allow spaces to be not escaped */
|
|
"tüüt", "tüüt"}, /* allow special chars to be not escaped */
|
|
/* Expected FAILURES: */
|
|
{
|
|
"\"\\0\"", NULL}, { /* unfinished escaped character */
|
|
"\"", NULL}, { /* solitary quote */
|
|
"\"\\380\"", NULL}, { /* invalid octal sequence */
|
|
"\"\\344\\204\\062\"", NULL}, {
|
|
/* invalid utf8: wrong end byte */
|
|
"\"\\344\\204\"", NULL} /* invalid utf8: wrong number of bytes */
|
|
};
|
|
guint i;
|
|
GValue v = { 0, };
|
|
|
|
g_value_init (&v, G_TYPE_STRING);
|
|
for (i = 0; i < G_N_ELEMENTS (tests); i++) {
|
|
if (gst_value_deserialize (&v, tests[i].from)) {
|
|
fail_if (tests[i].to == NULL,
|
|
"I got %s instead of a failure", g_value_get_string (&v));
|
|
fail_unless (g_str_equal (g_value_get_string (&v), tests[i].to),
|
|
"\nwanted: %s\ngot : %s", tests[i].to, g_value_get_string (&v));
|
|
} else {
|
|
fail_if (tests[i].to != NULL, "failed, but wanted: %s", tests[i].to);
|
|
}
|
|
}
|
|
g_value_unset (&v);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_value_compare)
|
|
{
|
|
GValue value1 = { 0 };
|
|
GValue value2 = { 0 };
|
|
GValue tmp = { 0 };
|
|
GstAllocationParams alloc_params = { 0 };
|
|
|
|
g_value_init (&value1, G_TYPE_INT);
|
|
g_value_set_int (&value1, 10);
|
|
g_value_init (&value2, G_TYPE_INT);
|
|
g_value_set_int (&value2, 20);
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
|
|
fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
|
|
fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
|
|
g_value_init (&value1, G_TYPE_DOUBLE);
|
|
g_value_set_double (&value1, 10);
|
|
g_value_init (&value2, G_TYPE_DOUBLE);
|
|
g_value_set_double (&value2, 20);
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
|
|
fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
|
|
fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
|
|
g_value_init (&value1, G_TYPE_STRING);
|
|
g_value_set_string (&value1, "a");
|
|
g_value_init (&value2, G_TYPE_STRING);
|
|
g_value_set_string (&value2, "b");
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
|
|
fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
|
|
fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
|
|
/* Test some NULL string comparisons */
|
|
g_value_set_string (&value2, NULL);
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
|
|
fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_UNORDERED);
|
|
fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL);
|
|
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
|
|
/* comparing 2/3 with 3/4 */
|
|
g_value_init (&value1, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&value1, 2, 3);
|
|
g_value_init (&value2, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&value2, 3, 4);
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
|
|
fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
|
|
fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
|
|
/* comparing -4/5 with 2/-3 */
|
|
g_value_init (&value1, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&value1, -4, 5);
|
|
g_value_init (&value2, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&value2, 2, -3);
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
|
|
fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
|
|
fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
|
|
/* comparing 10/100 with 200/2000 */
|
|
g_value_init (&value1, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&value1, 10, 100);
|
|
g_value_init (&value2, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&value2, 200, 2000);
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL);
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
|
|
/* comparing -4/5 with 2/-3 */
|
|
g_value_init (&value1, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&value1, -4, 5);
|
|
g_value_init (&value2, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&value2, 2, -3);
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_LESS_THAN);
|
|
fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_GREATER_THAN);
|
|
fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
|
|
/* Check that lists are equal regardless of order */
|
|
g_value_init (&value1, GST_TYPE_LIST);
|
|
g_value_init (&tmp, G_TYPE_INT);
|
|
g_value_set_int (&tmp, 1);
|
|
gst_value_list_append_value (&value1, &tmp);
|
|
g_value_set_int (&tmp, 2);
|
|
gst_value_list_append_value (&value1, &tmp);
|
|
g_value_set_int (&tmp, 3);
|
|
gst_value_list_append_value (&value1, &tmp);
|
|
g_value_set_int (&tmp, 4);
|
|
gst_value_list_append_value (&value1, &tmp);
|
|
|
|
g_value_init (&value2, GST_TYPE_LIST);
|
|
g_value_set_int (&tmp, 4);
|
|
gst_value_list_append_value (&value2, &tmp);
|
|
g_value_set_int (&tmp, 3);
|
|
gst_value_list_append_value (&value2, &tmp);
|
|
g_value_set_int (&tmp, 2);
|
|
gst_value_list_append_value (&value2, &tmp);
|
|
g_value_set_int (&tmp, 1);
|
|
gst_value_list_append_value (&value2, &tmp);
|
|
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
|
|
"value lists with different order were not equal when they should be");
|
|
fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL,
|
|
"value lists with same order were not equal when they should be");
|
|
fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL,
|
|
"value lists with same order were not equal when they should be");
|
|
|
|
/* Carry over the lists to this next check: */
|
|
/* Lists with different sizes are unequal */
|
|
g_value_set_int (&tmp, 1);
|
|
gst_value_list_append_value (&value2, &tmp);
|
|
|
|
fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
|
|
"Value lists with different size were equal when they shouldn't be");
|
|
|
|
/* Carry over the lists to this next check: */
|
|
/* Lists with same size but list1 contains one more element not in list2 */
|
|
g_value_set_int (&tmp, 5);
|
|
gst_value_list_append_value (&value1, &tmp);
|
|
|
|
fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
|
|
"Value lists with different elements were equal when they shouldn't be");
|
|
fail_if (gst_value_compare (&value2, &value1) == GST_VALUE_EQUAL,
|
|
"Value lists with different elements were equal when they shouldn't be");
|
|
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
g_value_unset (&tmp);
|
|
|
|
/* Arrays are only equal when in the same order */
|
|
g_value_init (&value1, GST_TYPE_ARRAY);
|
|
g_value_init (&tmp, G_TYPE_INT);
|
|
g_value_set_int (&tmp, 1);
|
|
gst_value_array_append_value (&value1, &tmp);
|
|
g_value_set_int (&tmp, 2);
|
|
gst_value_array_append_value (&value1, &tmp);
|
|
g_value_set_int (&tmp, 3);
|
|
gst_value_array_append_value (&value1, &tmp);
|
|
g_value_set_int (&tmp, 4);
|
|
gst_value_array_append_value (&value1, &tmp);
|
|
|
|
g_value_init (&value2, GST_TYPE_ARRAY);
|
|
g_value_set_int (&tmp, 4);
|
|
gst_value_array_append_value (&value2, &tmp);
|
|
g_value_set_int (&tmp, 3);
|
|
gst_value_array_append_value (&value2, &tmp);
|
|
g_value_set_int (&tmp, 2);
|
|
gst_value_array_append_value (&value2, &tmp);
|
|
g_value_set_int (&tmp, 1);
|
|
gst_value_array_append_value (&value2, &tmp);
|
|
|
|
fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
|
|
"Value arrays with different order were equal when they shouldn't be");
|
|
fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL,
|
|
"Identical value arrays were not equal when they should be");
|
|
fail_unless (gst_value_compare (&value2, &value2) == GST_VALUE_EQUAL,
|
|
"Identical value arrays were not equal when they should be");
|
|
|
|
/* Carry over the arrays to this next check: */
|
|
/* Arrays with different sizes are unequal */
|
|
g_value_unset (&value2);
|
|
g_value_init (&value2, GST_TYPE_ARRAY);
|
|
g_value_copy (&value1, &value2);
|
|
|
|
g_value_set_int (&tmp, 1);
|
|
gst_value_array_append_value (&value2, &tmp);
|
|
|
|
fail_if (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
|
|
"Value arrays with different size were equal when they shouldn't be");
|
|
/* order should not matter */
|
|
fail_if (gst_value_compare (&value2, &value1) == GST_VALUE_EQUAL,
|
|
"Value arrays with different size were equal when they shouldn't be");
|
|
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
g_value_unset (&tmp);
|
|
|
|
g_value_init (&value1, G_TYPE_VALUE_ARRAY);
|
|
g_value_init (&value2, G_TYPE_VALUE_ARRAY);
|
|
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL,
|
|
"Empty Value arrays aren't equals when they should");
|
|
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
|
|
g_value_init (&value1, GST_TYPE_BITMASK);
|
|
gst_value_set_bitmask (&value1, 0x123);
|
|
g_value_init (&value2, GST_TYPE_BITMASK);
|
|
gst_value_set_bitmask (&value2, 0x321);
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
|
|
fail_unless (gst_value_compare (&value2, &value1) == GST_VALUE_UNORDERED);
|
|
fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
|
|
/* Check that we can compare objects */
|
|
g_value_init (&value1, GST_TYPE_BIN);
|
|
g_value_take_object (&value1, gst_bin_new (NULL));
|
|
g_value_init (&value2, GST_TYPE_BIN);
|
|
g_value_take_object (&value2, gst_bin_new (NULL));
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
|
|
fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
|
|
/* Check that we can compare allocation params */
|
|
g_value_init (&value1, GST_TYPE_ALLOCATION_PARAMS);
|
|
g_value_set_boxed (&value1, &alloc_params);
|
|
g_value_init (&value2, GST_TYPE_ALLOCATION_PARAMS);
|
|
alloc_params.align = 1;
|
|
g_value_set_boxed (&value2, &alloc_params);
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
|
|
fail_unless (gst_value_compare (&value1, &value1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
|
|
/* Check that we can compare structure */
|
|
{
|
|
GstStructure *s = gst_structure_new_empty ("test");
|
|
|
|
g_value_init (&value1, GST_TYPE_STRUCTURE);
|
|
g_value_init (&value2, GST_TYPE_STRUCTURE);
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL);
|
|
|
|
gst_value_set_structure (&value1, s);
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_UNORDERED);
|
|
gst_value_set_structure (&value2, s);
|
|
fail_unless (gst_value_compare (&value1, &value2) == GST_VALUE_EQUAL);
|
|
g_value_unset (&value1);
|
|
g_value_unset (&value2);
|
|
gst_structure_free (s);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_value_intersect)
|
|
{
|
|
GValue dest = { 0 };
|
|
GValue src1 = { 0 };
|
|
GValue src2 = { 0 };
|
|
GValue item = { 0 };
|
|
gboolean ret;
|
|
|
|
g_value_init (&src1, G_TYPE_INT);
|
|
g_value_set_int (&src1, 10);
|
|
g_value_init (&src2, G_TYPE_INT);
|
|
g_value_set_int (&src2, 20);
|
|
ret = gst_value_intersect (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
g_value_init (&src1, G_TYPE_STRING);
|
|
g_value_set_static_string (&src1, "YUY2");
|
|
g_value_init (&src2, GST_TYPE_LIST);
|
|
g_value_init (&item, G_TYPE_STRING);
|
|
g_value_set_static_string (&item, "YUY2");
|
|
gst_value_list_append_value (&src2, &item);
|
|
g_value_set_static_string (&item, "I420");
|
|
gst_value_list_append_value (&src2, &item);
|
|
g_value_set_static_string (&item, "ABCD");
|
|
gst_value_list_append_value (&src2, &item);
|
|
|
|
fail_unless (gst_value_intersect (&dest, &src1, &src2));
|
|
fail_unless (G_VALUE_HOLDS_STRING (&dest));
|
|
fail_unless (g_str_equal (g_value_get_string (&dest), "YUY2"));
|
|
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
g_value_unset (&dest);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
GST_START_TEST (test_value_subtract_int)
|
|
{
|
|
GValue dest = { 0 };
|
|
GValue src1 = { 0 };
|
|
GValue src2 = { 0 };
|
|
const GValue *tmp;
|
|
gboolean ret;
|
|
|
|
/* int <-> int
|
|
*/
|
|
g_value_init (&src1, G_TYPE_INT);
|
|
g_value_set_int (&src1, 10);
|
|
g_value_init (&src2, G_TYPE_INT);
|
|
g_value_set_int (&src2, 20);
|
|
/* subtract as in sets, result is 10 */
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
|
|
/* same values, yields empty set */
|
|
ret = gst_value_subtract (&dest, &src1, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* int <-> int_range
|
|
*/
|
|
|
|
/* would yield an empty set */
|
|
g_value_init (&src1, G_TYPE_INT);
|
|
g_value_set_int (&src1, 10);
|
|
g_value_init (&src2, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src2, 0, 20);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
|
|
/* and the other way around, should create a list of two ranges. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_LIST);
|
|
tmp = gst_value_list_get_value (&dest, 0);
|
|
fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_int_range_min (tmp) == 0);
|
|
fail_unless (gst_value_get_int_range_max (tmp) == 9);
|
|
tmp = gst_value_list_get_value (&dest, 1);
|
|
fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_int_range_min (tmp) == 11);
|
|
fail_unless (gst_value_get_int_range_max (tmp) == 20);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* border case 1, empty set */
|
|
g_value_init (&src1, G_TYPE_INT);
|
|
g_value_set_int (&src1, 10);
|
|
g_value_init (&src2, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src2, 10, 20);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
|
|
/* and the other way around, should create a new range. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
|
|
fail_unless (gst_value_get_int_range_min (&dest) == 11);
|
|
fail_unless (gst_value_get_int_range_max (&dest) == 20);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* border case 2, empty set */
|
|
g_value_init (&src1, G_TYPE_INT);
|
|
g_value_set_int (&src1, 20);
|
|
g_value_init (&src2, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src2, 10, 20);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
|
|
/* and the other way around, should create a new range. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
|
|
fail_unless (gst_value_get_int_range_min (&dest) == 10);
|
|
fail_unless (gst_value_get_int_range_max (&dest) == 19);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* case 3, valid set */
|
|
g_value_init (&src1, G_TYPE_INT);
|
|
g_value_set_int (&src1, 0);
|
|
g_value_init (&src2, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src2, 10, 20);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_HOLDS_INT (&dest) == TRUE);
|
|
fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
|
|
/* and the other way around, should keep the range. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
|
|
fail_unless (gst_value_get_int_range_min (&dest) == 10);
|
|
fail_unless (gst_value_get_int_range_max (&dest) == 20);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* int_range <-> int_range
|
|
*/
|
|
|
|
/* same range, empty set */
|
|
g_value_init (&src1, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src1, 10, 20);
|
|
g_value_init (&src2, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src2, 10, 20);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* non overlapping ranges */
|
|
g_value_init (&src1, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src1, 10, 20);
|
|
g_value_init (&src2, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src2, 30, 40);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
|
|
fail_unless (gst_value_get_int_range_min (&dest) == 10);
|
|
fail_unless (gst_value_get_int_range_max (&dest) == 20);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
|
|
fail_unless (gst_value_get_int_range_min (&dest) == 30);
|
|
fail_unless (gst_value_get_int_range_max (&dest) == 40);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* completely overlapping ranges */
|
|
g_value_init (&src1, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src1, 10, 20);
|
|
g_value_init (&src2, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src2, 10, 30);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
|
|
fail_unless (gst_value_get_int_range_min (&dest) == 21);
|
|
fail_unless (gst_value_get_int_range_max (&dest) == 30);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* partially overlapping ranges */
|
|
g_value_init (&src1, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src1, 10, 20);
|
|
g_value_init (&src2, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src2, 15, 30);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
|
|
fail_unless (gst_value_get_int_range_min (&dest) == 10);
|
|
fail_unless (gst_value_get_int_range_max (&dest) == 14);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
|
|
fail_unless (gst_value_get_int_range_min (&dest) == 21);
|
|
fail_unless (gst_value_get_int_range_max (&dest) == 30);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* create a hole { int_range, int_range } */
|
|
g_value_init (&src1, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src1, 10, 30);
|
|
g_value_init (&src2, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src2, 15, 20);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_LIST);
|
|
tmp = gst_value_list_get_value (&dest, 0);
|
|
fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_int_range_min (tmp) == 10);
|
|
fail_unless (gst_value_get_int_range_max (tmp) == 14);
|
|
tmp = gst_value_list_get_value (&dest, 1);
|
|
fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_int_range_min (tmp) == 21);
|
|
fail_unless (gst_value_get_int_range_max (tmp) == 30);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* create a hole, { int, int } */
|
|
g_value_init (&src1, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src1, 10, 30);
|
|
g_value_init (&src2, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src2, 11, 29);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_LIST);
|
|
tmp = gst_value_list_get_value (&dest, 0);
|
|
fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
|
|
fail_unless (g_value_get_int (tmp) == 10);
|
|
tmp = gst_value_list_get_value (&dest, 1);
|
|
fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
|
|
fail_unless (g_value_get_int (tmp) == 30);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* create a hole, { int, int_range } */
|
|
g_value_init (&src1, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src1, 10, 30);
|
|
g_value_init (&src2, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src2, 11, 28);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_LIST);
|
|
tmp = gst_value_list_get_value (&dest, 0);
|
|
fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
|
|
fail_unless (g_value_get_int (tmp) == 10);
|
|
tmp = gst_value_list_get_value (&dest, 1);
|
|
fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_int_range_min (tmp) == 29);
|
|
fail_unless (gst_value_get_int_range_max (tmp) == 30);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* create a hole, { int_range, int } */
|
|
g_value_init (&src1, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src1, 10, 30);
|
|
g_value_init (&src2, GST_TYPE_INT_RANGE);
|
|
gst_value_set_int_range (&src2, 12, 29);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_LIST);
|
|
tmp = gst_value_list_get_value (&dest, 0);
|
|
fail_unless (GST_VALUE_HOLDS_INT_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_int_range_min (tmp) == 10);
|
|
fail_unless (gst_value_get_int_range_max (tmp) == 11);
|
|
tmp = gst_value_list_get_value (&dest, 1);
|
|
fail_unless (G_VALUE_HOLDS_INT (tmp) == TRUE);
|
|
fail_unless (g_value_get_int (tmp) == 30);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_value_subtract_int64)
|
|
{
|
|
GValue dest = { 0 };
|
|
GValue src1 = { 0 };
|
|
GValue src2 = { 0 };
|
|
const GValue *tmp;
|
|
gboolean ret;
|
|
|
|
/* int64 <-> int64
|
|
*/
|
|
g_value_init (&src1, G_TYPE_INT64);
|
|
g_value_set_int64 (&src1, 10);
|
|
g_value_init (&src2, G_TYPE_INT64);
|
|
g_value_set_int64 (&src2, 20);
|
|
/* subtract as in sets, result is 10 */
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
|
|
/* same values, yields empty set */
|
|
ret = gst_value_subtract (&dest, &src1, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* int64 <-> int64_range
|
|
*/
|
|
|
|
/* would yield an empty set */
|
|
g_value_init (&src1, G_TYPE_INT64);
|
|
g_value_set_int64 (&src1, 10);
|
|
g_value_init (&src2, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src2, 0, 20);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
|
|
/* and the other way around, should create a list of two ranges. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_LIST);
|
|
tmp = gst_value_list_get_value (&dest, 0);
|
|
fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_int64_range_min (tmp) == 0);
|
|
fail_unless (gst_value_get_int64_range_max (tmp) == 9);
|
|
tmp = gst_value_list_get_value (&dest, 1);
|
|
fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_int64_range_min (tmp) == 11);
|
|
fail_unless (gst_value_get_int64_range_max (tmp) == 20);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* border case 1, empty set */
|
|
g_value_init (&src1, G_TYPE_INT64);
|
|
g_value_set_int64 (&src1, 10);
|
|
g_value_init (&src2, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src2, 10, 20);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
|
|
/* and the other way around, should create a new range. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
|
|
fail_unless (gst_value_get_int64_range_min (&dest) == 11);
|
|
fail_unless (gst_value_get_int64_range_max (&dest) == 20);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* border case 2, empty set */
|
|
g_value_init (&src1, G_TYPE_INT64);
|
|
g_value_set_int64 (&src1, 20);
|
|
g_value_init (&src2, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src2, 10, 20);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
|
|
/* and the other way around, should create a new range. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
|
|
fail_unless (gst_value_get_int64_range_min (&dest) == 10);
|
|
fail_unless (gst_value_get_int64_range_max (&dest) == 19);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* case 3, valid set */
|
|
g_value_init (&src1, G_TYPE_INT64);
|
|
g_value_set_int64 (&src1, 0);
|
|
g_value_init (&src2, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src2, 10, 20);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_HOLDS_INT64 (&dest) == TRUE);
|
|
fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
|
|
/* and the other way around, should keep the range. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
|
|
fail_unless (gst_value_get_int64_range_min (&dest) == 10);
|
|
fail_unless (gst_value_get_int64_range_max (&dest) == 20);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* int64_range <-> int64_range
|
|
*/
|
|
|
|
/* same range, empty set */
|
|
g_value_init (&src1, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src1, 10, 20);
|
|
g_value_init (&src2, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src2, 10, 20);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* non overlapping ranges */
|
|
g_value_init (&src1, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src1, 10, 20);
|
|
g_value_init (&src2, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src2, 30, 40);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
|
|
fail_unless (gst_value_get_int64_range_min (&dest) == 10);
|
|
fail_unless (gst_value_get_int64_range_max (&dest) == 20);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
|
|
fail_unless (gst_value_get_int64_range_min (&dest) == 30);
|
|
fail_unless (gst_value_get_int64_range_max (&dest) == 40);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* completely overlapping ranges */
|
|
g_value_init (&src1, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src1, 10, 20);
|
|
g_value_init (&src2, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src2, 10, 30);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
|
|
fail_unless (gst_value_get_int64_range_min (&dest) == 21);
|
|
fail_unless (gst_value_get_int64_range_max (&dest) == 30);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* partially overlapping ranges */
|
|
g_value_init (&src1, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src1, 10, 20);
|
|
g_value_init (&src2, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src2, 15, 30);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
|
|
fail_unless (gst_value_get_int64_range_min (&dest) == 10);
|
|
fail_unless (gst_value_get_int64_range_max (&dest) == 14);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
|
|
fail_unless (gst_value_get_int64_range_min (&dest) == 21);
|
|
fail_unless (gst_value_get_int64_range_max (&dest) == 30);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* create a hole { int64_range, int64_range } */
|
|
g_value_init (&src1, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src1, 10, 30);
|
|
g_value_init (&src2, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src2, 15, 20);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_LIST);
|
|
tmp = gst_value_list_get_value (&dest, 0);
|
|
fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_int64_range_min (tmp) == 10);
|
|
fail_unless (gst_value_get_int64_range_max (tmp) == 14);
|
|
tmp = gst_value_list_get_value (&dest, 1);
|
|
fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_int64_range_min (tmp) == 21);
|
|
fail_unless (gst_value_get_int64_range_max (tmp) == 30);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* create a hole, { int64, int64 } */
|
|
g_value_init (&src1, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src1, 10, 30);
|
|
g_value_init (&src2, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src2, 11, 29);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_LIST);
|
|
tmp = gst_value_list_get_value (&dest, 0);
|
|
fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
|
|
fail_unless (g_value_get_int64 (tmp) == 10);
|
|
tmp = gst_value_list_get_value (&dest, 1);
|
|
fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
|
|
fail_unless (g_value_get_int64 (tmp) == 30);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* create a hole, { int64, int64_range } */
|
|
g_value_init (&src1, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src1, 10, 30);
|
|
g_value_init (&src2, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src2, 11, 28);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_LIST);
|
|
tmp = gst_value_list_get_value (&dest, 0);
|
|
fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
|
|
fail_unless (g_value_get_int64 (tmp) == 10);
|
|
tmp = gst_value_list_get_value (&dest, 1);
|
|
fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_int64_range_min (tmp) == 29);
|
|
fail_unless (gst_value_get_int64_range_max (tmp) == 30);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* create a hole, { int64_range, int64 } */
|
|
g_value_init (&src1, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src1, 10, 30);
|
|
g_value_init (&src2, GST_TYPE_INT64_RANGE);
|
|
gst_value_set_int64_range (&src2, 12, 29);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_LIST);
|
|
tmp = gst_value_list_get_value (&dest, 0);
|
|
fail_unless (GST_VALUE_HOLDS_INT64_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_int64_range_min (tmp) == 10);
|
|
fail_unless (gst_value_get_int64_range_max (tmp) == 11);
|
|
tmp = gst_value_list_get_value (&dest, 1);
|
|
fail_unless (G_VALUE_HOLDS_INT64 (tmp) == TRUE);
|
|
fail_unless (g_value_get_int64 (tmp) == 30);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_value_subtract_double)
|
|
{
|
|
GValue dest = { 0 };
|
|
GValue src1 = { 0 };
|
|
GValue src2 = { 0 };
|
|
const GValue *tmp;
|
|
gboolean ret;
|
|
|
|
/* double <-> double
|
|
*/
|
|
g_value_init (&src1, G_TYPE_DOUBLE);
|
|
g_value_set_double (&src1, 10.0);
|
|
g_value_init (&src2, G_TYPE_DOUBLE);
|
|
g_value_set_double (&src2, 20.0);
|
|
/* subtract as in sets, result is 10 */
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
|
|
/* same values, yields empty set */
|
|
ret = gst_value_subtract (&dest, &src1, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* double <-> double_range
|
|
*/
|
|
|
|
/* would yield an empty set */
|
|
g_value_init (&src1, G_TYPE_DOUBLE);
|
|
g_value_set_double (&src1, 10.0);
|
|
g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src2, 0.0, 20.0);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
|
|
/* and the other way around, we cannot create open ranges
|
|
* so the result is the range again */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_DOUBLE_RANGE);
|
|
fail_unless (gst_value_get_double_range_min (&dest) == 0.0);
|
|
fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* border case 1, empty set */
|
|
g_value_init (&src1, G_TYPE_DOUBLE);
|
|
g_value_set_double (&src1, 10.0);
|
|
g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src2, 10.0, 20.0);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
|
|
/* and the other way around, should keep same range as
|
|
* we don't have open ranges. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_DOUBLE_RANGE);
|
|
fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
|
|
fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* border case 2, empty set */
|
|
g_value_init (&src1, G_TYPE_DOUBLE);
|
|
g_value_set_double (&src1, 20.0);
|
|
g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src2, 10.0, 20.0);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
|
|
/* and the other way around, should keep same range as
|
|
* we don't have open ranges. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_DOUBLE_RANGE);
|
|
fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
|
|
fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* case 3, valid set */
|
|
g_value_init (&src1, G_TYPE_DOUBLE);
|
|
g_value_set_double (&src1, 0.0);
|
|
g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src2, 10.0, 20.0);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_HOLDS_DOUBLE (&dest) == TRUE);
|
|
fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
|
|
/* and the other way around, should keep the range. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_DOUBLE_RANGE);
|
|
fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
|
|
fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* double_range <-> double_range
|
|
*/
|
|
|
|
/* Check equality */
|
|
g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src1, 10.0, 20.0);
|
|
g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src2, 10.0, 15.0);
|
|
/* They are not equal (higher bound is different */
|
|
fail_if (gst_value_compare (&src1, &src2) == GST_VALUE_EQUAL);
|
|
g_value_unset (&src1);
|
|
/* They are not equal (lower bound is different */
|
|
g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src1, 5.0, 15.0);
|
|
fail_if (gst_value_compare (&src1, &src2) == GST_VALUE_EQUAL);
|
|
g_value_unset (&src1);
|
|
/* And finally check equality */
|
|
g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src1, 10.0, 15.0);
|
|
fail_unless (gst_value_compare (&src1, &src2) == GST_VALUE_EQUAL);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* same range, empty set */
|
|
g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src1, 10.0, 20.0);
|
|
g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src2, 10.0, 20.0);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* non overlapping ranges */
|
|
g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src1, 10.0, 20.0);
|
|
g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src2, 30.0, 40.0);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_DOUBLE_RANGE);
|
|
fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
|
|
fail_unless (gst_value_get_double_range_max (&dest) == 20.0);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_DOUBLE_RANGE);
|
|
fail_unless (gst_value_get_double_range_min (&dest) == 30.0);
|
|
fail_unless (gst_value_get_double_range_max (&dest) == 40.0);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* completely overlapping ranges */
|
|
g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src1, 10.0, 20.0);
|
|
g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src2, 10.0, 30.0);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_DOUBLE_RANGE);
|
|
fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
|
|
fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* partially overlapping ranges */
|
|
g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src1, 10.0, 20.0);
|
|
g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src2, 15.0, 30.0);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_DOUBLE_RANGE);
|
|
fail_unless (gst_value_get_double_range_min (&dest) == 10.0);
|
|
fail_unless (gst_value_get_double_range_max (&dest) == 15.0);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_DOUBLE_RANGE);
|
|
fail_unless (gst_value_get_double_range_min (&dest) == 20.0);
|
|
fail_unless (gst_value_get_double_range_max (&dest) == 30.0);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* create a hole { double_range, double_range } */
|
|
g_value_init (&src1, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src1, 10.0, 30.0);
|
|
g_value_init (&src2, GST_TYPE_DOUBLE_RANGE);
|
|
gst_value_set_double_range (&src2, 15.0, 20.0);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_LIST);
|
|
tmp = gst_value_list_get_value (&dest, 0);
|
|
fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_double_range_min (tmp) == 10.0);
|
|
fail_unless (gst_value_get_double_range_max (tmp) == 15.0);
|
|
tmp = gst_value_list_get_value (&dest, 1);
|
|
fail_unless (GST_VALUE_HOLDS_DOUBLE_RANGE (tmp) == TRUE);
|
|
fail_unless (gst_value_get_double_range_min (tmp) == 20.0);
|
|
fail_unless (gst_value_get_double_range_max (tmp) == 30.0);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
/* Test arithmetic subtraction of fractions */
|
|
GST_START_TEST (test_value_subtract_fraction)
|
|
{
|
|
GValue result = { 0 };
|
|
GValue src1 = { 0 };
|
|
GValue src2 = { 0 };
|
|
|
|
/* Subtract 1/4 from 1/2 */
|
|
g_value_init (&src1, GST_TYPE_FRACTION);
|
|
g_value_init (&src2, GST_TYPE_FRACTION);
|
|
g_value_init (&result, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&src1, 1, 2);
|
|
gst_value_set_fraction (&src2, 1, 4);
|
|
fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
|
|
fail_unless (gst_value_get_fraction_numerator (&result) == 1);
|
|
fail_unless (gst_value_get_fraction_denominator (&result) == 4);
|
|
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
g_value_unset (&result);
|
|
|
|
/* Subtract 1/12 from 7/8 */
|
|
g_value_init (&src1, GST_TYPE_FRACTION);
|
|
g_value_init (&src2, GST_TYPE_FRACTION);
|
|
g_value_init (&result, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&src1, 7, 8);
|
|
gst_value_set_fraction (&src2, 1, 12);
|
|
fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
|
|
fail_unless (gst_value_get_fraction_numerator (&result) == 19);
|
|
fail_unless (gst_value_get_fraction_denominator (&result) == 24);
|
|
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
g_value_unset (&result);
|
|
|
|
/* Subtract 12/13 from 4/3 */
|
|
g_value_init (&src1, GST_TYPE_FRACTION);
|
|
g_value_init (&src2, GST_TYPE_FRACTION);
|
|
g_value_init (&result, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&src1, 4, 3);
|
|
gst_value_set_fraction (&src2, 12, 13);
|
|
fail_unless (gst_value_fraction_subtract (&result, &src1, &src2) == TRUE);
|
|
fail_unless (gst_value_get_fraction_numerator (&result) == 16);
|
|
fail_unless (gst_value_get_fraction_denominator (&result) == 39);
|
|
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
g_value_unset (&result);
|
|
|
|
/* Subtract 1/12 from 7/8 */
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
/* Test set subtraction operations on fraction ranges */
|
|
GST_START_TEST (test_value_subtract_fraction_range)
|
|
{
|
|
GValue dest = { 0 };
|
|
GValue src1 = { 0 };
|
|
GValue src2 = { 0 };
|
|
GValue cmp = { 0 };
|
|
const GValue *tmp;
|
|
gboolean ret;
|
|
|
|
/* Value for tests */
|
|
g_value_init (&cmp, GST_TYPE_FRACTION);
|
|
|
|
/* fraction <-> fraction
|
|
*/
|
|
g_value_init (&src1, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&src1, 10, 1);
|
|
g_value_init (&src2, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&src2, 20, 1);
|
|
gst_value_set_fraction (&src1, 10, 1);
|
|
|
|
/* subtract as in sets, result is 10 */
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
|
|
/* same values, yields empty set */
|
|
ret = gst_value_subtract (&dest, &src1, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* fraction <-> fraction_range
|
|
*/
|
|
|
|
/* would yield an empty set */
|
|
g_value_init (&src1, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&src1, 10, 1);
|
|
g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src2, 0, 1, 20, 1);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
|
|
/* and the other way around, we cannot create open ranges
|
|
* so the result is the range again */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction (&cmp, 0, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
gst_value_set_fraction (&cmp, 20, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* border case 1, empty set */
|
|
g_value_init (&src1, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&src1, 10, 1);
|
|
g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src2, 10, 1, 20, 1);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
|
|
/* and the other way around, should keep same range as
|
|
* we don't have open ranges. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction (&cmp, 10, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
gst_value_set_fraction (&cmp, 20, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* case 2, valid set */
|
|
g_value_init (&src1, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&src1, 0, 1);
|
|
g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src2, 10, 1, 20, 1);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION);
|
|
fail_unless (gst_value_compare (&dest, &src1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
|
|
/* and the other way around, should keep the range. */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
|
|
fail_unless (gst_value_compare (&dest, &src2) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* fraction_range <-> fraction_range
|
|
*/
|
|
|
|
/* same range, empty set */
|
|
g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src1, 10, 2, 20, 2);
|
|
g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src2, 10, 2, 20, 2);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* non overlapping ranges */
|
|
g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src1, 10, 2, 10, 1);
|
|
g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src2, 30, 2, 40, 2);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction (&cmp, 5, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
gst_value_set_fraction (&cmp, 10, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction (&cmp, 15, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
gst_value_set_fraction (&cmp, 20, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* completely overlapping ranges */
|
|
g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src1, 10, 1, 20, 1);
|
|
g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src2, 10, 1, 30, 1);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == FALSE);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction (&cmp, 20, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
gst_value_set_fraction (&cmp, 30, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* partially overlapping ranges */
|
|
g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src1, 10, 1, 20, 1);
|
|
g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src2, 15, 1, 30, 1);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction (&cmp, 10, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
gst_value_set_fraction (&cmp, 15, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction (&cmp, 20, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_min (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
gst_value_set_fraction (&cmp, 30, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_max (&dest),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
/* create a hole { double_range, double_range } */
|
|
g_value_init (&src1, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src1, 10, 1, 30, 1);
|
|
g_value_init (&src2, GST_TYPE_FRACTION_RANGE);
|
|
gst_value_set_fraction_range_full (&src2, 15, 1, 20, 1);
|
|
ret = gst_value_subtract (&dest, &src1, &src2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_LIST);
|
|
/* 1st list entry */
|
|
tmp = gst_value_list_get_value (&dest, 0);
|
|
fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (tmp) == TRUE);
|
|
gst_value_set_fraction (&cmp, 10, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_min (tmp),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
gst_value_set_fraction (&cmp, 15, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_max (tmp),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
/* 2nd list entry */
|
|
tmp = gst_value_list_get_value (&dest, 1);
|
|
fail_unless (GST_VALUE_HOLDS_FRACTION_RANGE (tmp) == TRUE);
|
|
gst_value_set_fraction (&cmp, 20, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_min (tmp),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
gst_value_set_fraction (&cmp, 30, 1);
|
|
fail_unless (gst_value_compare (gst_value_get_fraction_range_max (tmp),
|
|
&cmp) == GST_VALUE_EQUAL);
|
|
g_value_unset (&dest);
|
|
/* the other way */
|
|
ret = gst_value_subtract (&dest, &src2, &src1);
|
|
fail_unless (ret == FALSE);
|
|
g_value_unset (&src1);
|
|
g_value_unset (&src2);
|
|
|
|
g_value_unset (&cmp);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
/* Test set subtraction operations on fraction lists */
|
|
GST_START_TEST (test_value_subtract_fraction_list)
|
|
{
|
|
GValue list1 = { 0 };
|
|
GValue list2 = { 0 };
|
|
GValue val1 = { 0 };
|
|
GValue val2 = { 0 };
|
|
GValue tmp = { 0 };
|
|
gboolean ret;
|
|
|
|
g_value_init (&list1, GST_TYPE_LIST);
|
|
g_value_init (&val1, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&val1, 15, 2);
|
|
gst_value_list_append_value (&list1, &val1);
|
|
g_value_init (&tmp, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&tmp, 5, 1);
|
|
gst_value_list_append_value (&list1, &tmp);
|
|
g_value_unset (&tmp);
|
|
|
|
g_value_init (&list2, GST_TYPE_LIST);
|
|
g_value_init (&val2, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&val2, 15, 1);
|
|
gst_value_list_append_value (&list2, &val2);
|
|
g_value_init (&tmp, GST_TYPE_FRACTION);
|
|
gst_value_set_fraction (&tmp, 5, 1);
|
|
gst_value_list_append_value (&list2, &tmp);
|
|
g_value_unset (&tmp);
|
|
|
|
/* should subtract all common elements */
|
|
ret = gst_value_subtract (&tmp, &list1, &list2);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (gst_value_compare (&tmp, &val1) == GST_VALUE_EQUAL);
|
|
g_value_unset (&val1);
|
|
g_value_unset (&tmp);
|
|
|
|
ret = gst_value_subtract (&tmp, &list2, &list1);
|
|
fail_unless (ret == TRUE);
|
|
fail_unless (gst_value_compare (&tmp, &val2) == GST_VALUE_EQUAL);
|
|
g_value_unset (&val2);
|
|
g_value_unset (&tmp);
|
|
|
|
g_value_unset (&list1);
|
|
g_value_unset (&list2);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_date)
|
|
{
|
|
GstStructure *s;
|
|
GDate *date, *date2;
|
|
gchar *str;
|
|
|
|
date = g_date_new_dmy (22, 9, 2005);
|
|
|
|
s = gst_structure_new ("media/x-type", "SOME_DATE_TAG", G_TYPE_DATE,
|
|
date, NULL);
|
|
|
|
fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG", G_TYPE_DATE));
|
|
fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date2));
|
|
fail_unless (date2 != NULL);
|
|
fail_unless (g_date_valid (date2));
|
|
fail_unless (g_date_compare (date, date2) == 0);
|
|
|
|
g_date_free (date);
|
|
g_date_free (date2);
|
|
date = NULL;
|
|
date2 = NULL;
|
|
|
|
str = gst_structure_to_string (s);
|
|
gst_structure_free (s);
|
|
s = NULL;
|
|
|
|
fail_unless (g_str_equal (str,
|
|
"media/x-type, SOME_DATE_TAG=(date)2005-09-22;"));
|
|
|
|
s = gst_structure_from_string (str, NULL);
|
|
g_free (str);
|
|
str = NULL;
|
|
|
|
fail_unless (s != NULL);
|
|
fail_unless (gst_structure_has_name (s, "media/x-type"));
|
|
fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TAG", G_TYPE_DATE));
|
|
fail_unless (gst_structure_get_date (s, "SOME_DATE_TAG", &date));
|
|
fail_unless (date != NULL);
|
|
fail_unless (g_date_valid (date));
|
|
fail_unless (g_date_get_day (date) == 22);
|
|
fail_unless (g_date_get_month (date) == 9);
|
|
fail_unless (g_date_get_year (date) == 2005);
|
|
g_date_free (date);
|
|
date = NULL;
|
|
|
|
str = gst_structure_to_string (s);
|
|
gst_structure_free (s);
|
|
s = NULL;
|
|
|
|
fail_unless (g_str_equal (str,
|
|
"media/x-type, SOME_DATE_TAG=(date)2005-09-22;"));
|
|
g_free (str);
|
|
str = NULL;
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static gboolean
|
|
date_time_equal (GstDateTime * a, GstDateTime * b)
|
|
{
|
|
if (gst_date_time_get_year (a) != gst_date_time_get_year (b) ||
|
|
gst_date_time_get_month (a) != gst_date_time_get_month (b) ||
|
|
gst_date_time_get_day (a) != gst_date_time_get_day (b))
|
|
return FALSE;
|
|
|
|
if (gst_date_time_get_hour (a) != gst_date_time_get_hour (b) ||
|
|
gst_date_time_get_minute (a) != gst_date_time_get_minute (b) ||
|
|
gst_date_time_get_second (a) != gst_date_time_get_second (b) ||
|
|
gst_date_time_get_microsecond (a) != gst_date_time_get_microsecond (b))
|
|
return FALSE;
|
|
|
|
if (gst_date_time_get_time_zone_offset (a) !=
|
|
gst_date_time_get_time_zone_offset (b))
|
|
return FALSE;
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
GST_START_TEST (test_date_time)
|
|
{
|
|
GstStructure *s;
|
|
GstDateTime *datetime, *datetime2;
|
|
GValue val = { 0, };
|
|
gchar *str;
|
|
|
|
/* utc timezone */
|
|
datetime = gst_date_time_new (0, 2010, 6, 23, 7, 40, 10);
|
|
|
|
s = gst_structure_new ("media/x-type", "SOME_DATE_TIME_TAG",
|
|
GST_TYPE_DATE_TIME, datetime, NULL);
|
|
|
|
fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
|
|
GST_TYPE_DATE_TIME));
|
|
fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
|
|
&datetime2));
|
|
fail_unless (datetime2 != NULL);
|
|
fail_unless (date_time_equal (datetime, datetime2));
|
|
|
|
gst_date_time_unref (datetime);
|
|
gst_date_time_unref (datetime2);
|
|
datetime = NULL;
|
|
datetime2 = NULL;
|
|
|
|
str = gst_structure_to_string (s);
|
|
gst_structure_free (s);
|
|
s = NULL;
|
|
|
|
fail_unless_equals_string (str,
|
|
"media/x-type, SOME_DATE_TIME_TAG=(datetime)2010-06-23T07:40:10Z;");
|
|
|
|
s = gst_structure_from_string (str, NULL);
|
|
g_free (str);
|
|
str = NULL;
|
|
|
|
fail_unless (s != NULL);
|
|
fail_unless (gst_structure_has_name (s, "media/x-type"));
|
|
fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
|
|
GST_TYPE_DATE_TIME));
|
|
fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
|
|
&datetime));
|
|
fail_unless (datetime != NULL);
|
|
fail_unless (gst_date_time_get_year (datetime) == 2010);
|
|
fail_unless (gst_date_time_get_month (datetime) == 6);
|
|
fail_unless (gst_date_time_get_day (datetime) == 23);
|
|
fail_unless (gst_date_time_get_hour (datetime) == 7);
|
|
fail_unless (gst_date_time_get_minute (datetime) == 40);
|
|
fail_unless (gst_date_time_get_second (datetime) == 10);
|
|
fail_unless (gst_date_time_get_microsecond (datetime) == 0);
|
|
fail_unless (gst_date_time_get_time_zone_offset (datetime) == 0);
|
|
gst_date_time_unref (datetime);
|
|
datetime = NULL;
|
|
|
|
str = gst_structure_to_string (s);
|
|
gst_structure_free (s);
|
|
s = NULL;
|
|
|
|
fail_unless_equals_string (str,
|
|
"media/x-type, SOME_DATE_TIME_TAG=(datetime)2010-06-23T07:40:10Z;");
|
|
g_free (str);
|
|
str = NULL;
|
|
|
|
/* with timezone */
|
|
datetime = gst_date_time_new (-3.0, 2010, 6, 23, 7, 40, 10.000001);
|
|
|
|
s = gst_structure_new ("media/x-type", "SOME_DATE_TIME_TAG",
|
|
GST_TYPE_DATE_TIME, datetime, NULL);
|
|
|
|
fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
|
|
GST_TYPE_DATE_TIME));
|
|
fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
|
|
&datetime2));
|
|
fail_unless (datetime2 != NULL);
|
|
fail_unless (date_time_equal (datetime, datetime2));
|
|
|
|
gst_date_time_unref (datetime);
|
|
gst_date_time_unref (datetime2);
|
|
datetime = NULL;
|
|
datetime2 = NULL;
|
|
|
|
str = gst_structure_to_string (s);
|
|
gst_structure_free (s);
|
|
s = NULL;
|
|
|
|
fail_unless_equals_string (str,
|
|
"media/x-type, SOME_DATE_TIME_TAG=(datetime)2010-06-23T07:40:10.000001-0300;");
|
|
|
|
s = gst_structure_from_string (str, NULL);
|
|
g_free (str);
|
|
str = NULL;
|
|
|
|
fail_unless (s != NULL);
|
|
fail_unless (gst_structure_has_name (s, "media/x-type"));
|
|
fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
|
|
GST_TYPE_DATE_TIME));
|
|
fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
|
|
&datetime));
|
|
fail_unless (datetime != NULL);
|
|
fail_unless (gst_date_time_get_year (datetime) == 2010);
|
|
fail_unless (gst_date_time_get_month (datetime) == 6);
|
|
fail_unless (gst_date_time_get_day (datetime) == 23);
|
|
fail_unless (gst_date_time_get_hour (datetime) == 7);
|
|
fail_unless (gst_date_time_get_minute (datetime) == 40);
|
|
fail_unless (gst_date_time_get_second (datetime) == 10);
|
|
fail_unless (gst_date_time_get_microsecond (datetime) == 1);
|
|
fail_unless (gst_date_time_get_time_zone_offset (datetime) == -3);
|
|
gst_date_time_unref (datetime);
|
|
datetime = NULL;
|
|
|
|
str = gst_structure_to_string (s);
|
|
gst_structure_free (s);
|
|
s = NULL;
|
|
fail_unless_equals_string (str,
|
|
"media/x-type, SOME_DATE_TIME_TAG=(datetime)2010-06-23T07:40:10.000001-0300;");
|
|
|
|
g_free (str);
|
|
str = NULL;
|
|
|
|
/* with positive timezone */
|
|
datetime = gst_date_time_new (2.0, 2010, 6, 23, 7, 40, 10.000001);
|
|
|
|
s = gst_structure_new ("media/x-type", "SOME_DATE_TIME_TAG",
|
|
GST_TYPE_DATE_TIME, datetime, NULL);
|
|
|
|
fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
|
|
GST_TYPE_DATE_TIME));
|
|
fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
|
|
&datetime2));
|
|
fail_unless (datetime2 != NULL);
|
|
fail_unless (date_time_equal (datetime, datetime2));
|
|
|
|
gst_date_time_unref (datetime);
|
|
gst_date_time_unref (datetime2);
|
|
datetime = NULL;
|
|
datetime2 = NULL;
|
|
|
|
str = gst_structure_to_string (s);
|
|
gst_structure_free (s);
|
|
s = NULL;
|
|
|
|
fail_unless_equals_string (str,
|
|
"media/x-type, SOME_DATE_TIME_TAG=(datetime)2010-06-23T07:40:10.000001+0200;");
|
|
|
|
s = gst_structure_from_string (str, NULL);
|
|
g_free (str);
|
|
str = NULL;
|
|
|
|
fail_unless (s != NULL);
|
|
fail_unless (gst_structure_has_name (s, "media/x-type"));
|
|
fail_unless (gst_structure_has_field_typed (s, "SOME_DATE_TIME_TAG",
|
|
GST_TYPE_DATE_TIME));
|
|
fail_unless (gst_structure_get_date_time (s, "SOME_DATE_TIME_TAG",
|
|
&datetime));
|
|
fail_unless (datetime != NULL);
|
|
fail_unless (gst_date_time_get_year (datetime) == 2010);
|
|
fail_unless (gst_date_time_get_month (datetime) == 6);
|
|
fail_unless (gst_date_time_get_day (datetime) == 23);
|
|
fail_unless (gst_date_time_get_hour (datetime) == 7);
|
|
fail_unless (gst_date_time_get_minute (datetime) == 40);
|
|
fail_unless (gst_date_time_get_second (datetime) == 10);
|
|
fail_unless (gst_date_time_get_microsecond (datetime) == 1);
|
|
fail_unless (gst_date_time_get_time_zone_offset (datetime) == 2);
|
|
gst_date_time_unref (datetime);
|
|
datetime = NULL;
|
|
|
|
str = gst_structure_to_string (s);
|
|
gst_structure_free (s);
|
|
s = NULL;
|
|
fail_unless_equals_string (str,
|
|
"media/x-type, SOME_DATE_TIME_TAG=(datetime)2010-06-23T07:40:10.000001+0200;");
|
|
|
|
g_free (str);
|
|
str = NULL;
|
|
|
|
/* test partial dates */
|
|
datetime = gst_date_time_new (0.0, 2010, -1, -1, -1, -1, -1.0);
|
|
g_value_init (&val, GST_TYPE_DATE_TIME);
|
|
g_value_take_boxed (&val, datetime);
|
|
str = gst_value_serialize (&val);
|
|
g_value_reset (&val);
|
|
fail_unless_equals_string (str, "2010");
|
|
fail_unless (gst_value_deserialize (&val, str));
|
|
datetime = g_value_get_boxed (&val);
|
|
fail_if (!gst_date_time_has_year (datetime));
|
|
fail_if (gst_date_time_has_month (datetime));
|
|
fail_if (gst_date_time_has_day (datetime));
|
|
fail_if (gst_date_time_has_time (datetime));
|
|
g_value_unset (&val);
|
|
g_free (str);
|
|
|
|
datetime = gst_date_time_new (0.0, 2010, 9, -1, -1, -1, -1.0);
|
|
g_value_init (&val, GST_TYPE_DATE_TIME);
|
|
g_value_take_boxed (&val, datetime);
|
|
str = gst_value_serialize (&val);
|
|
g_value_reset (&val);
|
|
fail_unless_equals_string (str, "2010-09");
|
|
fail_unless (gst_value_deserialize (&val, str));
|
|
datetime = g_value_get_boxed (&val);
|
|
fail_if (!gst_date_time_has_year (datetime));
|
|
fail_if (!gst_date_time_has_month (datetime));
|
|
fail_if (gst_date_time_has_day (datetime));
|
|
fail_if (gst_date_time_has_time (datetime));
|
|
g_value_unset (&val);
|
|
g_free (str);
|
|
|
|
datetime = gst_date_time_new (0.0, 1983, 11, 30, -1, -1, -1.0);
|
|
g_value_init (&val, GST_TYPE_DATE_TIME);
|
|
g_value_take_boxed (&val, datetime);
|
|
str = gst_value_serialize (&val);
|
|
g_value_reset (&val);
|
|
fail_unless_equals_string (str, "1983-11-30");
|
|
fail_unless (gst_value_deserialize (&val, str));
|
|
datetime = g_value_get_boxed (&val);
|
|
fail_if (!gst_date_time_has_year (datetime));
|
|
fail_if (!gst_date_time_has_month (datetime));
|
|
fail_if (!gst_date_time_has_day (datetime));
|
|
fail_if (gst_date_time_has_time (datetime));
|
|
g_value_unset (&val);
|
|
g_free (str);
|
|
|
|
datetime = gst_date_time_new (0.0, 1983, 11, 30, 3, 52, -1.0);
|
|
g_value_init (&val, GST_TYPE_DATE_TIME);
|
|
g_value_take_boxed (&val, datetime);
|
|
str = gst_value_serialize (&val);
|
|
g_value_reset (&val);
|
|
fail_unless_equals_string (str, "1983-11-30T03:52Z");
|
|
fail_unless (gst_value_deserialize (&val, str));
|
|
datetime = g_value_get_boxed (&val);
|
|
fail_if (!gst_date_time_has_year (datetime));
|
|
fail_if (!gst_date_time_has_month (datetime));
|
|
fail_if (!gst_date_time_has_day (datetime));
|
|
fail_if (!gst_date_time_has_time (datetime));
|
|
fail_if (gst_date_time_has_second (datetime));
|
|
fail_unless_equals_float (gst_date_time_get_time_zone_offset (datetime), 0.0);
|
|
g_value_unset (&val);
|
|
g_free (str);
|
|
|
|
datetime = gst_date_time_new (-4.5, 1983, 11, 30, 3, 52, -1.0);
|
|
g_value_init (&val, GST_TYPE_DATE_TIME);
|
|
g_value_take_boxed (&val, datetime);
|
|
str = gst_value_serialize (&val);
|
|
g_value_reset (&val);
|
|
fail_unless_equals_string (str, "1983-11-30T03:52-0430");
|
|
fail_unless (gst_value_deserialize (&val, str));
|
|
datetime = g_value_get_boxed (&val);
|
|
fail_if (!gst_date_time_has_year (datetime));
|
|
fail_if (!gst_date_time_has_month (datetime));
|
|
fail_if (!gst_date_time_has_day (datetime));
|
|
fail_if (!gst_date_time_has_time (datetime));
|
|
fail_if (gst_date_time_has_second (datetime));
|
|
fail_unless_equals_float (gst_date_time_get_time_zone_offset (datetime),
|
|
-4.5);
|
|
g_value_unset (&val);
|
|
g_free (str);
|
|
|
|
datetime = gst_date_time_new (4.5, 1983, 11, 30, 14, 52, 9);
|
|
g_value_init (&val, GST_TYPE_DATE_TIME);
|
|
g_value_take_boxed (&val, datetime);
|
|
str = gst_value_serialize (&val);
|
|
g_value_reset (&val);
|
|
fail_unless_equals_string (str, "1983-11-30T14:52:09+0430");
|
|
fail_unless (gst_value_deserialize (&val, str));
|
|
datetime = g_value_get_boxed (&val);
|
|
fail_if (!gst_date_time_has_year (datetime));
|
|
fail_if (!gst_date_time_has_month (datetime));
|
|
fail_if (!gst_date_time_has_day (datetime));
|
|
fail_if (!gst_date_time_has_time (datetime));
|
|
fail_if (!gst_date_time_has_second (datetime));
|
|
fail_unless_equals_float (gst_date_time_get_time_zone_offset (datetime), 4.5);
|
|
g_value_unset (&val);
|
|
g_free (str);
|
|
|
|
datetime = gst_date_time_new (-4.5, 1983, 11, 30, 14, 52, 9.702);
|
|
g_value_init (&val, GST_TYPE_DATE_TIME);
|
|
g_value_take_boxed (&val, datetime);
|
|
str = gst_value_serialize (&val);
|
|
g_value_reset (&val);
|
|
fail_unless_equals_string (str, "1983-11-30T14:52:09.702-0430");
|
|
fail_unless (gst_value_deserialize (&val, str));
|
|
datetime = g_value_get_boxed (&val);
|
|
fail_if (!gst_date_time_has_year (datetime));
|
|
fail_if (!gst_date_time_has_month (datetime));
|
|
fail_if (!gst_date_time_has_day (datetime));
|
|
fail_if (!gst_date_time_has_time (datetime));
|
|
fail_if (!gst_date_time_has_second (datetime));
|
|
fail_unless_equals_float (gst_date_time_get_time_zone_offset (datetime),
|
|
-4.5);
|
|
g_value_unset (&val);
|
|
g_free (str);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_fraction_range)
|
|
{
|
|
GValue range = { 0, };
|
|
GValue start = { 0, };
|
|
GValue end = { 0, };
|
|
GValue src = { 0, };
|
|
GValue dest = { 0, };
|
|
GValue range2 = { 0, };
|
|
|
|
g_value_init (&range, GST_TYPE_FRACTION_RANGE);
|
|
g_value_init (&range2, GST_TYPE_FRACTION_RANGE);
|
|
g_value_init (&start, GST_TYPE_FRACTION);
|
|
g_value_init (&end, GST_TYPE_FRACTION);
|
|
g_value_init (&src, GST_TYPE_FRACTION);
|
|
|
|
gst_value_set_fraction (&src, 1, 2);
|
|
|
|
/* Check that a intersection of fraction & range = fraction */
|
|
gst_value_set_fraction (&start, 1, 4);
|
|
gst_value_set_fraction (&end, 2, 3);
|
|
gst_value_set_fraction_range (&range, &start, &end);
|
|
|
|
fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION);
|
|
fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
|
|
|
|
/* Check that a intersection selects the overlapping range */
|
|
gst_value_set_fraction (&start, 1, 3);
|
|
gst_value_set_fraction (&end, 2, 3);
|
|
gst_value_set_fraction_range (&range2, &start, &end);
|
|
g_value_unset (&dest);
|
|
fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_FRACTION_RANGE);
|
|
|
|
gst_value_set_fraction_range (&range2, &start, &end);
|
|
fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
|
|
|
|
/* Check that non intersection ranges don't intersect */
|
|
gst_value_set_fraction (&start, 4, 2);
|
|
gst_value_set_fraction (&end, 5, 2);
|
|
gst_value_set_fraction_range (&range2, &start, &end);
|
|
g_value_unset (&dest);
|
|
fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
|
|
|
|
g_value_unset (&start);
|
|
g_value_unset (&end);
|
|
g_value_unset (&range);
|
|
g_value_unset (&range2);
|
|
g_value_unset (&src);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_serialize_deserialize_format_enum)
|
|
{
|
|
GstStructure *s, *s2;
|
|
GstFormat foobar_fmt;
|
|
gchar *str, *str2, *end = NULL;
|
|
|
|
/* make sure custom formats are serialised properly as well */
|
|
foobar_fmt = gst_format_register ("foobar", "GST_FORMAT_FOOBAR");
|
|
fail_unless (foobar_fmt != GST_FORMAT_UNDEFINED);
|
|
|
|
s = gst_structure_new ("foo/bar", "format1", GST_TYPE_FORMAT,
|
|
GST_FORMAT_BYTES, "format2", GST_TYPE_FORMAT, GST_FORMAT_TIME,
|
|
"format3", GST_TYPE_FORMAT, GST_FORMAT_DEFAULT, "format4",
|
|
GST_TYPE_FORMAT, foobar_fmt, NULL);
|
|
|
|
str = gst_structure_to_string (s);
|
|
GST_LOG ("Got structure string '%s'", GST_STR_NULL (str));
|
|
fail_unless (str != NULL);
|
|
fail_unless (strstr (str, "time") != NULL);
|
|
fail_unless (strstr (str, "byte") != NULL);
|
|
fail_unless (strstr (str, "default") != NULL);
|
|
fail_unless (strstr (str, "FOOBAR") != NULL);
|
|
|
|
s2 = gst_structure_from_string (str, &end);
|
|
fail_unless (s2 != NULL);
|
|
|
|
str2 = gst_structure_to_string (s2);
|
|
fail_unless (str2 != NULL);
|
|
|
|
fail_unless (g_str_equal (str, str2));
|
|
|
|
g_free (str);
|
|
g_free (str2);
|
|
gst_structure_free (s);
|
|
gst_structure_free (s2);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_serialize_deserialize_value_array)
|
|
{
|
|
GValue v = G_VALUE_INIT, v2 = G_VALUE_INIT, v3 = G_VALUE_INIT;
|
|
gchar *str = NULL;
|
|
|
|
g_value_init (&v, GST_TYPE_ARRAY);
|
|
g_value_init (&v2, GST_TYPE_ARRAY);
|
|
g_value_init (&v3, G_TYPE_DOUBLE);
|
|
g_value_set_double (&v3, 1);
|
|
gst_value_array_append_value (&v2, &v3);
|
|
g_value_unset (&v3);
|
|
g_value_init (&v3, G_TYPE_DOUBLE);
|
|
g_value_set_double (&v3, 0);
|
|
gst_value_array_append_value (&v2, &v3);
|
|
g_value_unset (&v3);
|
|
gst_value_array_append_value (&v, &v2);
|
|
g_value_unset (&v2);
|
|
|
|
str = gst_value_serialize (&v);
|
|
|
|
g_value_init (&v2, GST_TYPE_ARRAY);
|
|
fail_unless (gst_value_deserialize (&v2, str));
|
|
fail_unless (gst_value_compare (&v, &v2) == 0);
|
|
|
|
g_value_unset (&v2);
|
|
g_value_unset (&v);
|
|
g_free (str);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_compare_caps)
|
|
{
|
|
GValue value = { 0 }
|
|
, value2 = {
|
|
0};
|
|
|
|
g_value_init (&value, GST_TYPE_CAPS);
|
|
g_value_init (&value2, GST_TYPE_CAPS);
|
|
g_value_take_boxed (&value, NULL);
|
|
g_value_take_boxed (&value2, NULL);
|
|
|
|
fail_unless_equals_int (gst_value_compare (&value, &value2), GST_VALUE_EQUAL);
|
|
|
|
g_value_take_boxed (&value, gst_caps_new_empty_simple ("something"));
|
|
|
|
fail_unless_equals_int (gst_value_compare (&value, &value2),
|
|
GST_VALUE_UNORDERED);
|
|
|
|
g_value_unset (&value);
|
|
g_value_unset (&value2);
|
|
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static void
|
|
_test_serialize_deserialize_boxed_in_structure (const gpointer boxed_value,
|
|
GType type)
|
|
{
|
|
GValue value = G_VALUE_INIT, str_val = G_VALUE_INIT;
|
|
const GValue *value_after;
|
|
GstStructure *s, *s2;
|
|
const gchar *first_str_val = "first \" string", *second_str_val =
|
|
"second \" string";
|
|
gchar *str, *str2, *end;
|
|
|
|
g_value_init (&value, type);
|
|
g_value_init (&str_val, G_TYPE_STRING);
|
|
g_value_set_boxed (&value, boxed_value);
|
|
|
|
s = gst_structure_new_empty ("test-struct");
|
|
g_value_set_string (&str_val, first_str_val);
|
|
gst_structure_set_value (s, "first", &str_val);
|
|
gst_structure_set_value (s, "test-value", &value);
|
|
g_value_set_string (&str_val, second_str_val);
|
|
gst_structure_set_value (s, "second", &str_val);
|
|
|
|
/* serialize the values in the structure */
|
|
str = gst_structure_to_string (s);
|
|
fail_unless (str != NULL);
|
|
GST_DEBUG ("Got structure string '%s'", str);
|
|
|
|
/* recreate the structure */
|
|
s2 = gst_structure_from_string (str, &end);
|
|
fail_unless (s2 != NULL);
|
|
fail_unless (end[0] == '\0');
|
|
|
|
/* make sure the new structure serializes to the same string */
|
|
str2 = gst_structure_to_string (s2);
|
|
fail_unless_equals_string (str, str2);
|
|
|
|
/* test for equality if values can be compared */
|
|
value_after = gst_structure_get_value (s2, "test-value");
|
|
fail_unless (value_after != NULL);
|
|
fail_unless (G_VALUE_TYPE (value_after) == G_VALUE_TYPE (&value));
|
|
if (gst_value_can_compare (&value, value_after))
|
|
fail_unless (gst_value_compare (&value, value_after) == GST_VALUE_EQUAL);
|
|
|
|
/* test to make sure that the string values are still present, and
|
|
* haven't been gobbled by the value serialization */
|
|
fail_unless_equals_string (gst_structure_get_string (s2, "first"),
|
|
first_str_val);
|
|
fail_unless_equals_string (gst_structure_get_string (s2, "second"),
|
|
second_str_val);
|
|
|
|
/* cleanup */
|
|
gst_structure_free (s);
|
|
gst_structure_free (s2);
|
|
g_free (str);
|
|
g_free (str2);
|
|
g_value_unset (&value);
|
|
g_value_unset (&str_val);
|
|
}
|
|
|
|
GST_START_TEST (test_serialize_deserialize_caps)
|
|
{
|
|
GValue value = G_VALUE_INIT, value2 = G_VALUE_INIT;
|
|
GstCaps *incaps = gst_caps_new_simple ("caps/internal",
|
|
"in-field", G_TYPE_INT, 20, "in-field2",
|
|
G_TYPE_STRING, "some in ternal field", NULL);
|
|
GstCaps *test_caps[] = {
|
|
gst_caps_new_simple ("test/caps",
|
|
"foo", G_TYPE_INT, 10, "bar", G_TYPE_STRING, "test",
|
|
"int-caps", GST_TYPE_CAPS, incaps, NULL),
|
|
gst_caps_new_any (),
|
|
gst_caps_new_empty ()
|
|
};
|
|
GstCaps *caps, *caps2;
|
|
gchar *serialized;
|
|
gint i;
|
|
|
|
gst_caps_unref (incaps);
|
|
g_value_init (&value, GST_TYPE_CAPS);
|
|
g_value_init (&value2, GST_TYPE_CAPS);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (test_caps); i++) {
|
|
caps = test_caps[i];
|
|
fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
|
|
|
|
/* and assign caps to gvalue */
|
|
g_value_take_boxed (&value, caps);
|
|
fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
|
|
|
|
/* now serialize it */
|
|
serialized = gst_value_serialize (&value);
|
|
GST_DEBUG ("serialized caps to %s", serialized);
|
|
fail_unless (serialized != NULL);
|
|
|
|
/* refcount should not change */
|
|
fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
|
|
|
|
/* now deserialize again */
|
|
fail_unless (gst_value_deserialize (&value2, serialized));
|
|
|
|
caps2 = g_value_get_boxed (&value2);
|
|
fail_if (GST_CAPS_REFCOUNT_VALUE (caps2) != 1);
|
|
|
|
/* they should be equal */
|
|
fail_unless (gst_caps_is_equal (caps, caps2));
|
|
fail_unless (gst_caps_is_any (caps) == gst_caps_is_any (caps2));
|
|
|
|
_test_serialize_deserialize_boxed_in_structure (caps, GST_TYPE_CAPS);
|
|
/* cleanup */
|
|
g_free (serialized);
|
|
}
|
|
g_value_unset (&value);
|
|
g_value_unset (&value2);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_int_range)
|
|
{
|
|
GValue range = { 0, };
|
|
GValue start = { 0, };
|
|
GValue end = { 0, };
|
|
GValue src = { 0, };
|
|
GValue dest = { 0, };
|
|
GValue range2 = { 0, };
|
|
|
|
g_value_init (&range, GST_TYPE_INT_RANGE);
|
|
g_value_init (&range2, GST_TYPE_INT_RANGE);
|
|
g_value_init (&start, G_TYPE_INT);
|
|
g_value_init (&end, G_TYPE_INT);
|
|
g_value_init (&src, G_TYPE_INT);
|
|
|
|
g_value_set_int (&src, 2);
|
|
|
|
/* Check that a intersection of int & range = int */
|
|
gst_value_set_int_range (&range, 1, 5);
|
|
|
|
fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == G_TYPE_INT);
|
|
fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
|
|
|
|
/* Check that a intersection selects the overlapping range */
|
|
gst_value_set_int_range (&range2, 2, 3);
|
|
g_value_unset (&dest);
|
|
fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT_RANGE);
|
|
|
|
fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
|
|
|
|
/* Check that non intersection ranges don't intersect */
|
|
gst_value_set_int_range (&range2, 6, 7);
|
|
g_value_unset (&dest);
|
|
fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
|
|
|
|
gst_value_set_int_range (&range, -7, -6);
|
|
fail_unless_equals_int (gst_value_get_int_range_min (&range), -7);
|
|
fail_unless_equals_int (gst_value_get_int_range_max (&range), -6);
|
|
gst_value_set_int_range (&range, -7, 7);
|
|
fail_unless_equals_int (gst_value_get_int_range_min (&range), -7);
|
|
fail_unless_equals_int (gst_value_get_int_range_max (&range), 7);
|
|
|
|
g_value_unset (&start);
|
|
g_value_unset (&end);
|
|
g_value_unset (&range);
|
|
g_value_unset (&range2);
|
|
g_value_unset (&src);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_int64_range)
|
|
{
|
|
GValue range = { 0, };
|
|
GValue start = { 0, };
|
|
GValue end = { 0, };
|
|
GValue src = { 0, };
|
|
GValue dest = { 0, };
|
|
GValue range2 = { 0, };
|
|
|
|
g_value_init (&range, GST_TYPE_INT64_RANGE);
|
|
g_value_init (&range2, GST_TYPE_INT64_RANGE);
|
|
g_value_init (&start, G_TYPE_INT64);
|
|
g_value_init (&end, G_TYPE_INT64);
|
|
g_value_init (&src, G_TYPE_INT64);
|
|
|
|
g_value_set_int64 (&src, 2);
|
|
|
|
/* Check that a intersection of int64 & range = int64 */
|
|
gst_value_set_int64_range (&range, 1, 5);
|
|
|
|
fail_unless (gst_value_intersect (&dest, &src, &range) == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == G_TYPE_INT64);
|
|
fail_unless (gst_value_compare (&dest, &src) == GST_VALUE_EQUAL);
|
|
|
|
/* Check that a intersection selects the overlapping range */
|
|
gst_value_set_int64_range (&range2, 2, 3);
|
|
g_value_unset (&dest);
|
|
fail_unless (gst_value_intersect (&dest, &range, &range2) == TRUE);
|
|
fail_unless (G_VALUE_TYPE (&dest) == GST_TYPE_INT64_RANGE);
|
|
|
|
fail_unless (gst_value_compare (&dest, &range2) == GST_VALUE_EQUAL);
|
|
|
|
/* Check that non intersection ranges don't intersect */
|
|
gst_value_set_int64_range (&range2, 6, 7);
|
|
g_value_unset (&dest);
|
|
fail_unless (gst_value_intersect (&dest, &range, &range2) == FALSE);
|
|
|
|
g_value_unset (&start);
|
|
g_value_unset (&end);
|
|
g_value_unset (&range);
|
|
g_value_unset (&range2);
|
|
g_value_unset (&src);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_serialize_int64_range)
|
|
{
|
|
int i = 0;
|
|
|
|
gint64 int64_ranges[] = {
|
|
0, 5,
|
|
0, G_MAXINT,
|
|
5, G_MAXINT32,
|
|
5, G_MAXINT64,
|
|
};
|
|
gint int64_ranges_size = sizeof (int64_ranges) / sizeof (int64_ranges[0]) / 2;
|
|
|
|
gchar *int64_range_strings[] = {
|
|
g_strdup ("[ 0, 5 ]"),
|
|
g_strdup_printf ("[ 0, %" G_GINT64_FORMAT " ]", (gint64) G_MAXINT),
|
|
g_strdup_printf ("[ 5, %" G_GINT64_FORMAT " ]", (gint64) G_MAXINT32),
|
|
g_strdup_printf ("[ 5, %" G_GINT64_FORMAT " ]", G_MAXINT64),
|
|
};
|
|
gint int64_range_strings_size =
|
|
sizeof (int64_range_strings) / sizeof (int64_range_strings[0]);
|
|
|
|
fail_unless (int64_ranges_size == int64_range_strings_size);
|
|
|
|
while (i + 1 < (int64_ranges_size * 2)) {
|
|
if ((i + 1) % 2) {
|
|
gchar *str;
|
|
gchar *str2;
|
|
GValue value = { 0 };
|
|
const GValue *deserialized_value;
|
|
int idx = i / 2;
|
|
GstStructure *s;
|
|
|
|
g_value_init (&value, GST_TYPE_INT64_RANGE);
|
|
|
|
/* check serialization */
|
|
gst_value_set_int64_range (&value, int64_ranges[i], int64_ranges[i + 1]);
|
|
str = gst_value_serialize (&value);
|
|
fail_unless (strcmp (str, int64_range_strings[idx]) == 0);
|
|
g_free (int64_range_strings[idx]);
|
|
g_value_unset (&value);
|
|
|
|
/* now deserialize again to an int64 range */
|
|
s = gst_structure_new ("foo/bar", "range", GST_TYPE_INT64_RANGE,
|
|
int64_ranges[i], int64_ranges[i + 1], NULL);
|
|
deserialized_value = gst_structure_get_value (s, "range");
|
|
fail_unless (GST_VALUE_HOLDS_INT64_RANGE (deserialized_value) == TRUE);
|
|
str2 = gst_value_serialize (deserialized_value);
|
|
|
|
fail_unless (gst_value_get_int64_range_min (deserialized_value) ==
|
|
int64_ranges[i]);
|
|
fail_unless (gst_value_get_int64_range_max (deserialized_value) ==
|
|
int64_ranges[i + 1]);
|
|
|
|
gst_structure_free (s);
|
|
g_free (str);
|
|
g_free (str2);
|
|
}
|
|
i++;
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_int_range)
|
|
{
|
|
GstStructure *s;
|
|
gchar *str, *str2;
|
|
gchar *end = NULL;
|
|
const GValue *deserialized_value;
|
|
|
|
/* check a valid int_range deserialization */
|
|
str = g_strdup_printf ("foo/bar, range=[ 1, %d ];", G_MAXINT);
|
|
s = gst_structure_from_string (str, &end);
|
|
fail_unless (*end == '\0');
|
|
deserialized_value = gst_structure_get_value (s, "range");
|
|
fail_unless (GST_VALUE_HOLDS_INT_RANGE (deserialized_value) == TRUE);
|
|
fail_unless (gst_value_get_int_range_min (deserialized_value) == 1);
|
|
fail_unless (gst_value_get_int_range_max (deserialized_value) == G_MAXINT);
|
|
gst_structure_free (s);
|
|
end = NULL;
|
|
g_free (str);
|
|
|
|
/* check invalid int_range deserialization */
|
|
str =
|
|
g_strdup_printf ("foo/bar, range=[ 1, %" G_GINT64_FORMAT " ];",
|
|
(gint64) G_MAXINT + 1);
|
|
s = NULL;
|
|
ASSERT_CRITICAL (s = gst_structure_from_string (str, &end));
|
|
g_free (str);
|
|
if (s)
|
|
gst_structure_free (s);
|
|
str =
|
|
g_strdup_printf ("foo/bar, range=[ %" G_GINT64_FORMAT ", %"
|
|
G_GINT64_FORMAT " ];", (gint64) G_MAXINT, (gint64) G_MAXINT + 1);
|
|
ASSERT_CRITICAL (s = gst_structure_from_string (str, NULL));
|
|
end = NULL;
|
|
g_free (str);
|
|
if (s)
|
|
gst_structure_free (s);
|
|
|
|
/* check a valid int64_range deserialization. Those ranges need to
|
|
* be explicit about their storage type. */
|
|
str = g_strdup_printf ("foo/bar, range=(gint64)[ 1, %d ];", G_MAXINT);
|
|
s = gst_structure_from_string (str, &end);
|
|
fail_unless (*end == '\0');
|
|
deserialized_value = gst_structure_get_value (s, "range");
|
|
fail_unless (GST_VALUE_HOLDS_INT64_RANGE (deserialized_value) == TRUE);
|
|
fail_unless (gst_value_get_int64_range_min (deserialized_value) == 1);
|
|
fail_unless (gst_value_get_int64_range_max (deserialized_value) == G_MAXINT);
|
|
str2 = gst_structure_to_string (s);
|
|
fail_unless (strcmp (str, str2) == 0);
|
|
gst_structure_free (s);
|
|
end = NULL;
|
|
g_free (str);
|
|
g_free (str2);
|
|
|
|
/* check invalid int64_range (starting with a gint) deserialization */
|
|
str =
|
|
g_strdup_printf ("foo/bar, range=(gint64)[ 1, %" G_GUINT64_FORMAT " ];",
|
|
(guint64) G_MAXINT64 + 1);
|
|
s = NULL;
|
|
ASSERT_CRITICAL (s = gst_structure_from_string (str, &end));
|
|
if (s) {
|
|
fail_unless (*end == '\0');
|
|
gst_structure_free (s);
|
|
end = NULL;
|
|
}
|
|
g_free (str);
|
|
|
|
/* check invalid int64_range deserialization into a int64_range */
|
|
str =
|
|
g_strdup_printf ("foo/bar, range=(gint64)[ %" G_GINT64_FORMAT ", %"
|
|
G_GUINT64_FORMAT " ];", (gint64) G_MAXINT, (guint64) G_MAXINT64 + 1);
|
|
ASSERT_CRITICAL (s = gst_structure_from_string (str, NULL));
|
|
g_free (str);
|
|
if (s)
|
|
gst_structure_free (s);
|
|
|
|
/* check invalid int64_range deserialization into a int_range */
|
|
str =
|
|
g_strdup_printf ("foo/bar, range=[ %" G_GINT64_FORMAT ", %"
|
|
G_GUINT64_FORMAT " ];", (gint64) G_MAXINT, (guint64) G_MAXINT64 + 1);
|
|
s = gst_structure_from_string (str, &end);
|
|
fail_unless (s == NULL);
|
|
fail_unless (end == NULL);
|
|
g_free (str);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_stepped_range_collection)
|
|
{
|
|
GstStructure *s;
|
|
const GValue *v;
|
|
|
|
s = gst_structure_new ("foo/bar", "range", GST_TYPE_INT_RANGE, 8, 12, NULL);
|
|
fail_unless (s != NULL);
|
|
v = gst_structure_get_value (s, "range");
|
|
fail_unless (v != NULL);
|
|
fail_unless (gst_value_get_int_range_min (v) == 8);
|
|
fail_unless (gst_value_get_int_range_max (v) == 12);
|
|
fail_unless (gst_value_get_int_range_step (v) == 1);
|
|
gst_structure_free (s);
|
|
|
|
s = gst_structure_new ("foo/bar", "range", GST_TYPE_INT64_RANGE, (gint64) 8,
|
|
(gint64) 12, NULL);
|
|
fail_unless (s != NULL);
|
|
v = gst_structure_get_value (s, "range");
|
|
fail_unless (v != NULL);
|
|
fail_unless (gst_value_get_int64_range_min (v) == 8);
|
|
fail_unless (gst_value_get_int64_range_max (v) == 12);
|
|
fail_unless (gst_value_get_int64_range_step (v) == 1);
|
|
gst_structure_free (s);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_stepped_int_range_parsing)
|
|
{
|
|
gchar *str;
|
|
guint n;
|
|
gchar *end = NULL;
|
|
GstStructure *s;
|
|
|
|
static const gchar *good_ranges[] = {
|
|
"[0, 1, 1]",
|
|
"[-2, 2, 2]",
|
|
"[16, 4096, 16]",
|
|
};
|
|
|
|
static const gchar *bad_ranges[] = {
|
|
"[0, 1, -1]",
|
|
"[1, 2, 2]",
|
|
"[2, 3, 2]",
|
|
"[0, 0, 0]",
|
|
"[0, 0, 1]",
|
|
"[1, 2, 0]",
|
|
"[1, 1, 1]",
|
|
};
|
|
|
|
/* check we can parse good ranges */
|
|
for (n = 0; n < G_N_ELEMENTS (good_ranges); ++n) {
|
|
str = g_strdup_printf ("foo/bar, range=%s", good_ranges[n]);
|
|
s = gst_structure_from_string (str, &end);
|
|
fail_unless (s != NULL);
|
|
fail_unless (*end == '\0');
|
|
gst_structure_free (s);
|
|
s = NULL;
|
|
g_free (str);
|
|
}
|
|
|
|
/* check we cannot parse bad ranges */
|
|
for (n = 0; n < G_N_ELEMENTS (bad_ranges); ++n) {
|
|
str = g_strdup_printf ("foo/bar, range=%s", bad_ranges[n]);
|
|
ASSERT_CRITICAL (s = gst_structure_from_string (str, &end));
|
|
if (s)
|
|
gst_structure_free (s);
|
|
g_free (str);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_stepped_int_range_ops)
|
|
{
|
|
gchar *str1, *str2, *str3;
|
|
guint n;
|
|
GstStructure *s1, *s2, *s3;
|
|
const GValue *v1, *v2, *v3;
|
|
|
|
static const struct
|
|
{
|
|
const gchar *set1;
|
|
const gchar *op;
|
|
const gchar *set2;
|
|
const gchar *result;
|
|
} ranges[] = {
|
|
{
|
|
"[16, 4096, 16]", "inter", "[100, 200, 10]", "160"}, {
|
|
"[16, 4096, 16]", "inter", "[100, 200, 100]", NULL}, {
|
|
"[16, 4096, 16]", "inter", "[0, 512, 256]", "[256, 512, 256]"}, {
|
|
"[16, 32, 16]", "union", "[32, 96, 16]", "[16, 96, 16]"}, {
|
|
"[16, 32, 16]", "union", "[48, 96, 16]", "[16, 96, 16]"}, {
|
|
"[112, 192, 16]", "union", "[48, 96, 16]", "[48, 192, 16]"}, {
|
|
"[16, 32, 16]", "union", "[64, 96, 16]", NULL}, {
|
|
"[112, 192, 16]", "union", "[48, 96, 8]", NULL}, {
|
|
"[10, 20, 5]", "union", "10", "[10, 20, 5]"}, {
|
|
"[10, 20, 5]", "union", "20", "[10, 20, 5]"}, {
|
|
"[10, 20, 5]", "union", "15", "[10, 20, 5]"}, {
|
|
"[10, 20, 5]", "union", "5", "[5, 20, 5]"}, {
|
|
"[10, 20, 5]", "union", "12", NULL}, {
|
|
"[10, 20, 5]", "union", "30", NULL}, {
|
|
"[10, 20, 5]", "union", "25", "[10, 25, 5]"},};
|
|
|
|
for (n = 0; n < G_N_ELEMENTS (ranges); ++n) {
|
|
gchar *end = NULL;
|
|
GValue dest = { 0 };
|
|
gboolean ret;
|
|
|
|
str1 = g_strdup_printf ("foo/bar, range=%s", ranges[n].set1);
|
|
s1 = gst_structure_from_string (str1, &end);
|
|
fail_unless (s1 != NULL);
|
|
fail_unless (*end == '\0');
|
|
v1 = gst_structure_get_value (s1, "range");
|
|
fail_unless (v1 != NULL);
|
|
|
|
str2 = g_strdup_printf ("foo/bar, range=%s", ranges[n].set2);
|
|
s2 = gst_structure_from_string (str2, &end);
|
|
fail_unless (s2 != NULL);
|
|
fail_unless (*end == '\0');
|
|
v2 = gst_structure_get_value (s2, "range");
|
|
fail_unless (v2 != NULL);
|
|
|
|
if (!strcmp (ranges[n].op, "inter")) {
|
|
ret = gst_value_intersect (&dest, v1, v2);
|
|
} else if (!strcmp (ranges[n].op, "union")) {
|
|
ret = gst_value_union (&dest, v1, v2);
|
|
} else {
|
|
fail_unless (FALSE);
|
|
ret = FALSE;
|
|
}
|
|
|
|
if (ranges[n].result) {
|
|
fail_unless (ret);
|
|
} else {
|
|
fail_unless (!ret);
|
|
}
|
|
|
|
if (ret) {
|
|
str3 = g_strdup_printf ("foo/bar, range=%s", ranges[n].result);
|
|
s3 = gst_structure_from_string (str3, &end);
|
|
fail_unless (s3 != NULL);
|
|
fail_unless (*end == '\0');
|
|
v3 = gst_structure_get_value (s3, "range");
|
|
fail_unless (v3 != NULL);
|
|
|
|
if (gst_value_compare (&dest, v3) != GST_VALUE_EQUAL) {
|
|
GST_ERROR ("%s %s %s yielded %s, expected %s", str1, ranges[n].op, str2,
|
|
gst_value_serialize (&dest), gst_value_serialize (v3));
|
|
fail_unless (FALSE);
|
|
}
|
|
|
|
gst_structure_free (s3);
|
|
g_free (str3);
|
|
|
|
g_value_unset (&dest);
|
|
}
|
|
|
|
gst_structure_free (s2);
|
|
g_free (str2);
|
|
gst_structure_free (s1);
|
|
g_free (str1);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_structure_basic)
|
|
{
|
|
GstStructure *s1, *s2;
|
|
GValue v1 = G_VALUE_INIT, v2 = G_VALUE_INIT;
|
|
|
|
/* sanity test */
|
|
s1 = gst_structure_from_string ("foo,bar=1", NULL);
|
|
g_value_init (&v1, GST_TYPE_STRUCTURE);
|
|
gst_value_set_structure (&v1, s1);
|
|
fail_unless (gst_structure_is_equal (s1, gst_value_get_structure (&v1)));
|
|
|
|
s2 = gst_structure_copy (s1);
|
|
g_value_init (&v2, GST_TYPE_STRUCTURE);
|
|
gst_value_set_structure (&v2, s2);
|
|
|
|
/* can do everything but subtract */
|
|
fail_unless (gst_value_can_compare (&v1, &v2));
|
|
fail_unless (gst_value_can_intersect (&v1, &v2));
|
|
fail_unless (!gst_value_can_subtract (&v1, &v2));
|
|
fail_unless (gst_value_can_union (&v1, &v2));
|
|
|
|
gst_structure_free (s1);
|
|
gst_structure_free (s2);
|
|
g_value_unset (&v1);
|
|
g_value_unset (&v2);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_structure_single_ops)
|
|
{
|
|
static const struct
|
|
{
|
|
const gchar *str1;
|
|
gboolean is_fixed;
|
|
gboolean can_fixate;
|
|
} single_struct[] = {
|
|
{
|
|
"foo,bar=(int)1", TRUE, TRUE}, {
|
|
"foo,bar=(int)[1,2]", FALSE, TRUE},};
|
|
gint i;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (single_struct); i++) {
|
|
GstStructure *s1 = gst_structure_from_string (single_struct[i].str1, NULL);
|
|
GValue v1 = G_VALUE_INIT;
|
|
GValue v2 = G_VALUE_INIT;
|
|
|
|
fail_unless (s1 != NULL);
|
|
|
|
GST_DEBUG ("checking structure %" GST_PTR_FORMAT, s1);
|
|
|
|
g_value_init (&v1, GST_TYPE_STRUCTURE);
|
|
gst_value_set_structure (&v1, s1);
|
|
|
|
fail_unless (gst_value_is_fixed (&v1) == single_struct[i].is_fixed);
|
|
fail_unless (gst_value_fixate (&v2, &v1) == single_struct[i].can_fixate);
|
|
if (single_struct[i].can_fixate)
|
|
g_value_unset (&v2);
|
|
|
|
g_value_unset (&v1);
|
|
gst_structure_free (s1);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_structure_ops)
|
|
{
|
|
struct
|
|
{
|
|
const gchar *str1;
|
|
const gchar *str2;
|
|
const gchar *op;
|
|
gint ret;
|
|
GType str_type;
|
|
} comparisons[] = {
|
|
/* *INDENT-OFF* */
|
|
{"foo,bar=(int)1", "foo,bar=(int)1", "compare", GST_VALUE_EQUAL, 0},
|
|
{"foo,bar=(int)1", "foo,bar=(int)1", "is_subset", TRUE, 0},
|
|
{"foo,bar=(int)1", "foo,bar=(int)1", "intersect", TRUE, GST_TYPE_STRUCTURE},
|
|
{"foo,bar=(int)1", "foo,bar=(int)1", "union", TRUE, GST_TYPE_STRUCTURE},
|
|
{"foo,bar=(int)[1,2]", "foo,bar=(int)1", "compare", GST_VALUE_UNORDERED, 0},
|
|
{"foo,bar=(int)[1,2]", "foo,bar=(int)1", "is_subset", FALSE, 0},
|
|
{"foo,bar=(int)[1,2]", "foo,bar=(int)1", "intersect", TRUE, GST_TYPE_STRUCTURE},
|
|
{"foo,bar=(int)[1,2]", "foo,bar=(int)1", "union", TRUE, GST_TYPE_STRUCTURE},
|
|
{"foo,bar=(int)1", "foo,bar=(int)[1,2]", "compare", GST_VALUE_UNORDERED, 0},
|
|
{"foo,bar=(int)1", "foo,bar=(int)[1,2]", "is_subset", TRUE, 0},
|
|
{"foo,bar=(int)1", "foo,bar=(int)[1,2]", "intersect", TRUE, GST_TYPE_STRUCTURE},
|
|
{"foo,bar=(int)1", "foo,bar=(int)[1,2]", "union", TRUE, GST_TYPE_STRUCTURE},
|
|
{"foo,bar=(int)1", "foo,bar=(int)2", "compare", GST_VALUE_UNORDERED, 0},
|
|
{"foo,bar=(int)1", "foo,bar=(int)2", "is_subset", FALSE, 0},
|
|
{"foo,bar=(int)1", "foo,bar=(int)2", "intersect", FALSE, 0},
|
|
{"foo,bar=(int)1", "foo,bar=(int)2", "union", TRUE, GST_TYPE_STRUCTURE},
|
|
{"foo,bar=(int)1", "baz,bar=(int)1", "compare", GST_VALUE_UNORDERED, 0},
|
|
{"foo,bar=(int)1", "baz,bar=(int)1", "is_subset", FALSE, 0},
|
|
{"foo,bar=(int)1", "baz,bar=(int)1", "intersect", FALSE, 0},
|
|
#if 0
|
|
/* deserializing lists is not implemented (but this should still work!) */
|
|
{"foo,bar=(int)1", "baz,bar=(int)1", "union", TRUE, G_TYPE_LIST},
|
|
#endif
|
|
/* *INDENT-ON* */
|
|
};
|
|
gint i;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (comparisons); i++) {
|
|
GstStructure *s1 = gst_structure_from_string (comparisons[i].str1, NULL);
|
|
GstStructure *s2 = gst_structure_from_string (comparisons[i].str2, NULL);
|
|
GValue v1 = G_VALUE_INIT, v2 = G_VALUE_INIT, v3 = G_VALUE_INIT;
|
|
|
|
fail_unless (s1 != NULL);
|
|
fail_unless (s2 != NULL);
|
|
|
|
GST_DEBUG ("checking %s with structure1 %" GST_PTR_FORMAT " structure2 %"
|
|
GST_PTR_FORMAT " is %d", comparisons[i].op, s1, s2, comparisons[i].ret);
|
|
|
|
g_value_init (&v1, GST_TYPE_STRUCTURE);
|
|
gst_value_set_structure (&v1, s1);
|
|
g_value_init (&v2, GST_TYPE_STRUCTURE);
|
|
gst_value_set_structure (&v2, s2);
|
|
|
|
if (g_strcmp0 (comparisons[i].op, "compare") == 0) {
|
|
fail_unless (gst_value_compare (&v1, &v2) == comparisons[i].ret);
|
|
} else if (g_strcmp0 (comparisons[i].op, "is_subset") == 0) {
|
|
fail_unless (gst_value_is_subset (&v1, &v2) == comparisons[i].ret);
|
|
} else {
|
|
if (g_strcmp0 (comparisons[i].op, "intersect") == 0) {
|
|
fail_unless (gst_value_intersect (&v3, &v1, &v2) == comparisons[i].ret);
|
|
} else if (g_strcmp0 (comparisons[i].op, "union") == 0) {
|
|
fail_unless (gst_value_union (&v3, &v1, &v2) == comparisons[i].ret);
|
|
}
|
|
if (comparisons[i].ret) {
|
|
GValue result = G_VALUE_INIT;
|
|
gchar *str;
|
|
|
|
str = gst_value_serialize (&v3);
|
|
GST_LOG ("result %s", str);
|
|
|
|
g_value_init (&result, comparisons[i].str_type);
|
|
fail_unless (gst_value_deserialize (&result, str));
|
|
g_free (str);
|
|
fail_unless (gst_value_compare (&result, &v3) == GST_VALUE_EQUAL);
|
|
g_value_unset (&v3);
|
|
g_value_unset (&result);
|
|
}
|
|
}
|
|
|
|
gst_structure_free (s1);
|
|
gst_structure_free (s2);
|
|
g_value_unset (&v1);
|
|
g_value_unset (&v2);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static gpointer
|
|
get_serialize_deserialize_boxed (const gpointer boxed, GType type)
|
|
{
|
|
gchar *serialized, *cmp;
|
|
GValue value = G_VALUE_INIT, value2 = G_VALUE_INIT;
|
|
gpointer ret;
|
|
|
|
g_value_init (&value, type);
|
|
g_value_init (&value2, type);
|
|
|
|
g_value_set_boxed (&value, boxed);
|
|
serialized = gst_value_serialize (&value);
|
|
fail_unless (serialized != NULL);
|
|
GST_DEBUG ("serialized to %s", serialized);
|
|
fail_unless (gst_value_deserialize (&value2, serialized));
|
|
cmp = gst_value_serialize (&value2);
|
|
fail_unless_equals_string (cmp, serialized);
|
|
|
|
ret = g_value_dup_boxed (&value2);
|
|
|
|
g_free (serialized);
|
|
g_free (cmp);
|
|
g_value_unset (&value);
|
|
g_value_unset (&value2);
|
|
return ret;
|
|
}
|
|
|
|
GST_START_TEST (test_serialize_deserialize_structure)
|
|
{
|
|
GstStructure *instr = gst_structure_new ("structure/internal",
|
|
"in-field", G_TYPE_INT, 20, "in-field2",
|
|
G_TYPE_STRING, "some in ternal field", NULL);
|
|
GstStructure *test_str[] = {
|
|
gst_structure_new ("test/structure",
|
|
"foo", G_TYPE_INT, 10, "bar", G_TYPE_STRING, "test",
|
|
"int-str", GST_TYPE_STRUCTURE, instr, NULL),
|
|
gst_structure_new_empty ("empty")
|
|
};
|
|
gint i;
|
|
GstStructure *str, *str2;
|
|
|
|
gst_structure_free (instr);
|
|
for (i = 0; i < G_N_ELEMENTS (test_str); i++) {
|
|
str = test_str[i];
|
|
str2 = get_serialize_deserialize_boxed (str, GST_TYPE_STRUCTURE);
|
|
fail_unless (gst_structure_is_equal (str, str2));
|
|
|
|
_test_serialize_deserialize_boxed_in_structure (str, GST_TYPE_STRUCTURE);
|
|
|
|
gst_structure_free (str);
|
|
gst_structure_free (str2);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static void
|
|
setup_test_value_array (GValue * value)
|
|
{
|
|
GValueArray *array;
|
|
GValue v = G_VALUE_INIT;
|
|
|
|
g_value_init (&v, G_TYPE_INT);
|
|
g_value_init (value, G_TYPE_VALUE_ARRAY);
|
|
|
|
array = g_value_array_new (3);
|
|
g_value_set_int (&v, 1);
|
|
g_value_array_append (array, &v);
|
|
g_value_set_int (&v, 2);
|
|
g_value_array_append (array, &v);
|
|
g_value_set_int (&v, 3);
|
|
g_value_array_append (array, &v);
|
|
|
|
g_value_take_boxed (value, array);
|
|
}
|
|
|
|
static void
|
|
test_revert_array_transform (GValue * v1, GValue * v2)
|
|
{
|
|
GValueArray *array;
|
|
|
|
g_value_reset (v1);
|
|
|
|
fail_unless (g_value_transform (v2, v1));
|
|
array = g_value_get_boxed (v1);
|
|
fail_unless (array->n_values == 3);
|
|
fail_unless (g_value_get_int (g_value_array_get_nth (array, 0)) == 1);
|
|
fail_unless (g_value_get_int (g_value_array_get_nth (array, 1)) == 2);
|
|
fail_unless (g_value_get_int (g_value_array_get_nth (array, 2)) == 3);
|
|
}
|
|
|
|
GST_START_TEST (test_transform_array)
|
|
{
|
|
GValue v1 = G_VALUE_INIT, v2 = G_VALUE_INIT;
|
|
|
|
setup_test_value_array (&v1);
|
|
|
|
g_value_init (&v2, GST_TYPE_ARRAY);
|
|
|
|
fail_unless (g_value_transform (&v1, &v2));
|
|
fail_unless (gst_value_array_get_size (&v2) == 3);
|
|
fail_unless (g_value_get_int (gst_value_array_get_value (&v2, 0)) == 1);
|
|
fail_unless (g_value_get_int (gst_value_array_get_value (&v2, 1)) == 2);
|
|
fail_unless (g_value_get_int (gst_value_array_get_value (&v2, 2)) == 3);
|
|
|
|
test_revert_array_transform (&v1, &v2);
|
|
|
|
g_value_unset (&v1);
|
|
g_value_unset (&v2);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_transform_list)
|
|
{
|
|
GValue v1 = G_VALUE_INIT, v2 = G_VALUE_INIT;
|
|
|
|
setup_test_value_array (&v1);
|
|
|
|
g_value_init (&v2, GST_TYPE_LIST);
|
|
|
|
fail_unless (g_value_transform (&v1, &v2));
|
|
fail_unless (gst_value_list_get_size (&v2) == 3);
|
|
fail_unless (g_value_get_int (gst_value_list_get_value (&v2, 0)) == 1);
|
|
fail_unless (g_value_get_int (gst_value_list_get_value (&v2, 1)) == 2);
|
|
fail_unless (g_value_get_int (gst_value_list_get_value (&v2, 2)) == 3);
|
|
|
|
test_revert_array_transform (&v1, &v2);
|
|
|
|
g_value_unset (&v1);
|
|
g_value_unset (&v2);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_serialize_null_aray)
|
|
{
|
|
gchar *serialized;
|
|
GValue v = G_VALUE_INIT;
|
|
|
|
g_value_init (&v, G_TYPE_VALUE_ARRAY);
|
|
|
|
g_value_set_boxed (&v, NULL);
|
|
serialized = gst_value_serialize (&v);
|
|
fail_unless_equals_string (serialized, "< >");
|
|
g_value_unset (&v);
|
|
g_free (serialized);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_array)
|
|
{
|
|
GValue value = { 0 };
|
|
const gchar *strings[] = {
|
|
"{ test, }",
|
|
"{ , }",
|
|
"{ test,, }",
|
|
"{ , , }",
|
|
};
|
|
gint results_size[] = { 1, 0, -1, -1 }; /* -1 means deserialization should fail */
|
|
int i;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
/* Workaround a bug in our parser that would lead to segfaults
|
|
* when deserializing container types using static strings */
|
|
gchar *str = g_strdup (strings[i]);
|
|
g_value_init (&value, GST_TYPE_LIST);
|
|
|
|
if (results_size[i] == -1) {
|
|
fail_if (gst_value_deserialize (&value, str),
|
|
"Should not be able to deserialize %s (%d) as list", str, i);
|
|
} else {
|
|
fail_unless (gst_value_deserialize (&value, str),
|
|
"could not deserialize %s (%d)", str, i);
|
|
fail_unless (gst_value_list_get_size (&value) == results_size[i],
|
|
"Wrong array size: %d. expected %d",
|
|
gst_value_array_get_size (&value), results_size[i]);
|
|
}
|
|
|
|
g_value_unset (&value);
|
|
g_free (str);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
#define TEST_FLAGS_TYPE (test_flags_get_type())
|
|
static GType
|
|
test_flags_get_type (void)
|
|
{
|
|
static const GFlagsValue values[] = {
|
|
{1, "One", "one"},
|
|
{1 << 1, "Two", "two"},
|
|
{1 << 3, "Eight", "eight"},
|
|
{0, NULL, NULL}
|
|
};
|
|
static volatile GType id = 0;
|
|
|
|
if (g_once_init_enter ((gsize *) & id)) {
|
|
GType _id;
|
|
|
|
_id = g_flags_register_static ("TestFlags", values);
|
|
|
|
g_once_init_leave ((gsize *) & id, _id);
|
|
}
|
|
|
|
return id;
|
|
}
|
|
|
|
#define _RESULT(i) result_##i
|
|
#define RESULT(i) _RESULT(i)
|
|
|
|
GST_START_TEST (test_deserialize_with_pspec)
|
|
{
|
|
GValue value = { 0 };
|
|
GParamSpec *pspec;
|
|
const gchar *strings[] = {
|
|
"< one, 0>",
|
|
"< one+eight, two >",
|
|
"< 9, 0>",
|
|
};
|
|
int i;
|
|
|
|
gint results[3][2] = {
|
|
{1, 0},
|
|
{9, 2},
|
|
{9, 0}
|
|
};
|
|
|
|
pspec = gst_param_spec_array ("flags-array",
|
|
"Flags Array", "An array of flags",
|
|
g_param_spec_flags ("flags", "Flags", "Flags", TEST_FLAGS_TYPE, 0,
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS),
|
|
G_PARAM_READWRITE | G_PARAM_STATIC_STRINGS);
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
int j;
|
|
gchar *str = g_strdup (strings[i]);
|
|
g_value_init (&value, GST_TYPE_ARRAY);
|
|
|
|
fail_unless (gst_value_deserialize_with_pspec (&value, str, pspec),
|
|
"could not deserialize %s (%d)", str, i);
|
|
|
|
fail_unless (gst_value_array_get_size (&value) ==
|
|
G_N_ELEMENTS (results[i]));
|
|
|
|
for (j = 0; j < G_N_ELEMENTS (results[i]); j++) {
|
|
const GValue *elem_value = gst_value_array_get_value (&value, j);
|
|
fail_unless (G_VALUE_TYPE (elem_value) == TEST_FLAGS_TYPE);
|
|
fail_unless_equals_int (g_value_get_flags (elem_value), results[i][j]);
|
|
}
|
|
|
|
g_value_unset (&value);
|
|
g_free (str);
|
|
}
|
|
|
|
g_param_spec_unref (pspec);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_serialize_deserialize_segment)
|
|
{
|
|
GstSegment *seg, *seg2;
|
|
|
|
seg = gst_segment_new ();
|
|
gst_segment_init (seg, GST_FORMAT_DEFAULT);
|
|
fail_unless (gst_segment_do_seek (seg, 1.2, GST_FORMAT_DEFAULT,
|
|
GST_SEEK_FLAG_FLUSH, GST_SEEK_TYPE_SET, 20, GST_SEEK_TYPE_SET, 30,
|
|
NULL));
|
|
seg2 = get_serialize_deserialize_boxed (seg, GST_TYPE_SEGMENT);
|
|
fail_unless (gst_segment_is_equal (seg, seg2));
|
|
|
|
_test_serialize_deserialize_boxed_in_structure (seg, GST_TYPE_SEGMENT);
|
|
|
|
gst_segment_free (seg);
|
|
gst_segment_free (seg2);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_serialize_deserialize_caps_features)
|
|
{
|
|
GstCapsFeatures *test_feats[] = {
|
|
gst_caps_features_new ("abc:val1", "xyz:val2", NULL),
|
|
gst_caps_features_new ("feat:val", NULL),
|
|
gst_caps_features_new_any (),
|
|
gst_caps_features_new_empty ()
|
|
};
|
|
gint i;
|
|
GstCapsFeatures *feats, *feats2;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (test_feats); i++) {
|
|
feats = test_feats[i];
|
|
fail_unless (feats != NULL);
|
|
feats2 = get_serialize_deserialize_boxed (feats, GST_TYPE_CAPS_FEATURES);
|
|
fail_unless (gst_caps_features_is_equal (feats, feats2));
|
|
fail_unless (gst_caps_features_is_any (feats) ==
|
|
gst_caps_features_is_any (feats2));
|
|
|
|
_test_serialize_deserialize_boxed_in_structure (feats,
|
|
GST_TYPE_CAPS_FEATURES);
|
|
|
|
gst_caps_features_free (feats);
|
|
gst_caps_features_free (feats2);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_serialize_deserialize_tag_list)
|
|
{
|
|
GstTagList *test_tags[] = {
|
|
gst_tag_list_new (GST_TAG_TITLE, "A Title", GST_TAG_ARTIST, "Art櫱",
|
|
GST_TAG_TRACK_NUMBER, 1, NULL),
|
|
gst_tag_list_new_empty ()
|
|
};
|
|
gint i;
|
|
GstTagList *tags, *tags2;
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (test_tags); i++) {
|
|
tags = test_tags[i];
|
|
fail_unless (tags != NULL);
|
|
tags2 = get_serialize_deserialize_boxed (tags, GST_TYPE_TAG_LIST);
|
|
fail_unless (gst_tag_list_is_equal (tags, tags2));
|
|
|
|
_test_serialize_deserialize_boxed_in_structure (tags, GST_TYPE_TAG_LIST);
|
|
|
|
gst_tag_list_unref (tags);
|
|
gst_tag_list_unref (tags2);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_deserialize_serialize_nested_structures)
|
|
{
|
|
gint i;
|
|
gchar *structure_str;
|
|
GstStructure *structure, *structure2;
|
|
|
|
/* *INDENT-OFF* */
|
|
struct
|
|
{
|
|
const gchar *serialized_struct;
|
|
gboolean should_fail;
|
|
const gchar *path_to_bool;
|
|
const gchar *subcaps_str;
|
|
} tests_data[] = {
|
|
{"s, substruct=[sub, is-deepest=true]", FALSE, "substruct"},
|
|
{"s, substruct=(structure) [sub, is-deepest=true]", FALSE, "substruct"},
|
|
{"s, substruct=[sub, is-substruct=true, subsubstruct=[subsub, is-deepest=true]]", FALSE, "substruct/subsubstruct"},
|
|
{"s, substruct=[sub, is-substruct=true, subsubstruct=[subsub, subsubsubstruct=[subsubsub, is-deepest=true]]]", FALSE, "substruct/subsubstruct/subsubsubstruct"},
|
|
{"s, substruct=[sub, an-array={a, b}, subsubstruct=[subsub, a-range=[1,2], a-string=\"this is a \\\"string\\\"\"]]", FALSE, NULL},
|
|
{"s, sub-caps=[nested-caps(some:Feature), is-caps=true; second, caps-structure=true]", FALSE, NULL, "nested-caps(some:Feature), is-caps=true; second, caps-structure=true"},
|
|
{"s, sub-caps=[nested-caps(some:Feature)]", FALSE, NULL, "nested-caps(some:Feature)"},
|
|
{"s, array=(structure){[struct, n=1], [struct, n=2]}"},
|
|
/* Broken structure with substructures */
|
|
{"s, substruct=[sub, is-substruct=true", TRUE},
|
|
{"s, substruct=[sub, is-substruct=true, sub=\"yes]", TRUE},
|
|
{"s, substruct=[sub, a-broken-string=$broken]", TRUE},
|
|
{"s, sub-caps=(int)[nested-caps(some:Feature)]", TRUE},
|
|
};
|
|
/* *INDENT-ON* */
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (tests_data); i++) {
|
|
structure = gst_structure_new_from_string (tests_data[i].serialized_struct);
|
|
if (tests_data[i].should_fail) {
|
|
fail_if (structure, "%s not be deserialized",
|
|
tests_data[i].serialized_struct);
|
|
continue;
|
|
}
|
|
fail_unless (structure, "%s could not be deserialized",
|
|
tests_data[i].serialized_struct);
|
|
structure_str = gst_structure_to_string (structure);
|
|
structure2 = gst_structure_new_from_string (structure_str);
|
|
fail_unless (gst_structure_is_equal (structure, structure2));
|
|
g_free (structure_str);
|
|
|
|
if (tests_data[i].path_to_bool) {
|
|
const GstStructure *tmpstruct = structure;
|
|
gchar **tmpstrv = g_strsplit (tests_data[i].path_to_bool, "/", -1);
|
|
gint j;
|
|
|
|
for (j = 0; tmpstrv[j]; j++) {
|
|
const GValue *v = gst_structure_get_value (tmpstruct, tmpstrv[j]);
|
|
|
|
fail_unless (v, "Could not find '%s' in %s", tmpstrv[j],
|
|
gst_structure_to_string (tmpstruct));
|
|
tmpstruct = gst_value_get_structure (v);
|
|
|
|
fail_unless (GST_IS_STRUCTURE (tmpstruct));
|
|
if (!tmpstrv[j + 1]) {
|
|
gboolean tmp;
|
|
|
|
fail_unless (gst_structure_get_boolean (tmpstruct, "is-deepest", &tmp)
|
|
&& tmp);
|
|
}
|
|
}
|
|
g_strfreev (tmpstrv);
|
|
}
|
|
if (tests_data[i].subcaps_str) {
|
|
const GValue *v = gst_structure_get_value (structure, "sub-caps");
|
|
const GstCaps *caps = gst_value_get_caps (v);
|
|
GstCaps *caps2 = gst_caps_from_string (tests_data[i].subcaps_str);
|
|
|
|
fail_unless (gst_caps_is_equal (caps, caps2));
|
|
gst_caps_unref (caps2);
|
|
}
|
|
|
|
/* Ensure that doing a round trip works as expected */
|
|
structure_str = gst_structure_to_string (structure2);
|
|
gst_structure_free (structure2);
|
|
structure2 = gst_structure_new_from_string (structure_str);
|
|
fail_unless (gst_structure_is_equal (structure, structure2));
|
|
gst_structure_free (structure);
|
|
gst_structure_free (structure2);
|
|
g_free (structure_str);
|
|
}
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
GST_START_TEST (test_serialize_deserialize_sample)
|
|
{
|
|
GstSample *samp, *samp2;
|
|
gsize buff_len = 8;
|
|
const gchar buff_str[8] = "buf\ndat";
|
|
gchar *buff_val;
|
|
GstBuffer *buff = gst_buffer_new_wrapped (g_strdup (buff_str), buff_len);
|
|
GstCaps *caps = gst_caps_new_simple ("caps", "Int", G_TYPE_INT, 20,
|
|
"String", G_TYPE_STRING, "a string", NULL);
|
|
GstSegment *seg = gst_segment_new ();
|
|
|
|
gst_segment_init (seg, GST_FORMAT_DEFAULT);
|
|
fail_unless (gst_segment_do_seek (seg, 1.2, GST_FORMAT_DEFAULT,
|
|
GST_SEEK_FLAG_FLUSH, GST_SEEK_TYPE_SET, 20, GST_SEEK_TYPE_SET, 30,
|
|
NULL));
|
|
fail_unless (buff != NULL);
|
|
fail_unless (caps != NULL);
|
|
samp = gst_sample_new (buff, caps, seg,
|
|
gst_structure_new ("structure", "Float", G_TYPE_FLOAT, -2.5, NULL));
|
|
gst_buffer_unref (buff);
|
|
gst_caps_unref (caps);
|
|
|
|
samp2 = get_serialize_deserialize_boxed (samp, GST_TYPE_SAMPLE);
|
|
fail_unless (gst_caps_is_equal (gst_sample_get_caps (samp),
|
|
gst_sample_get_caps (samp2)));
|
|
fail_unless (gst_structure_is_equal (gst_sample_get_info (samp),
|
|
gst_sample_get_info (samp2)));
|
|
fail_unless (gst_segment_is_equal (gst_sample_get_segment (samp),
|
|
gst_sample_get_segment (samp2)));
|
|
|
|
buff = gst_sample_get_buffer (samp);
|
|
gst_buffer_extract_dup (buff, 0, -1, (gpointer *) & buff_val, &buff_len);
|
|
fail_unless_equals_int (buff_len, 8);
|
|
fail_unless_equals_string (buff_val, buff_str);
|
|
g_free (buff_val);
|
|
buff = gst_sample_get_buffer (samp2);
|
|
gst_buffer_extract_dup (buff, 0, -1, (gpointer *) & buff_val, &buff_len);
|
|
fail_unless_equals_int (buff_len, 8);
|
|
fail_unless_equals_string (buff_val, buff_str);
|
|
g_free (buff_val);
|
|
|
|
_test_serialize_deserialize_boxed_in_structure (samp, GST_TYPE_SAMPLE);
|
|
|
|
gst_sample_unref (samp);
|
|
gst_sample_unref (samp2);
|
|
gst_segment_free (seg);
|
|
}
|
|
|
|
GST_END_TEST;
|
|
|
|
static Suite *
|
|
gst_value_suite (void)
|
|
{
|
|
Suite *s = suite_create ("GstValue");
|
|
TCase *tc_chain = tcase_create ("general");
|
|
|
|
suite_add_tcase (s, tc_chain);
|
|
tcase_add_test (tc_chain, test_deserialize_buffer);
|
|
tcase_add_test (tc_chain, test_serialize_buffer);
|
|
tcase_add_test (tc_chain, test_deserialize_gint);
|
|
tcase_add_test (tc_chain, test_deserialize_gint_failures);
|
|
tcase_add_test (tc_chain, test_deserialize_guint);
|
|
tcase_add_test (tc_chain, test_deserialize_guint_failures);
|
|
tcase_add_test (tc_chain, test_deserialize_gint64);
|
|
tcase_add_test (tc_chain, test_deserialize_guint64);
|
|
tcase_add_test (tc_chain, test_deserialize_guchar);
|
|
tcase_add_test (tc_chain, test_deserialize_gstfraction);
|
|
tcase_add_test (tc_chain, test_deserialize_gtype);
|
|
tcase_add_test (tc_chain, test_deserialize_gtype_failures);
|
|
tcase_add_test (tc_chain, test_deserialize_bitmask);
|
|
tcase_add_test (tc_chain, test_deserialize_array);
|
|
tcase_add_test (tc_chain, test_serialize_flags);
|
|
tcase_add_test (tc_chain, test_deserialize_flags);
|
|
tcase_add_test (tc_chain, test_serialize_deserialize_format_enum);
|
|
tcase_add_test (tc_chain, test_serialize_deserialize_value_array);
|
|
tcase_add_test (tc_chain, test_string);
|
|
tcase_add_test (tc_chain, test_deserialize_string);
|
|
tcase_add_test (tc_chain, test_value_compare);
|
|
tcase_add_test (tc_chain, test_value_intersect);
|
|
tcase_add_test (tc_chain, test_value_subtract_int);
|
|
tcase_add_test (tc_chain, test_value_subtract_int64);
|
|
tcase_add_test (tc_chain, test_value_subtract_double);
|
|
tcase_add_test (tc_chain, test_value_subtract_fraction);
|
|
tcase_add_test (tc_chain, test_value_subtract_fraction_range);
|
|
tcase_add_test (tc_chain, test_value_subtract_fraction_list);
|
|
tcase_add_test (tc_chain, test_date);
|
|
tcase_add_test (tc_chain, test_date_time);
|
|
tcase_add_test (tc_chain, test_fraction_range);
|
|
tcase_add_test (tc_chain, test_serialize_deserialize_caps);
|
|
tcase_add_test (tc_chain, test_compare_caps);
|
|
tcase_add_test (tc_chain, test_int_range);
|
|
tcase_add_test (tc_chain, test_int64_range);
|
|
tcase_add_test (tc_chain, test_serialize_int64_range);
|
|
tcase_add_test (tc_chain, test_deserialize_int_range);
|
|
tcase_add_test (tc_chain, test_stepped_range_collection);
|
|
tcase_add_test (tc_chain, test_stepped_int_range_parsing);
|
|
tcase_add_test (tc_chain, test_stepped_int_range_ops);
|
|
tcase_add_test (tc_chain, test_flagset);
|
|
tcase_add_test (tc_chain, test_structure_basic);
|
|
tcase_add_test (tc_chain, test_structure_single_ops);
|
|
tcase_add_test (tc_chain, test_structure_ops);
|
|
tcase_add_test (tc_chain, test_serialize_deserialize_structure);
|
|
tcase_add_test (tc_chain, test_transform_array);
|
|
tcase_add_test (tc_chain, test_transform_list);
|
|
tcase_add_test (tc_chain, test_serialize_null_aray);
|
|
tcase_add_test (tc_chain, test_deserialize_with_pspec);
|
|
tcase_add_test (tc_chain, test_deserialize_serialize_nested_structures);
|
|
tcase_add_test (tc_chain, test_serialize_deserialize_segment);
|
|
tcase_add_test (tc_chain, test_serialize_deserialize_caps_features);
|
|
tcase_add_test (tc_chain, test_serialize_deserialize_tag_list);
|
|
tcase_add_test (tc_chain, test_serialize_deserialize_sample);
|
|
|
|
return s;
|
|
}
|
|
|
|
GST_CHECK_MAIN (gst_value);
|