2005-06-22 19:22:34 +00:00
|
|
|
/* GStreamer
|
|
|
|
* Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
|
|
|
|
*
|
|
|
|
* gststructure.c: Unit tests for GstStructure
|
|
|
|
*
|
|
|
|
* 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
|
2012-11-03 20:44:48 +00:00
|
|
|
* Free Software Foundation, Inc., 51 Franklin St, Fifth Floor,
|
|
|
|
* Boston, MA 02110-1301, USA.
|
2005-06-22 19:22:34 +00:00
|
|
|
*/
|
2017-11-24 12:41:20 +00:00
|
|
|
#ifdef HAVE_CONFIG_H
|
|
|
|
#include "config.h"
|
|
|
|
#endif
|
2005-06-22 19:22:34 +00:00
|
|
|
|
2006-07-02 08:26:48 +00:00
|
|
|
#include <gst/gststructure.h>
|
2005-08-20 12:14:28 +00:00
|
|
|
#include <gst/check/gstcheck.h>
|
2005-06-22 19:22:34 +00:00
|
|
|
|
|
|
|
|
2005-07-09 16:36:18 +00:00
|
|
|
GST_START_TEST (test_from_string_int)
|
2005-06-22 19:22:34 +00:00
|
|
|
{
|
|
|
|
const char *strings[] = {
|
2012-03-01 10:06:49 +00:00
|
|
|
"video/x-raw, width = (int) 123456",
|
|
|
|
"video/x-raw, stride = (int) -123456",
|
|
|
|
"video/x-raw, red_mask = (int) 0xFFFF",
|
|
|
|
"video/x-raw, red_mask = (int) 0x0000FFFF",
|
|
|
|
"video/x-raw, red_mask = (int) 0x7FFFFFFF",
|
|
|
|
"video/x-raw, red_mask = (int) 0x80000000",
|
|
|
|
"video/x-raw, red_mask = (int) 0xFF000000",
|
2005-11-10 12:32:57 +00:00
|
|
|
/* result from
|
2012-09-13 09:35:41 +00:00
|
|
|
* gst-launch ... ! "video/x-raw, red_mask=(int)0xFF000000" ! ... */
|
2012-03-01 10:06:49 +00:00
|
|
|
"video/x-raw,\\ red_mask=(int)0xFF000000",
|
2005-06-22 19:22:34 +00:00
|
|
|
};
|
|
|
|
gint results[] = {
|
|
|
|
123456,
|
|
|
|
-123456,
|
|
|
|
0xFFFF,
|
|
|
|
0xFFFF,
|
|
|
|
0x7FFFFFFF,
|
2008-01-12 20:22:30 +00:00
|
|
|
(gint) 0x80000000,
|
|
|
|
(gint) 0xFF000000,
|
|
|
|
(gint) 0xFF000000,
|
2005-06-22 19:22:34 +00:00
|
|
|
};
|
|
|
|
GstStructure *structure;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
|
|
const char *s;
|
|
|
|
const gchar *name;
|
|
|
|
gint value;
|
|
|
|
|
|
|
|
s = strings[i];
|
|
|
|
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
name = gst_structure_nth_field_name (structure, 0);
|
|
|
|
fail_unless (gst_structure_get_int (structure, name, &value));
|
|
|
|
fail_unless (value == results[i],
|
|
|
|
"Value %d is not the expected result %d for string %s",
|
|
|
|
value, results[i], s);
|
2005-07-12 09:41:00 +00:00
|
|
|
|
|
|
|
/* cleanup */
|
|
|
|
gst_structure_free (structure);
|
2005-06-22 19:22:34 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2005-07-09 16:36:18 +00:00
|
|
|
GST_END_TEST;
|
2005-06-22 19:22:34 +00:00
|
|
|
|
2010-03-23 19:23:22 +00:00
|
|
|
GST_START_TEST (test_from_string_uint)
|
|
|
|
{
|
|
|
|
const char *strings[] = {
|
|
|
|
"taglist, bar = (uint) 123456",
|
|
|
|
"taglist, bar = (uint) 0xFFFF",
|
|
|
|
"taglist, bar = (uint) 0x0000FFFF",
|
|
|
|
"taglist, bar = (uint) 0x7FFFFFFF",
|
|
|
|
"taglist, bar = (uint) 0x80000000",
|
|
|
|
"taglist, bar = (uint) 0xFF000000"
|
|
|
|
};
|
|
|
|
guint results[] = {
|
|
|
|
123456,
|
|
|
|
0xFFFF,
|
|
|
|
0xFFFF,
|
|
|
|
0x7FFFFFFF,
|
|
|
|
0x80000000,
|
|
|
|
0xFF000000,
|
|
|
|
};
|
|
|
|
GstStructure *structure;
|
|
|
|
int i;
|
|
|
|
|
|
|
|
for (i = 0; i < G_N_ELEMENTS (strings); ++i) {
|
|
|
|
const char *s;
|
|
|
|
const gchar *name;
|
|
|
|
guint value;
|
|
|
|
|
|
|
|
s = strings[i];
|
|
|
|
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
name = gst_structure_nth_field_name (structure, 0);
|
|
|
|
fail_unless (gst_structure_get_uint (structure, name, &value));
|
|
|
|
fail_unless (value == results[i],
|
|
|
|
"Value %u is not the expected result %u for string %s",
|
|
|
|
value, results[i], s);
|
|
|
|
|
|
|
|
/* cleanup */
|
|
|
|
gst_structure_free (structure);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2005-11-22 12:35:42 +00:00
|
|
|
/* Test type conversions from string */
|
|
|
|
GST_START_TEST (test_from_string)
|
|
|
|
{
|
|
|
|
GstStructure *structure;
|
|
|
|
const gchar *s;
|
|
|
|
const GValue *val;
|
|
|
|
|
|
|
|
s = "test-string,value=1";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
fail_unless ((val = gst_structure_get_value (structure, "value")) != NULL);
|
|
|
|
fail_unless (G_VALUE_HOLDS_INT (val));
|
|
|
|
gst_structure_free (structure);
|
|
|
|
|
|
|
|
s = "test-string,value=1.0";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
fail_unless ((val = gst_structure_get_value (structure, "value")) != NULL);
|
|
|
|
fail_unless (G_VALUE_HOLDS_DOUBLE (val));
|
|
|
|
gst_structure_free (structure);
|
|
|
|
|
|
|
|
s = "test-string,value=1/1";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
fail_unless ((val = gst_structure_get_value (structure, "value")) != NULL);
|
|
|
|
fail_unless (GST_VALUE_HOLDS_FRACTION (val));
|
|
|
|
gst_structure_free (structure);
|
2005-11-22 13:14:51 +00:00
|
|
|
|
|
|
|
s = "test-string,value=bar";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
fail_unless ((val = gst_structure_get_value (structure, "value")) != NULL);
|
|
|
|
fail_unless (G_VALUE_HOLDS_STRING (val));
|
|
|
|
gst_structure_free (structure);
|
2007-07-08 14:11:53 +00:00
|
|
|
|
|
|
|
s = "test-string,value=true";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
fail_unless ((val = gst_structure_get_value (structure, "value")) != NULL);
|
|
|
|
fail_unless (G_VALUE_HOLDS_BOOLEAN (val));
|
|
|
|
fail_unless_equals_int (g_value_get_boolean (val), TRUE);
|
|
|
|
gst_structure_free (structure);
|
2007-12-08 12:54:53 +00:00
|
|
|
|
2020-12-10 12:57:37 +00:00
|
|
|
/* Test trailing comas */
|
|
|
|
s = "test-string,";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
gst_structure_free (structure);
|
|
|
|
|
|
|
|
s = "test-string,;";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
gst_structure_free (structure);
|
|
|
|
|
|
|
|
s = "test-string,value=true,";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
fail_unless ((val = gst_structure_get_value (structure, "value")) != NULL);
|
|
|
|
fail_unless (G_VALUE_HOLDS_BOOLEAN (val));
|
|
|
|
fail_unless_equals_int (g_value_get_boolean (val), TRUE);
|
|
|
|
gst_structure_free (structure);
|
|
|
|
|
|
|
|
s = "test-string,value=true,;";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
fail_unless ((val = gst_structure_get_value (structure, "value")) != NULL);
|
|
|
|
fail_unless (G_VALUE_HOLDS_BOOLEAN (val));
|
|
|
|
fail_unless_equals_int (g_value_get_boolean (val), TRUE);
|
|
|
|
gst_structure_free (structure);
|
|
|
|
|
|
|
|
s = "test-string,value=true,,";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_unless (structure == NULL, "Created structure from string %s", s);
|
|
|
|
|
2017-03-09 01:09:57 +00:00
|
|
|
/* Tests for flagset deserialisation */
|
|
|
|
s = "foobar,value=0010:ffff";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
fail_unless ((val = gst_structure_get_value (structure, "value")) != NULL);
|
|
|
|
fail_unless (GST_VALUE_HOLDS_FLAG_SET (val));
|
|
|
|
gst_structure_free (structure);
|
|
|
|
|
|
|
|
/* In the presence of the hex values, the strings don't matter as long as they
|
|
|
|
* have the right form */
|
|
|
|
s = "foobar,value=0010:ffff:+random+other/not-the-other";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
fail_unless ((val = gst_structure_get_value (structure, "value")) != NULL);
|
|
|
|
fail_unless (GST_VALUE_HOLDS_FLAG_SET (val));
|
|
|
|
gst_structure_free (structure);
|
|
|
|
|
|
|
|
/* Test that a timecode string is deserialised as a string, not a flagset:
|
|
|
|
* https://bugzilla.gnome.org/show_bug.cgi?id=779755 */
|
|
|
|
s = "foobar,timecode=00:01:00:00";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
fail_unless ((val = gst_structure_get_value (structure, "timecode")) != NULL);
|
|
|
|
fail_unless (G_VALUE_HOLDS_STRING (val));
|
|
|
|
gst_structure_free (structure);
|
|
|
|
|
2007-12-08 12:54:53 +00:00
|
|
|
s = "0.10:decoder-video/mpeg, abc=(boolean)false";
|
2018-11-06 09:20:17 +00:00
|
|
|
structure = NULL;
|
2011-06-03 11:25:54 +00:00
|
|
|
ASSERT_CRITICAL (structure = gst_structure_from_string (s, NULL));
|
|
|
|
fail_unless (structure == NULL, "Could not get structure from string %s", s);
|
2007-12-08 12:54:53 +00:00
|
|
|
|
|
|
|
/* make sure we bail out correctly in case of an error or if parsing fails */
|
|
|
|
s = "***foo***, abc=(boolean)false";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_unless (structure == NULL);
|
2008-03-03 10:07:21 +00:00
|
|
|
|
|
|
|
/* assert that we get a warning if the structure wasn't entirely consumed, but
|
|
|
|
* we didn't provide an end pointer */
|
|
|
|
s = "foo/bar; other random data";
|
|
|
|
ASSERT_WARNING (structure = gst_structure_from_string (s, NULL));
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
gst_structure_free (structure);
|
2014-11-20 12:34:32 +00:00
|
|
|
|
|
|
|
/* make sure we handle \ as last character in various things, run with valgrind */
|
|
|
|
s = "foo,test=\"foobar\\";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_unless (structure == NULL);
|
|
|
|
s = "\\";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_unless (structure == NULL);
|
|
|
|
s = "foobar,test\\";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_unless (structure == NULL);
|
|
|
|
s = "foobar,test=(string)foo\\";
|
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_unless (structure == NULL);
|
2005-11-22 12:35:42 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2007-10-16 06:32:07 +00:00
|
|
|
|
|
|
|
GST_START_TEST (test_to_string)
|
|
|
|
{
|
2018-11-06 09:20:17 +00:00
|
|
|
GstStructure *st1 = NULL;
|
2007-10-16 06:32:07 +00:00
|
|
|
|
2011-10-29 07:02:00 +00:00
|
|
|
ASSERT_CRITICAL (st1 = gst_structure_new_empty ("Foo\nwith-newline"));
|
2007-10-16 13:58:43 +00:00
|
|
|
fail_unless (st1 == NULL);
|
2007-10-16 06:32:07 +00:00
|
|
|
|
2011-10-29 07:02:00 +00:00
|
|
|
ASSERT_CRITICAL (st1 = gst_structure_new_empty ("Foo with whitespace"));
|
2007-10-16 13:58:43 +00:00
|
|
|
fail_unless (st1 == NULL);
|
2011-10-29 07:02:00 +00:00
|
|
|
ASSERT_CRITICAL (st1 = gst_structure_new_empty ("1st"));
|
2007-12-08 12:54:53 +00:00
|
|
|
fail_unless (st1 == NULL);
|
2007-10-16 06:32:07 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
|
|
|
2007-10-15 11:58:16 +00:00
|
|
|
GST_START_TEST (test_to_from_string)
|
|
|
|
{
|
|
|
|
GstStructure *st1, *st2;
|
2016-12-21 09:02:45 +00:00
|
|
|
gchar *str;
|
2007-10-15 11:58:16 +00:00
|
|
|
|
2007-10-16 13:58:43 +00:00
|
|
|
/* test escaping/unescaping */
|
|
|
|
st1 = gst_structure_new ("FooBar-123/0_1", "num", G_TYPE_INT, 9173,
|
2007-10-15 11:58:16 +00:00
|
|
|
"string", G_TYPE_STRING, "Something Like Face/Off", NULL);
|
|
|
|
str = gst_structure_to_string (st1);
|
|
|
|
st2 = gst_structure_from_string (str, NULL);
|
|
|
|
g_free (str);
|
|
|
|
|
2007-10-16 06:32:07 +00:00
|
|
|
fail_unless (st2 != NULL);
|
2016-12-21 09:02:45 +00:00
|
|
|
fail_unless (gst_structure_is_equal (st1, st2),
|
|
|
|
"Structures did not match:\n\tStructure 1: %" GST_PTR_FORMAT
|
|
|
|
"\n\tStructure 2: %" GST_PTR_FORMAT "\n", st1, st2);
|
2007-10-16 06:32:07 +00:00
|
|
|
|
2016-12-21 09:02:45 +00:00
|
|
|
gst_structure_free (st1);
|
|
|
|
gst_structure_free (st2);
|
2017-04-07 17:49:29 +00:00
|
|
|
|
|
|
|
/* Test NULL strings */
|
|
|
|
st1 = gst_structure_new ("test", "mynullstr", G_TYPE_STRING, NULL, NULL);
|
|
|
|
fail_unless (st1 != NULL);
|
|
|
|
str = gst_structure_to_string (st1);
|
|
|
|
fail_unless (strcmp (str, "test, mynullstr=(string)NULL;") == 0,
|
|
|
|
"Failed to serialize to right string: %s", str);
|
|
|
|
|
|
|
|
st2 = gst_structure_from_string (str, NULL);
|
|
|
|
fail_unless (st2 != NULL);
|
|
|
|
g_free (str);
|
|
|
|
|
|
|
|
fail_unless (gst_structure_is_equal (st1, st2),
|
|
|
|
"Structures did not match:\n\tStructure 1: %" GST_PTR_FORMAT
|
|
|
|
"\n\tStructure 2: %" GST_PTR_FORMAT "\n", st1, st2);
|
|
|
|
|
|
|
|
gst_structure_free (st1);
|
|
|
|
gst_structure_free (st2);
|
2018-03-15 11:43:56 +00:00
|
|
|
|
|
|
|
/* pointers are serialized but not deserialized */
|
|
|
|
st1 = gst_structure_new ("test", "ptr", G_TYPE_POINTER, 0xdeadbeef, NULL);
|
|
|
|
str = gst_structure_to_string (st1);
|
|
|
|
/* The way pointers are serialized may be plateform specific so just check
|
|
|
|
* if it contains the address */
|
|
|
|
fail_unless (g_strrstr (str, "deadbeef") || g_strrstr (str, "DEADBEEF"),
|
|
|
|
"Failed to serialize to right string: %s", str);
|
|
|
|
|
|
|
|
st2 = gst_structure_from_string (str, NULL);
|
|
|
|
fail_unless (!st2);
|
|
|
|
|
|
|
|
gst_structure_free (st1);
|
|
|
|
g_free (str);
|
2007-10-15 11:58:16 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2014-07-14 21:25:50 +00:00
|
|
|
/* Added to make sure taglists are properly serialized/deserialized after bug
|
|
|
|
* https://bugzilla.gnome.org/show_bug.cgi?id=733131 */
|
|
|
|
GST_START_TEST (test_to_from_string_tag_event)
|
|
|
|
{
|
|
|
|
GstEvent *tagevent;
|
|
|
|
GstTagList *taglist;
|
|
|
|
GstStructure *st1, *st2;
|
|
|
|
gchar *str;
|
|
|
|
|
|
|
|
/* empty taglist */
|
|
|
|
taglist = gst_tag_list_new_empty ();
|
|
|
|
tagevent = gst_event_new_tag (taglist);
|
|
|
|
|
|
|
|
st1 = (GstStructure *) gst_event_get_structure (tagevent);
|
|
|
|
str = gst_structure_to_string (st1);
|
|
|
|
fail_unless (str != NULL);
|
|
|
|
|
|
|
|
st2 = gst_structure_new_from_string (str);
|
|
|
|
fail_unless (st2 != NULL);
|
|
|
|
fail_unless (gst_structure_is_equal (st1, st2));
|
|
|
|
gst_event_unref (tagevent);
|
|
|
|
gst_structure_free (st2);
|
|
|
|
g_free (str);
|
|
|
|
|
|
|
|
/* taglist with data */
|
|
|
|
taglist = gst_tag_list_new ("title", "TEST TITLE", NULL);
|
|
|
|
tagevent = gst_event_new_tag (taglist);
|
|
|
|
|
|
|
|
st1 = (GstStructure *) gst_event_get_structure (tagevent);
|
|
|
|
str = gst_structure_to_string (st1);
|
|
|
|
fail_unless (str != NULL);
|
|
|
|
|
|
|
|
st2 = gst_structure_new_from_string (str);
|
|
|
|
fail_unless (st2 != NULL);
|
|
|
|
fail_unless (gst_structure_is_equal (st1, st2));
|
|
|
|
gst_event_unref (tagevent);
|
|
|
|
gst_structure_free (st2);
|
|
|
|
g_free (str);
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2006-05-22 13:34:03 +00:00
|
|
|
GST_START_TEST (test_complete_structure)
|
2005-06-22 19:22:34 +00:00
|
|
|
{
|
2006-05-22 13:34:03 +00:00
|
|
|
GstStructure *structure;
|
|
|
|
const gchar *s;
|
2005-06-22 19:22:34 +00:00
|
|
|
|
2016-01-18 19:10:48 +00:00
|
|
|
s = "GstEventSeek, rate=(double)1, format=(GstFormat)GST_FORMAT_TIME, flags=(GstSeekFlags)GST_SEEK_FLAG_NONE, start_type=(GstSeekType)GST_SEEK_TYPE_SET, start=(gint64)1000000000, stop_type=(GstSeekType)GST_SEEK_TYPE_NONE, stop=(gint64)0";
|
2006-05-22 13:34:03 +00:00
|
|
|
structure = gst_structure_from_string (s, NULL);
|
|
|
|
fail_if (structure == NULL, "Could not get structure from string %s", s);
|
|
|
|
/* FIXME: TODO: add checks for correct serialization of members ? */
|
|
|
|
gst_structure_free (structure);
|
2005-06-22 19:22:34 +00:00
|
|
|
}
|
|
|
|
|
2006-05-22 13:34:03 +00:00
|
|
|
GST_END_TEST;
|
|
|
|
|
2009-07-02 11:40:05 +00:00
|
|
|
GST_START_TEST (test_string_properties)
|
|
|
|
{
|
|
|
|
GstStructure *st1, *st2;
|
2016-12-21 09:02:45 +00:00
|
|
|
gchar *str;
|
2009-07-02 11:40:05 +00:00
|
|
|
|
|
|
|
/* test escaping/unescaping */
|
|
|
|
st1 = gst_structure_new ("RandomStructure", "prop1", G_TYPE_STRING, "foo",
|
|
|
|
"prop2", G_TYPE_STRING, "", "prop3", G_TYPE_STRING, NULL,
|
|
|
|
"prop4", G_TYPE_STRING, "NULL", NULL);
|
|
|
|
str = gst_structure_to_string (st1);
|
|
|
|
st2 = gst_structure_from_string (str, NULL);
|
|
|
|
g_free (str);
|
|
|
|
|
|
|
|
fail_unless (st2 != NULL);
|
2016-12-21 09:02:45 +00:00
|
|
|
fail_unless (gst_structure_is_equal (st1, st2),
|
|
|
|
"Structures did not match:\n\tStructure 1: %" GST_PTR_FORMAT
|
|
|
|
"\n\tStructure 2: %" GST_PTR_FORMAT "\n", st1, st2);
|
2009-07-02 11:40:05 +00:00
|
|
|
|
2016-12-21 09:02:45 +00:00
|
|
|
gst_structure_free (st1);
|
|
|
|
gst_structure_free (st2);
|
2009-07-02 11:40:05 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2005-07-12 16:28:36 +00:00
|
|
|
GST_START_TEST (test_structure_new)
|
|
|
|
{
|
|
|
|
GstStructure *s;
|
|
|
|
GError *e;
|
|
|
|
GQuark domain;
|
2006-07-02 08:26:48 +00:00
|
|
|
gboolean bool;
|
|
|
|
gint num, den;
|
|
|
|
GstClockTime clocktime;
|
2014-02-25 14:41:45 +00:00
|
|
|
guint64 uint64;
|
2006-07-02 08:26:48 +00:00
|
|
|
|
|
|
|
s = gst_structure_new ("name",
|
|
|
|
"key", G_TYPE_STRING, "value",
|
|
|
|
"bool", G_TYPE_BOOLEAN, TRUE,
|
|
|
|
"fraction", GST_TYPE_FRACTION, 1, 5,
|
2014-02-25 14:41:45 +00:00
|
|
|
"clocktime", GST_TYPE_CLOCK_TIME, GST_CLOCK_TIME_NONE,
|
|
|
|
"uint64", G_TYPE_UINT64, (guint64) 1234, NULL);
|
2006-07-02 08:26:48 +00:00
|
|
|
|
|
|
|
fail_unless (gst_structure_get_field_type (s, "unknown") == G_TYPE_INVALID);
|
|
|
|
/* test setting a different name */
|
|
|
|
gst_structure_set_name (s, "newname");
|
2005-07-12 16:28:36 +00:00
|
|
|
fail_unless (strcmp (gst_structure_get_string (s, "key"), "value") == 0);
|
2006-07-02 08:26:48 +00:00
|
|
|
fail_unless (gst_structure_has_field (s, "key"));
|
2014-02-25 14:41:45 +00:00
|
|
|
fail_unless_equals_int (gst_structure_n_fields (s), 5);
|
2006-07-02 08:26:48 +00:00
|
|
|
/* test removing a field */
|
|
|
|
gst_structure_remove_field (s, "key");
|
|
|
|
fail_if (gst_structure_get_string (s, "key"));
|
|
|
|
fail_if (gst_structure_has_field (s, "key"));
|
2014-02-25 14:41:45 +00:00
|
|
|
fail_unless_equals_int (gst_structure_n_fields (s), 4);
|
2006-07-02 08:26:48 +00:00
|
|
|
|
|
|
|
fail_unless (gst_structure_get_boolean (s, "bool", &bool));
|
|
|
|
fail_unless (bool);
|
|
|
|
|
|
|
|
fail_unless (gst_structure_get_fraction (s, "fraction", &num, &den));
|
|
|
|
fail_unless_equals_int (num, 1);
|
|
|
|
fail_unless_equals_int (den, 5);
|
|
|
|
|
|
|
|
fail_unless (gst_structure_get_clock_time (s, "clocktime", &clocktime));
|
|
|
|
fail_unless_equals_uint64 (clocktime, GST_CLOCK_TIME_NONE);
|
|
|
|
|
2014-02-25 14:41:45 +00:00
|
|
|
fail_unless (gst_structure_get_uint64 (s, "uint64", &uint64));
|
|
|
|
fail_unless_equals_uint64 (uint64, 1234);
|
|
|
|
|
2005-07-12 16:28:36 +00:00
|
|
|
gst_structure_free (s);
|
|
|
|
|
2007-11-17 17:50:21 +00:00
|
|
|
domain = g_quark_from_static_string ("test");
|
2005-07-12 16:28:36 +00:00
|
|
|
e = g_error_new (domain, 0, "a test error");
|
2012-01-22 01:39:49 +00:00
|
|
|
s = gst_structure_new ("name", "key", G_TYPE_ERROR, e, NULL);
|
2005-07-12 16:28:36 +00:00
|
|
|
g_error_free (e);
|
|
|
|
gst_structure_free (s);
|
2007-12-08 12:54:53 +00:00
|
|
|
|
2011-10-29 07:02:00 +00:00
|
|
|
ASSERT_CRITICAL (gst_structure_free (gst_structure_new_empty
|
2011-10-27 14:51:16 +00:00
|
|
|
("0.10:decoder-video/mpeg")));
|
2007-12-08 12:54:53 +00:00
|
|
|
|
|
|
|
/* make sure we bail out correctly in case of an error or if parsing fails */
|
2018-11-06 09:20:17 +00:00
|
|
|
s = NULL;
|
2007-12-08 12:54:53 +00:00
|
|
|
ASSERT_CRITICAL (s = gst_structure_new ("^joo\nba\ndoo^",
|
|
|
|
"abc", G_TYPE_BOOLEAN, FALSE, NULL));
|
|
|
|
fail_unless (s == NULL);
|
2005-07-12 16:28:36 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2006-07-02 08:26:48 +00:00
|
|
|
GST_START_TEST (test_fixate)
|
|
|
|
{
|
|
|
|
GstStructure *s;
|
2019-01-09 13:01:02 +00:00
|
|
|
gint i;
|
2006-07-02 08:26:48 +00:00
|
|
|
|
|
|
|
s = gst_structure_new ("name",
|
|
|
|
"int", G_TYPE_INT, 5,
|
2019-01-09 13:01:02 +00:00
|
|
|
"intrange", GST_TYPE_INT_RANGE, 10, 20,
|
|
|
|
"intrange2", GST_TYPE_INT_RANGE, 10, 20,
|
|
|
|
"intrange3", GST_TYPE_INT_RANGE, 10, 20, NULL);
|
2006-07-02 08:26:48 +00:00
|
|
|
|
2019-01-09 13:01:02 +00:00
|
|
|
/* basic test */
|
2006-07-02 08:26:48 +00:00
|
|
|
fail_if (gst_structure_fixate_field_nearest_int (s, "int", 5));
|
2019-01-09 13:01:02 +00:00
|
|
|
fail_unless (gst_structure_fixate_field_nearest_int (s, "intrange", 15));
|
|
|
|
fail_if (gst_structure_fixate_field_nearest_int (s, "intrange", 15));
|
|
|
|
fail_unless (gst_structure_get_int (s, "intrange", &i));
|
|
|
|
fail_unless_equals_int (i, 15);
|
|
|
|
|
|
|
|
/* test range min */
|
|
|
|
fail_unless (gst_structure_fixate_field_nearest_int (s, "intrange2", 5));
|
|
|
|
fail_unless (gst_structure_get_int (s, "intrange2", &i));
|
|
|
|
fail_unless_equals_int (i, 10);
|
|
|
|
|
|
|
|
/* test range max */
|
|
|
|
fail_unless (gst_structure_fixate_field_nearest_int (s, "intrange3", 25));
|
|
|
|
fail_unless (gst_structure_get_int (s, "intrange3", &i));
|
|
|
|
fail_unless_equals_int (i, 20);
|
|
|
|
|
|
|
|
gst_structure_free (s);
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
|
|
GST_START_TEST (test_fixate_stepped)
|
|
|
|
{
|
|
|
|
GstStructure *s;
|
|
|
|
GValue v = G_VALUE_INIT;
|
|
|
|
gint i;
|
|
|
|
|
|
|
|
s = gst_structure_new_empty ("name");
|
|
|
|
|
|
|
|
g_value_init (&v, GST_TYPE_INT_RANGE);
|
|
|
|
gst_value_set_int_range_step (&v, 10, 20, 5);
|
|
|
|
gst_structure_set_value (s, "intrange1", &v);
|
|
|
|
gst_structure_set_value (s, "intrange2", &v);
|
|
|
|
gst_structure_set_value (s, "intrange3", &v);
|
|
|
|
g_value_unset (&v);
|
|
|
|
|
|
|
|
/* exact */
|
|
|
|
fail_unless (gst_structure_fixate_field_nearest_int (s, "intrange1", 15));
|
|
|
|
fail_unless (gst_structure_get_int (s, "intrange1", &i));
|
|
|
|
fail_unless_equals_int (i, 15);
|
|
|
|
|
|
|
|
/* round down */
|
|
|
|
fail_unless (gst_structure_fixate_field_nearest_int (s, "intrange2", 12));
|
|
|
|
fail_unless (gst_structure_get_int (s, "intrange2", &i));
|
|
|
|
fail_unless_equals_int (i, 10);
|
|
|
|
|
|
|
|
/* round up */
|
|
|
|
fail_unless (gst_structure_fixate_field_nearest_int (s, "intrange3", 13));
|
|
|
|
fail_unless (gst_structure_get_int (s, "intrange3", &i));
|
|
|
|
fail_unless_equals_int (i, 15);
|
|
|
|
|
2006-07-02 08:26:48 +00:00
|
|
|
gst_structure_free (s);
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2007-09-05 01:00:50 +00:00
|
|
|
GST_START_TEST (test_fixate_frac_list)
|
|
|
|
{
|
2008-08-05 15:03:27 +00:00
|
|
|
GstStructure *s, *s2;
|
2007-09-05 01:00:50 +00:00
|
|
|
GValue list = { 0 };
|
|
|
|
GValue frac = { 0 };
|
|
|
|
gchar *str;
|
|
|
|
gint num, denom;
|
|
|
|
|
|
|
|
g_value_init (&list, GST_TYPE_LIST);
|
|
|
|
g_value_init (&frac, GST_TYPE_FRACTION);
|
|
|
|
|
|
|
|
gst_value_set_fraction (&frac, 30, 1);
|
|
|
|
gst_value_list_append_value (&list, &frac);
|
|
|
|
gst_value_set_fraction (&frac, 15, 1);
|
|
|
|
gst_value_list_append_value (&list, &frac);
|
|
|
|
gst_value_set_fraction (&frac, 10, 1);
|
|
|
|
gst_value_list_append_value (&list, &frac);
|
|
|
|
|
2011-10-29 07:02:00 +00:00
|
|
|
s = gst_structure_new_empty ("name");
|
2007-09-05 01:00:50 +00:00
|
|
|
gst_structure_set_value (s, "frac", &list);
|
|
|
|
g_value_unset (&frac);
|
|
|
|
g_value_unset (&list);
|
|
|
|
|
|
|
|
str = gst_structure_to_string (s);
|
|
|
|
GST_DEBUG ("list %s", str);
|
|
|
|
g_free (str);
|
|
|
|
|
2008-08-05 15:03:27 +00:00
|
|
|
/* take copy */
|
|
|
|
s2 = gst_structure_copy (s);
|
|
|
|
|
2007-09-05 01:00:50 +00:00
|
|
|
/* fixate to the nearest fraction, this should give 15/1 */
|
|
|
|
fail_unless (gst_structure_fixate_field_nearest_fraction (s, "frac", 14, 1));
|
|
|
|
|
|
|
|
fail_unless (gst_structure_get_fraction (s, "frac", &num, &denom));
|
|
|
|
fail_unless (num == 15);
|
|
|
|
fail_unless (denom == 1);
|
|
|
|
|
|
|
|
gst_structure_free (s);
|
2008-08-05 15:03:27 +00:00
|
|
|
s = s2;
|
|
|
|
|
|
|
|
/* fixate to the nearest fraction, this should give 30/1 */
|
|
|
|
fail_unless (gst_structure_fixate_field_nearest_fraction (s, "frac", G_MAXINT,
|
|
|
|
1));
|
|
|
|
|
|
|
|
fail_unless (gst_structure_get_fraction (s, "frac", &num, &denom));
|
|
|
|
fail_unless (num == 30);
|
|
|
|
fail_unless (denom == 1);
|
|
|
|
gst_structure_free (s);
|
2007-09-05 01:00:50 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
2006-07-02 08:26:48 +00:00
|
|
|
|
2016-12-08 04:41:40 +00:00
|
|
|
GST_START_TEST (test_is_subset_equal_array_list)
|
2011-11-09 10:24:26 +00:00
|
|
|
{
|
|
|
|
GstStructure *s1, *s2;
|
|
|
|
|
|
|
|
s1 = gst_structure_from_string ("test/test, channels=(int){ 1, 2 }", NULL);
|
|
|
|
fail_if (s1 == NULL);
|
|
|
|
s2 = gst_structure_from_string ("test/test, channels=(int)[ 1, 2 ]", NULL);
|
|
|
|
fail_if (s2 == NULL);
|
|
|
|
|
|
|
|
fail_unless (gst_structure_is_subset (s1, s2));
|
|
|
|
|
|
|
|
gst_structure_free (s1);
|
|
|
|
gst_structure_free (s2);
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2016-12-08 04:41:40 +00:00
|
|
|
GST_START_TEST (test_is_subset_different_name)
|
|
|
|
{
|
|
|
|
GstStructure *s1, *s2;
|
|
|
|
|
|
|
|
s1 = gst_structure_from_string ("test/test, channels=(int)1", NULL);
|
|
|
|
fail_if (s1 == NULL);
|
|
|
|
s2 = gst_structure_from_string ("test/baz, channels=(int)1", NULL);
|
|
|
|
fail_if (s2 == NULL);
|
|
|
|
|
|
|
|
fail_unless (!gst_structure_is_subset (s1, s2));
|
|
|
|
|
|
|
|
gst_structure_free (s1);
|
|
|
|
gst_structure_free (s2);
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
|
|
GST_START_TEST (test_is_subset_superset_missing_fields)
|
|
|
|
{
|
|
|
|
GstStructure *s1, *s2;
|
|
|
|
|
|
|
|
/* a missing field is equivalent to any value */
|
|
|
|
s1 = gst_structure_from_string ("test/test, channels=(int)1, rate=(int)1",
|
|
|
|
NULL);
|
|
|
|
fail_if (s1 == NULL);
|
|
|
|
s2 = gst_structure_from_string ("test/test, channels=(int)1", NULL);
|
|
|
|
fail_if (s2 == NULL);
|
|
|
|
|
|
|
|
fail_unless (gst_structure_is_subset (s1, s2));
|
|
|
|
|
|
|
|
gst_structure_free (s1);
|
|
|
|
gst_structure_free (s2);
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
|
|
GST_START_TEST (test_is_subset_superset_extra_fields)
|
|
|
|
{
|
|
|
|
GstStructure *s1, *s2;
|
|
|
|
|
|
|
|
/* a missing field is equivalent to any value */
|
|
|
|
s1 = gst_structure_from_string ("test/test, channels=(int)1", NULL);
|
|
|
|
fail_if (s1 == NULL);
|
|
|
|
s2 = gst_structure_from_string ("test/test, channels=(int)1, rate=(int)1",
|
|
|
|
NULL);
|
|
|
|
fail_if (s2 == NULL);
|
|
|
|
|
|
|
|
fail_unless (!gst_structure_is_subset (s1, s2));
|
|
|
|
|
|
|
|
gst_structure_free (s1);
|
|
|
|
gst_structure_free (s2);
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
|
|
GST_START_TEST (test_is_subset_superset_extra_values)
|
|
|
|
{
|
|
|
|
GstStructure *s1, *s2;
|
|
|
|
|
|
|
|
s1 = gst_structure_from_string ("test/test, channels=(int)1", NULL);
|
|
|
|
fail_if (s1 == NULL);
|
|
|
|
s2 = gst_structure_from_string ("test/test, channels=(int)[ 1, 2 ]", NULL);
|
|
|
|
fail_if (s2 == NULL);
|
|
|
|
|
|
|
|
fail_unless (gst_structure_is_subset (s1, s2));
|
|
|
|
|
|
|
|
gst_structure_free (s1);
|
|
|
|
gst_structure_free (s2);
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2011-11-09 10:24:26 +00:00
|
|
|
|
2007-10-22 08:53:26 +00:00
|
|
|
GST_START_TEST (test_structure_nested)
|
|
|
|
{
|
|
|
|
GstStructure *sp, *sc1, *sc2;
|
|
|
|
gchar *str;
|
|
|
|
|
2009-06-02 15:36:10 +00:00
|
|
|
sc1 = gst_structure_new ("Camera",
|
|
|
|
"XResolution", G_TYPE_INT, 72, "YResolution", G_TYPE_INT, 73, NULL);
|
2007-10-22 08:53:26 +00:00
|
|
|
fail_unless (sc1 != NULL);
|
|
|
|
|
2009-06-02 15:36:10 +00:00
|
|
|
sc2 = gst_structure_new ("Image-Data",
|
|
|
|
"Orientation", G_TYPE_STRING, "top-left",
|
|
|
|
"Comment", G_TYPE_STRING, "super photo", NULL);
|
2007-10-22 08:53:26 +00:00
|
|
|
fail_unless (sc2 != NULL);
|
|
|
|
|
|
|
|
sp = gst_structure_new ("Exif", "Camera", GST_TYPE_STRUCTURE, sc1,
|
|
|
|
"Image Data", GST_TYPE_STRUCTURE, sc2, NULL);
|
|
|
|
fail_unless (sp != NULL);
|
|
|
|
|
2009-06-02 15:36:10 +00:00
|
|
|
fail_unless (gst_structure_n_fields (sp) == 2);
|
|
|
|
|
2007-10-22 08:53:26 +00:00
|
|
|
fail_unless (gst_structure_has_field_typed (sp, "Camera",
|
|
|
|
GST_TYPE_STRUCTURE));
|
|
|
|
|
|
|
|
str = gst_structure_to_string (sp);
|
|
|
|
fail_unless (str != NULL);
|
|
|
|
|
2009-06-02 15:36:10 +00:00
|
|
|
GST_DEBUG ("serialized to '%s'", str);
|
|
|
|
|
2007-10-22 08:53:26 +00:00
|
|
|
fail_unless (g_str_equal (str,
|
|
|
|
"Exif"
|
2009-06-02 15:36:10 +00:00
|
|
|
", Camera=(structure)\"Camera\\,\\ XResolution\\=\\(int\\)72\\,\\ YResolution\\=\\(int\\)73\\;\""
|
|
|
|
", Image Data=(structure)\"Image-Data\\,\\ Orientation\\=\\(string\\)top-left\\,\\ Comment\\=\\(string\\)\\\"super\\\\\\ photo\\\"\\;\";"));
|
2007-10-22 08:53:26 +00:00
|
|
|
|
|
|
|
g_free (str);
|
|
|
|
str = NULL;
|
|
|
|
|
|
|
|
gst_structure_free (sc1);
|
|
|
|
gst_structure_free (sc2);
|
|
|
|
gst_structure_free (sp);
|
2009-06-02 15:36:10 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
|
|
GST_START_TEST (test_structure_nested_from_and_to_string)
|
|
|
|
{
|
|
|
|
GstStructure *s;
|
2010-03-03 10:45:38 +00:00
|
|
|
const gchar *str1;
|
|
|
|
gchar *str2, *end = NULL;
|
2009-06-02 15:36:10 +00:00
|
|
|
|
|
|
|
str1 = "main"
|
|
|
|
", main-sub1=(structure)\"type-b\\,\\ machine-type\\=\\(int\\)0\\;\""
|
|
|
|
", main-sub2=(structure)\"type-a\\,\\ plugin-filename\\=\\(string\\)\\\"/home/user/lib/lib\\\\\\ with\\\\\\ spaces.dll\\\"\\,\\ machine-type\\=\\(int\\)1\\;\""
|
|
|
|
", main-sub3=(structure)\"type-b\\,\\ plugin-filename\\=\\(string\\)/home/user/lib/lib_no_spaces.so\\,\\ machine-type\\=\\(int\\)1\\;\""
|
|
|
|
";";
|
2007-10-22 08:53:26 +00:00
|
|
|
|
2009-06-02 15:36:10 +00:00
|
|
|
s = gst_structure_from_string (str1, &end);
|
|
|
|
fail_unless (s != NULL);
|
|
|
|
|
|
|
|
GST_DEBUG ("not parsed part : %s", end);
|
|
|
|
fail_unless (*end == '\0');
|
|
|
|
|
|
|
|
fail_unless (gst_structure_n_fields (s) == 3);
|
|
|
|
|
|
|
|
fail_unless (gst_structure_has_field_typed (s, "main-sub1",
|
|
|
|
GST_TYPE_STRUCTURE));
|
|
|
|
|
|
|
|
str2 = gst_structure_to_string (s);
|
|
|
|
fail_unless (str2 != NULL);
|
|
|
|
|
|
|
|
fail_unless (g_str_equal (str1, str2));
|
|
|
|
|
|
|
|
g_free (str2);
|
|
|
|
|
|
|
|
gst_structure_free (s);
|
2007-10-22 08:53:26 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2020-07-15 02:36:36 +00:00
|
|
|
GST_START_TEST (test_serialize_nested_structures)
|
|
|
|
{
|
|
|
|
GstStructure *s;
|
|
|
|
const gchar *str1;
|
|
|
|
gchar *str2, *end = NULL;
|
|
|
|
|
|
|
|
str1 = "main"
|
|
|
|
", main-sub1=(structure)[type-b, machine-type=(int)0;]"
|
|
|
|
", main-sub2=(structure)[type-a, plugin-filename=(string)\"/home/user/lib/lib\\ with\\ spaces.dll\", machine-type=(int)1;]"
|
|
|
|
", main-sub3=(structure)[type-b, plugin-filename=(string)/home/user/lib/lib_no_spaces.so, machine-type=(int)1;]"
|
|
|
|
";";
|
|
|
|
|
|
|
|
s = gst_structure_from_string (str1, &end);
|
|
|
|
fail_unless (s != NULL);
|
|
|
|
|
|
|
|
GST_DEBUG ("not parsed part : %s", end);
|
|
|
|
fail_unless (*end == '\0');
|
|
|
|
|
|
|
|
fail_unless (gst_structure_n_fields (s) == 3);
|
|
|
|
|
|
|
|
fail_unless (gst_structure_has_field_typed (s, "main-sub1",
|
|
|
|
GST_TYPE_STRUCTURE));
|
|
|
|
|
|
|
|
str2 = gst_structure_serialize (s, GST_SERIALIZE_FLAG_NONE);
|
|
|
|
fail_unless (str2 != NULL);
|
|
|
|
|
|
|
|
fail_unless (g_str_equal (str1, str2));
|
|
|
|
|
|
|
|
g_free (str2);
|
|
|
|
|
|
|
|
gst_structure_free (s);
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2009-06-08 22:43:16 +00:00
|
|
|
GST_START_TEST (test_vararg_getters)
|
|
|
|
{
|
|
|
|
GstStructure *s;
|
|
|
|
GstBuffer *buf, *buf2;
|
|
|
|
gboolean ret;
|
|
|
|
GstCaps *caps, *caps2;
|
2012-01-20 13:23:57 +00:00
|
|
|
GstMapInfo info;
|
2009-06-08 22:43:16 +00:00
|
|
|
gdouble d;
|
|
|
|
gint64 i64;
|
|
|
|
gchar *c;
|
|
|
|
gint i, num, denom;
|
2011-03-21 18:15:27 +00:00
|
|
|
guint8 *data;
|
2009-06-08 22:43:16 +00:00
|
|
|
|
|
|
|
buf = gst_buffer_new_and_alloc (3);
|
2011-03-21 18:15:27 +00:00
|
|
|
|
2012-01-20 13:23:57 +00:00
|
|
|
fail_unless (gst_buffer_map (buf, &info, GST_MAP_WRITE));
|
|
|
|
data = info.data;
|
2011-03-21 18:15:27 +00:00
|
|
|
data[0] = 0xf0;
|
|
|
|
data[1] = 0x66;
|
|
|
|
data[2] = 0x0d;
|
2012-01-20 13:23:57 +00:00
|
|
|
gst_buffer_unmap (buf, &info);
|
2009-06-08 22:43:16 +00:00
|
|
|
|
2011-10-27 15:09:51 +00:00
|
|
|
caps = gst_caps_new_empty_simple ("video/x-foo");
|
2009-06-08 22:43:16 +00:00
|
|
|
|
|
|
|
s = gst_structure_new ("test", "int", G_TYPE_INT, 12345678, "string",
|
|
|
|
G_TYPE_STRING, "Hello World!", "buf", GST_TYPE_BUFFER, buf, "caps",
|
|
|
|
GST_TYPE_CAPS, caps, "int64", G_TYPE_INT64, G_GINT64_CONSTANT (-99),
|
|
|
|
"double", G_TYPE_DOUBLE, G_MAXDOUBLE, "frag", GST_TYPE_FRACTION, 39, 14,
|
|
|
|
NULL);
|
|
|
|
|
|
|
|
/* first the plain one */
|
|
|
|
ret = gst_structure_get (s, "double", G_TYPE_DOUBLE, &d, "string",
|
|
|
|
G_TYPE_STRING, &c, "caps", GST_TYPE_CAPS, &caps2, "buf",
|
|
|
|
GST_TYPE_BUFFER, &buf2, "frag", GST_TYPE_FRACTION, &num, &denom, "int",
|
|
|
|
G_TYPE_INT, &i, "int64", G_TYPE_INT64, &i64, NULL);
|
|
|
|
|
|
|
|
fail_unless (ret);
|
|
|
|
fail_unless_equals_string (c, "Hello World!");
|
|
|
|
fail_unless_equals_int (i, 12345678);
|
|
|
|
fail_unless_equals_float (d, G_MAXDOUBLE);
|
|
|
|
fail_unless_equals_int (num, 39);
|
|
|
|
fail_unless_equals_int (denom, 14);
|
|
|
|
fail_unless (i64 == -99);
|
|
|
|
fail_unless (caps == caps2);
|
|
|
|
fail_unless (buf == buf2);
|
|
|
|
|
|
|
|
/* expected failures */
|
|
|
|
ASSERT_CRITICAL (gst_structure_get (s, NULL, G_TYPE_INT, &i, NULL));
|
|
|
|
fail_if (gst_structure_get (s, "int", G_TYPE_INT, &i, "double",
|
|
|
|
G_TYPE_FLOAT, &d, NULL));
|
|
|
|
fail_if (gst_structure_get (s, "int", G_TYPE_INT, &i, "dooble",
|
|
|
|
G_TYPE_DOUBLE, &d, NULL));
|
|
|
|
|
|
|
|
g_free (c);
|
|
|
|
c = NULL;
|
|
|
|
gst_caps_unref (caps2);
|
|
|
|
caps2 = NULL;
|
|
|
|
gst_buffer_unref (buf2);
|
|
|
|
buf2 = NULL;
|
|
|
|
|
|
|
|
/* and now the _id variant */
|
|
|
|
ret = gst_structure_id_get (s, g_quark_from_static_string ("double"),
|
|
|
|
G_TYPE_DOUBLE, &d, g_quark_from_static_string ("string"), G_TYPE_STRING,
|
|
|
|
&c, g_quark_from_static_string ("caps"), GST_TYPE_CAPS, &caps2,
|
|
|
|
g_quark_from_static_string ("buf"), GST_TYPE_BUFFER, &buf2,
|
|
|
|
g_quark_from_static_string ("int"), G_TYPE_INT, &i,
|
|
|
|
g_quark_from_static_string ("int64"), G_TYPE_INT64, &i64, NULL);
|
|
|
|
|
|
|
|
fail_unless (ret);
|
|
|
|
fail_unless_equals_string (c, "Hello World!");
|
|
|
|
fail_unless_equals_int (i, 12345678);
|
|
|
|
fail_unless_equals_float (d, G_MAXDOUBLE);
|
|
|
|
fail_unless (i64 == -99);
|
|
|
|
fail_unless (caps == caps2);
|
|
|
|
fail_unless (buf == buf2);
|
|
|
|
|
|
|
|
/* expected failures */
|
|
|
|
ASSERT_CRITICAL (gst_structure_get (s, 0, G_TYPE_INT, &i, NULL));
|
|
|
|
fail_if (gst_structure_id_get (s, g_quark_from_static_string ("int"),
|
|
|
|
G_TYPE_INT, &i, g_quark_from_static_string ("double"), G_TYPE_FLOAT,
|
|
|
|
&d, NULL));
|
|
|
|
fail_if (gst_structure_id_get (s, g_quark_from_static_string ("int"),
|
|
|
|
G_TYPE_INT, &i, g_quark_from_static_string ("dooble"), G_TYPE_DOUBLE,
|
|
|
|
&d, NULL));
|
|
|
|
|
|
|
|
g_free (c);
|
|
|
|
gst_caps_unref (caps2);
|
|
|
|
gst_buffer_unref (buf2);
|
|
|
|
|
|
|
|
/* finally make sure NULL as return location is handled gracefully */
|
|
|
|
ret = gst_structure_get (s, "double", G_TYPE_DOUBLE, NULL, "string",
|
|
|
|
G_TYPE_STRING, NULL, "caps", GST_TYPE_CAPS, NULL, "buf",
|
|
|
|
GST_TYPE_BUFFER, NULL, "int", G_TYPE_INT, &i, "frag", GST_TYPE_FRACTION,
|
|
|
|
NULL, NULL, "int64", G_TYPE_INT64, &i64, NULL);
|
|
|
|
|
|
|
|
ASSERT_WARNING (gst_structure_get (s, "frag", GST_TYPE_FRACTION, NULL,
|
|
|
|
&denom, NULL));
|
|
|
|
ASSERT_WARNING (gst_structure_get (s, "frag", GST_TYPE_FRACTION, &num,
|
|
|
|
NULL, NULL));
|
|
|
|
|
|
|
|
/* clean up */
|
|
|
|
gst_caps_unref (caps);
|
|
|
|
gst_buffer_unref (buf);
|
|
|
|
gst_structure_free (s);
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2014-12-16 17:14:22 +00:00
|
|
|
static gboolean
|
|
|
|
foreach_func (GQuark field_id, const GValue * value, gpointer user_data)
|
|
|
|
{
|
|
|
|
gint *sum = user_data;
|
|
|
|
gint v = 0;
|
|
|
|
|
|
|
|
if (G_VALUE_HOLDS_INT (value))
|
|
|
|
v = g_value_get_int (value);
|
|
|
|
*sum += v;
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_START_TEST (test_foreach)
|
|
|
|
{
|
|
|
|
GstStructure *s;
|
|
|
|
gint sum = 0;
|
|
|
|
|
|
|
|
s = gst_structure_new ("foo/bar", "baz", G_TYPE_INT, 1, "bla", G_TYPE_INT, 3,
|
|
|
|
NULL);
|
|
|
|
fail_unless (gst_structure_foreach (s, foreach_func, &sum));
|
|
|
|
fail_unless_equals_int (sum, 4);
|
|
|
|
gst_structure_free (s);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
|
|
|
static gboolean
|
|
|
|
map_func (GQuark field_id, GValue * value, gpointer user_data)
|
|
|
|
{
|
|
|
|
if (G_VALUE_HOLDS_INT (value))
|
|
|
|
g_value_set_int (value, 123);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_START_TEST (test_map_in_place)
|
|
|
|
{
|
|
|
|
GstStructure *s, *s2;
|
|
|
|
|
|
|
|
s = gst_structure_new ("foo/bar", "baz", G_TYPE_INT, 1, "bla", G_TYPE_INT, 3,
|
|
|
|
NULL);
|
|
|
|
s2 = gst_structure_new ("foo/bar", "baz", G_TYPE_INT, 123, "bla", G_TYPE_INT,
|
|
|
|
123, NULL);
|
|
|
|
fail_unless (gst_structure_map_in_place (s, map_func, NULL));
|
|
|
|
fail_unless (gst_structure_is_equal (s, s2));
|
|
|
|
gst_structure_free (s);
|
|
|
|
gst_structure_free (s2);
|
|
|
|
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2014-12-16 15:31:21 +00:00
|
|
|
static gboolean
|
|
|
|
filter_map_func (GQuark field_id, GValue * value, gpointer user_data)
|
|
|
|
{
|
|
|
|
if (strcmp (g_quark_to_string (field_id), "bla") == 0)
|
|
|
|
return FALSE;
|
|
|
|
|
|
|
|
if (G_VALUE_HOLDS_INT (value))
|
|
|
|
g_value_set_int (value, 2);
|
|
|
|
|
|
|
|
return TRUE;
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_START_TEST (test_filter_and_map_in_place)
|
|
|
|
{
|
|
|
|
GstStructure *s, *s2;
|
|
|
|
|
|
|
|
s = gst_structure_new ("foo/bar", "baz", G_TYPE_INT, 1, "bla", G_TYPE_INT, 3,
|
|
|
|
NULL);
|
|
|
|
s2 = gst_structure_new ("foo/bar", "baz", G_TYPE_INT, 2, NULL);
|
|
|
|
gst_structure_filter_and_map_in_place (s, filter_map_func, NULL);
|
|
|
|
fail_unless (gst_structure_is_equal (s, s2));
|
|
|
|
gst_structure_free (s);
|
|
|
|
gst_structure_free (s2);
|
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
gstvalue: Add GstFlagSet type
GstFlagSet is a new type designed for negotiating sets
of boolean capabilities flags, consisting of a 32-bit
flags bitfield and 32-bit mask field. The mask field
indicates which of the flags bits an element needs to have
as specific values, and which it doesn't care about.
This allows efficient negotiation of arrays of boolean
capabilities.
The standard serialisation format is FLAGS:MASK, with
flags and mask fields expressed in hexadecimal, however
GstFlagSet has a gst_register_flagset() function, which
associates a new GstFlagSet derived type with an existing
GFlags gtype. When serializing a GstFlagSet with an
associated set of GFlags, it also serializes a human-readable
form of the flags for easier debugging.
It is possible to parse a GFlags style serialisation of a
flagset, without the hex portion on the front. ie,
+flag1/flag2/flag3+flag4, to indicate that
flag1 & flag4 must be set, and flag2/flag3 must be unset,
and any other flags are don't-care.
https://bugzilla.gnome.org/show_bug.cgi?id=746373
2015-05-25 06:23:33 +00:00
|
|
|
GST_START_TEST (test_flagset)
|
|
|
|
{
|
|
|
|
GstStructure *s;
|
|
|
|
GType test_flagset_type;
|
|
|
|
guint test_flags =
|
|
|
|
GST_SEEK_FLAG_FLUSH | GST_SEEK_FLAG_SKIP | GST_SEEK_FLAG_SNAP_AFTER;
|
|
|
|
guint test_mask = GST_FLAG_SET_MASK_EXACT;
|
|
|
|
guint out_flags, out_mask;
|
|
|
|
|
|
|
|
test_flagset_type = gst_flagset_register (GST_TYPE_SEEK_FLAGS);
|
|
|
|
fail_unless (g_type_is_a (test_flagset_type, GST_TYPE_FLAG_SET));
|
|
|
|
|
|
|
|
/* Check that we can retrieve a non-standard flagset from the structure */
|
|
|
|
s = gst_structure_new ("test-struct", "test-flagset", test_flagset_type,
|
|
|
|
test_flags, test_mask, NULL);
|
|
|
|
fail_unless (gst_structure_get_flagset (s, "test-flagset", &out_flags,
|
|
|
|
&out_mask));
|
|
|
|
|
|
|
|
fail_unless (out_flags == test_flags);
|
|
|
|
fail_unless (out_mask == test_mask);
|
2015-05-30 12:01:09 +00:00
|
|
|
gst_structure_free (s);
|
gstvalue: Add GstFlagSet type
GstFlagSet is a new type designed for negotiating sets
of boolean capabilities flags, consisting of a 32-bit
flags bitfield and 32-bit mask field. The mask field
indicates which of the flags bits an element needs to have
as specific values, and which it doesn't care about.
This allows efficient negotiation of arrays of boolean
capabilities.
The standard serialisation format is FLAGS:MASK, with
flags and mask fields expressed in hexadecimal, however
GstFlagSet has a gst_register_flagset() function, which
associates a new GstFlagSet derived type with an existing
GFlags gtype. When serializing a GstFlagSet with an
associated set of GFlags, it also serializes a human-readable
form of the flags for easier debugging.
It is possible to parse a GFlags style serialisation of a
flagset, without the hex portion on the front. ie,
+flag1/flag2/flag3+flag4, to indicate that
flag1 & flag4 must be set, and flag2/flag3 must be unset,
and any other flags are don't-care.
https://bugzilla.gnome.org/show_bug.cgi?id=746373
2015-05-25 06:23:33 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
GST_END_TEST;
|
|
|
|
|
2008-02-29 13:59:24 +00:00
|
|
|
static Suite *
|
2005-07-12 16:28:36 +00:00
|
|
|
gst_structure_suite (void)
|
|
|
|
{
|
|
|
|
Suite *s = suite_create ("GstStructure");
|
|
|
|
TCase *tc_chain = tcase_create ("general");
|
|
|
|
|
|
|
|
suite_add_tcase (s, tc_chain);
|
|
|
|
tcase_add_test (tc_chain, test_from_string_int);
|
2010-03-23 19:23:22 +00:00
|
|
|
tcase_add_test (tc_chain, test_from_string_uint);
|
2005-11-22 12:35:42 +00:00
|
|
|
tcase_add_test (tc_chain, test_from_string);
|
2007-10-16 06:32:07 +00:00
|
|
|
tcase_add_test (tc_chain, test_to_string);
|
2007-10-15 11:58:16 +00:00
|
|
|
tcase_add_test (tc_chain, test_to_from_string);
|
2014-07-14 21:25:50 +00:00
|
|
|
tcase_add_test (tc_chain, test_to_from_string_tag_event);
|
2009-07-02 11:40:05 +00:00
|
|
|
tcase_add_test (tc_chain, test_string_properties);
|
2006-05-22 13:34:03 +00:00
|
|
|
tcase_add_test (tc_chain, test_complete_structure);
|
2005-07-12 16:28:36 +00:00
|
|
|
tcase_add_test (tc_chain, test_structure_new);
|
2006-07-02 08:26:48 +00:00
|
|
|
tcase_add_test (tc_chain, test_fixate);
|
2019-01-09 13:01:02 +00:00
|
|
|
tcase_add_test (tc_chain, test_fixate_stepped);
|
2007-09-05 01:00:50 +00:00
|
|
|
tcase_add_test (tc_chain, test_fixate_frac_list);
|
2016-12-08 04:41:40 +00:00
|
|
|
tcase_add_test (tc_chain, test_is_subset_equal_array_list);
|
|
|
|
tcase_add_test (tc_chain, test_is_subset_different_name);
|
|
|
|
tcase_add_test (tc_chain, test_is_subset_superset_missing_fields);
|
|
|
|
tcase_add_test (tc_chain, test_is_subset_superset_extra_fields);
|
|
|
|
tcase_add_test (tc_chain, test_is_subset_superset_extra_values);
|
2007-10-22 08:53:26 +00:00
|
|
|
tcase_add_test (tc_chain, test_structure_nested);
|
2009-06-02 15:36:10 +00:00
|
|
|
tcase_add_test (tc_chain, test_structure_nested_from_and_to_string);
|
2020-07-15 02:36:36 +00:00
|
|
|
tcase_add_test (tc_chain, test_serialize_nested_structures);
|
2009-06-08 22:43:16 +00:00
|
|
|
tcase_add_test (tc_chain, test_vararg_getters);
|
2014-12-16 17:14:22 +00:00
|
|
|
tcase_add_test (tc_chain, test_foreach);
|
|
|
|
tcase_add_test (tc_chain, test_map_in_place);
|
2014-12-16 15:31:21 +00:00
|
|
|
tcase_add_test (tc_chain, test_filter_and_map_in_place);
|
gstvalue: Add GstFlagSet type
GstFlagSet is a new type designed for negotiating sets
of boolean capabilities flags, consisting of a 32-bit
flags bitfield and 32-bit mask field. The mask field
indicates which of the flags bits an element needs to have
as specific values, and which it doesn't care about.
This allows efficient negotiation of arrays of boolean
capabilities.
The standard serialisation format is FLAGS:MASK, with
flags and mask fields expressed in hexadecimal, however
GstFlagSet has a gst_register_flagset() function, which
associates a new GstFlagSet derived type with an existing
GFlags gtype. When serializing a GstFlagSet with an
associated set of GFlags, it also serializes a human-readable
form of the flags for easier debugging.
It is possible to parse a GFlags style serialisation of a
flagset, without the hex portion on the front. ie,
+flag1/flag2/flag3+flag4, to indicate that
flag1 & flag4 must be set, and flag2/flag3 must be unset,
and any other flags are don't-care.
https://bugzilla.gnome.org/show_bug.cgi?id=746373
2015-05-25 06:23:33 +00:00
|
|
|
tcase_add_test (tc_chain, test_flagset);
|
2005-07-12 16:28:36 +00:00
|
|
|
return s;
|
|
|
|
}
|
|
|
|
|
2006-07-01 20:56:56 +00:00
|
|
|
GST_CHECK_MAIN (gst_structure);
|