gstreamer/tests/check/gst/gstvalue.c

3735 lines
123 KiB
C
Raw Normal View History

/* 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);
2011-03-21 18:15:27 +00:00
gst_buffer_fill (buf, 0, (gchar *) buf_data, len);
2011-03-21 18:15:27 +00:00
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;
2011-12-16 12:11:36 +00:00
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"}, {
"", ""}, /* empty strings */
{
"\"\"", ""}, /* quoted empty string -> empty string */
/* Expected FAILURES: */
{
"\"\\0\"", NULL}, /* unfinished escaped character */
{
"\"", NULL}, /* solitary quote */
{
"\" \"", NULL}, /* spaces must be escaped */
#if 0
/* FIXME 0.9: this test should fail, but it doesn't */
{
"tüüt", NULL} /* string with special chars must be escaped */
#endif
};
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
/* 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);
2011-12-16 12:11:36 +00:00
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);
2011-12-16 12:11:36 +00:00
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);
2011-12-16 12:11:36 +00:00
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);
2011-10-11 11:54:45 +00:00
g_value_set_static_string (&src1, "YUY2");
g_value_init (&src2, GST_TYPE_LIST);
g_value_init (&item, G_TYPE_STRING);
2011-10-11 11:54:45 +00:00
g_value_set_static_string (&item, "YUY2");
gst_value_list_append_value (&src2, &item);
2011-10-11 11:54:45 +00:00
g_value_set_static_string (&item, "I420");
gst_value_list_append_value (&src2, &item);
2011-10-11 11:54:45 +00:00
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);
2011-10-11 11:54:45 +00:00
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;
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
/* 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 */
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
}
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
/* 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;
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
GST_START_TEST (test_fraction_range)
{
GValue range = { 0, };
GValue start = { 0, };
GValue end = { 0, };
GValue src = { 0, };
GValue dest = { 0, };
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
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;
GST_START_TEST (test_serialize_deserialize_caps)
{
GValue value = { 0 }
, value2 = {
0};
GstCaps *caps, *caps2;
GstCaps *incaps;
gchar *serialized;
incaps = gst_caps_new_simple ("caps/internal",
"in-field", G_TYPE_INT, 20, "in-field2",
G_TYPE_STRING, "some in ternal field", NULL);
caps = gst_caps_new_simple ("test/caps",
"foo", G_TYPE_INT, 10, "bar", G_TYPE_STRING, "test",
"int-caps", GST_TYPE_CAPS, incaps, NULL);
fail_if (GST_CAPS_REFCOUNT_VALUE (caps) != 1);
gst_caps_unref (incaps);
/* and assign caps to gvalue */
g_value_init (&value, GST_TYPE_CAPS);
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 */
g_value_init (&value2, GST_TYPE_CAPS);
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));
/* cleanup */
g_value_unset (&value);
g_value_unset (&value2);
g_free (serialized);
}
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]);
2012-01-27 11:10:09 +00:00
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]);
2012-01-27 11:10:09 +00:00
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[] = {
2012-01-27 11:10:09 +00:00
{
"[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;
const gchar *str_result;
} comparisons[] = {
/* *INDENT-OFF* */
{"foo,bar=(int)1", "foo,bar=(int)1", "compare", GST_VALUE_EQUAL, 0, NULL},
{"foo,bar=(int)1", "foo,bar=(int)1", "is_subset", TRUE, 0, NULL},
{"foo,bar=(int)1", "foo,bar=(int)1", "intersect", TRUE, GST_TYPE_STRUCTURE, "foo,bar=(int)1"},
{"foo,bar=(int)1", "foo,bar=(int)1", "union", TRUE, GST_TYPE_STRUCTURE, "foo,bar=(int)1"},
{"foo,bar=(int)[1,2]", "foo,bar=(int)1", "compare", GST_VALUE_UNORDERED, 0, NULL},
{"foo,bar=(int)[1,2]", "foo,bar=(int)1", "is_subset", FALSE, 0, NULL},
{"foo,bar=(int)[1,2]", "foo,bar=(int)1", "intersect", TRUE, GST_TYPE_STRUCTURE, "foo,bar=(int)1"},
{"foo,bar=(int)[1,2]", "foo,bar=(int)1", "union", TRUE, GST_TYPE_STRUCTURE, "foo,bar=(int)[1,2]"},
{"foo,bar=(int)1", "foo,bar=(int)[1,2]", "compare", GST_VALUE_UNORDERED, 0, NULL},
{"foo,bar=(int)1", "foo,bar=(int)[1,2]", "is_subset", TRUE, 0, NULL},
{"foo,bar=(int)1", "foo,bar=(int)[1,2]", "intersect", TRUE, GST_TYPE_STRUCTURE, "foo,bar=(int)1"},
{"foo,bar=(int)1", "foo,bar=(int)[1,2]", "union", TRUE, GST_TYPE_STRUCTURE, "foo,bar=(int)[1,2]"},
{"foo,bar=(int)1", "foo,bar=(int)2", "compare", GST_VALUE_UNORDERED, 0, NULL},
{"foo,bar=(int)1", "foo,bar=(int)2", "is_subset", FALSE, 0, NULL},
{"foo,bar=(int)1", "foo,bar=(int)2", "intersect", FALSE, 0, NULL},
{"foo,bar=(int)1", "foo,bar=(int)2", "union", TRUE, GST_TYPE_STRUCTURE, "foo,bar=(int)[1,2]"},
{"foo,bar=(int)1", "baz,bar=(int)1", "compare", GST_VALUE_UNORDERED, 0, NULL},
{"foo,bar=(int)1", "baz,bar=(int)1", "is_subset", FALSE, 0, NULL},
{"foo,bar=(int)1", "baz,bar=(int)1", "intersect", FALSE, 0, NULL},
#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, "{foo,bar=(int)1;, baz,bar=(int)1;}"},
#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, %s", comparisons[i].op, s1, s2,
comparisons[i].ret, comparisons[i].str_result);
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_free (str);
g_value_init (&result, comparisons[i].str_type);
fail_unless (gst_value_deserialize (&result,
comparisons[i].str_result));
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 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_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;
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);
2011-12-16 12:11:36 +00:00
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
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);
Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from i... Original commit message from CVS: * check/gst/capslist.h: * check/gst/gstcaps.c: (GST_START_TEST): * check/gst/gstvalue.c: (GST_START_TEST), (gst_value_suite): * gst/gststructure.c: (gst_structure_parse_range), (gst_structure_fixate_field_nearest_fraction): * gst/gststructure.h: * gst/gstvalue.c: (gst_value_init_fraction_range), (gst_value_free_fraction_range), (gst_value_copy_fraction_range), (gst_value_collect_fraction_range), (gst_value_lcopy_fraction_range), (gst_value_set_fraction_range), (gst_value_set_fraction_range_full), (gst_value_get_fraction_range_min), (gst_value_get_fraction_range_max), (gst_value_serialize_fraction_range), (gst_value_transform_fraction_range_string), (gst_value_compare_fraction_range), (gst_value_deserialize_fraction_range), (gst_value_intersect_fraction_fraction_range), (gst_value_intersect_fraction_range_fraction_range), (gst_value_subtract_fraction_fraction_range), (gst_value_subtract_fraction_range_fraction), (gst_value_subtract_fraction_range_fraction_range), (gst_value_collect_fraction), (gst_value_fraction_multiply), (gst_value_fraction_subtract), (gst_value_deserialize_fraction), (gst_value_transform_string_fraction), (_gst_value_initialize): * gst/gstvalue.h: Implement fraction ranges and extend GstFraction to support arithmetic subtraction, as well as deserialization from integer strings such as "100" Add a testsuite as for int and double range set operations
2005-11-21 23:54:59 +00:00
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_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);
return s;
}
tests/check/: use the new macro Original commit message from CVS: * tests/check/elements/fakesink.c: * tests/check/elements/fakesrc.c: * tests/check/elements/fdsrc.c: * tests/check/elements/identity.c: * tests/check/generic/sinks.c: (gst_sinks_suite): * tests/check/generic/states.c: * tests/check/gst/gst.c: * tests/check/gst/gstabi.c: * tests/check/gst/gstbin.c: * tests/check/gst/gstbuffer.c: (gst_buffer_suite): * tests/check/gst/gstbus.c: (gst_bus_suite): * tests/check/gst/gstcaps.c: (GST_START_TEST): * tests/check/gst/gstelement.c: * tests/check/gst/gstevent.c: (gst_event_suite): * tests/check/gst/gstghostpad.c: * tests/check/gst/gstiterator.c: (gst_iterator_suite): * tests/check/gst/gstmessage.c: (gst_message_suite): * tests/check/gst/gstminiobject.c: * tests/check/gst/gstobject.c: * tests/check/gst/gstpad.c: * tests/check/gst/gstpipeline.c: * tests/check/gst/gstplugin.c: * tests/check/gst/gstquery.c: (gst_query_suite): * tests/check/gst/gstsegment.c: (gst_segment_suite): * tests/check/gst/gststructure.c: * tests/check/gst/gstsystemclock.c: * tests/check/gst/gsttag.c: * tests/check/gst/gsttask.c: (gst_task_suite): * tests/check/gst/gstutils.c: * tests/check/gst/gstvalue.c: * tests/check/libs/adapter.c: * tests/check/libs/basesrc.c: * tests/check/libs/collectpads.c: * tests/check/libs/controller.c: * tests/check/libs/gdp.c: (gst_dp_suite): * tests/check/libs/gstnetclientclock.c: * tests/check/libs/gstnettimeprovider.c: * tests/check/libs/libsabi.c: (libsabi_suite): * tests/check/libs/typefindhelper.c: * tests/check/pipelines/cleanup.c: * tests/check/pipelines/parse-launch.c: * tests/check/pipelines/simple-launch-lines.c: * tests/check/pipelines/stress.c: (stress_suite): use the new macro
2006-07-01 20:56:56 +00:00
GST_CHECK_MAIN (gst_value);