mirrors/gstreamer
mirrors/gstreamer
1
1
Fork 0
mirror of https://gitlab.freedesktop.org/gstreamer/gstreamer.git synced 2024-12-19 14:56:36 +00:00
Code Issues 1 Projects Releases Wiki Activity

tests: make some tests compile

Browse source
This commit is contained in:
Wim Taymans 2011-03-21 19:15:27 +01:00
parent d82c8bd2af
commit 4a9a59df08
15 changed files with 216 additions and 103 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

8
tests/check/elements/fakesrc.c
View file

@ -117,7 +117,7 @@ GST_START_TEST (test_sizetype_empty)
while (l) {
GstBuffer *buf = l->data;
fail_unless (GST_BUFFER_SIZE (buf) == 0);
fail_unless (gst_buffer_get_size (buf) == 0);
l = l->next;
}
gst_check_drop_buffers ();
@ -155,7 +155,7 @@ GST_START_TEST (test_sizetype_fixed)
while (l) {
GstBuffer *buf = l->data;
fail_unless (GST_BUFFER_SIZE (buf) == 8192);
fail_unless (gst_buffer_get_size (buf) == 8192);
l = l->next;
}
gst_check_drop_buffers ();
@ -194,8 +194,8 @@ GST_START_TEST (test_sizetype_random)
while (l) {
GstBuffer *buf = l->data;
fail_if (GST_BUFFER_SIZE (buf) > 8192);
fail_if (GST_BUFFER_SIZE (buf) < 4096);
fail_if (gst_buffer_get_size (buf) > 8192);
fail_if (gst_buffer_get_size (buf) < 4096);
l = l->next;
}
gst_check_drop_buffers ();

5
tests/check/elements/filesink.c
View file

@ -87,9 +87,12 @@ cleanup_filesink (GstElement * filesink)
G_STMT_START { \
GstBuffer *buf = gst_buffer_new_and_alloc(num_bytes); \
GRand *rand = g_rand_new_with_seed (num_bytes); \
guint8 *data; \
guint i; \
data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE); \
for (i = 0; i < num_bytes; ++i) \
GST_BUFFER_DATA(buf)[i] = (g_rand_int (rand) >> 24) & 0xff; \
data[i] = (g_rand_int (rand) >> 24) & 0xff; \
gst_buffer_unmap (buf, data, num_bytes); \
fail_unless_equals_int (gst_pad_push (mysrcpad, buf), GST_FLOW_OK); \
g_rand_free (rand); \
} G_STMT_END

28
tests/check/elements/filesrc.c
View file

@ -171,6 +171,8 @@ GST_START_TEST (test_pull)
GstPad *pad;
GstFlowReturn ret;
GstBuffer *buffer1, *buffer2;
guint8 *data1, *data2;
gsize size1, size2;
src = setup_filesrc ();
@ -208,16 +210,18 @@ GST_START_TEST (test_pull)
ret = gst_pad_get_range (pad, 0, 100, &buffer1);
fail_unless (ret == GST_FLOW_OK);
fail_unless (buffer1 != NULL);
fail_unless (GST_BUFFER_SIZE (buffer1) == 100);
fail_unless (gst_buffer_get_size (buffer1) == 100);
ret = gst_pad_get_range (pad, 0, 50, &buffer2);
fail_unless (ret == GST_FLOW_OK);
fail_unless (buffer2 != NULL);
fail_unless (GST_BUFFER_SIZE (buffer2) == 50);
fail_unless (gst_buffer_get_size (buffer2) == 50);
/* this should be the same */
fail_unless (memcmp (GST_BUFFER_DATA (buffer1), GST_BUFFER_DATA (buffer2),
50) == 0);
data1 = gst_buffer_map (buffer1, &size1, NULL, GST_MAP_READ);
data2 = gst_buffer_map (buffer2, &size2, NULL, GST_MAP_READ);
fail_unless (memcmp (data1, data2, 50) == 0);
gst_buffer_unmap (buffer2, data2, size2);
gst_buffer_unref (buffer2);
@ -225,12 +229,14 @@ GST_START_TEST (test_pull)
ret = gst_pad_get_range (pad, 50, 50, &buffer2);
fail_unless (ret == GST_FLOW_OK);
fail_unless (buffer2 != NULL);
fail_unless (GST_BUFFER_SIZE (buffer2) == 50);
fail_unless (gst_buffer_get_size (buffer2) == 50);
/* compare with previously read data */
fail_unless (memcmp (GST_BUFFER_DATA (buffer1) + 50,
GST_BUFFER_DATA (buffer2), 50) == 0);
data2 = gst_buffer_map (buffer2, &size2, NULL, GST_MAP_READ);
fail_unless (memcmp (data1, data2, 50) == 0);
gst_buffer_unmap (buffer2, data2, size2);
gst_buffer_unmap (buffer1, data1, size1);
gst_buffer_unref (buffer1);
gst_buffer_unref (buffer2);
@ -238,28 +244,28 @@ GST_START_TEST (test_pull)
ret = gst_pad_get_range (pad, stop - 10, 10, &buffer1);
fail_unless (ret == GST_FLOW_OK);
fail_unless (buffer1 != NULL);
fail_unless (GST_BUFFER_SIZE (buffer1) == 10);
fail_unless (gst_buffer_get_size (buffer1) == 10);
gst_buffer_unref (buffer1);
/* read 20 bytes at end-10 should give exactly 10 bytes */
ret = gst_pad_get_range (pad, stop - 10, 20, &buffer1);
fail_unless (ret == GST_FLOW_OK);
fail_unless (buffer1 != NULL);
fail_unless (GST_BUFFER_SIZE (buffer1) == 10);
fail_unless (gst_buffer_get_size (buffer1) == 10);
gst_buffer_unref (buffer1);
/* read 0 bytes at end-1 should return 0 bytes */
ret = gst_pad_get_range (pad, stop - 1, 0, &buffer1);
fail_unless (ret == GST_FLOW_OK);
fail_unless (buffer1 != NULL);
fail_unless (GST_BUFFER_SIZE (buffer1) == 0);
fail_unless (gst_buffer_get_size (buffer1) == 0);
gst_buffer_unref (buffer1);
/* read 10 bytes at end-1 should return 1 byte */
ret = gst_pad_get_range (pad, stop - 1, 10, &buffer1);
fail_unless (ret == GST_FLOW_OK);
fail_unless (buffer1 != NULL);
fail_unless (GST_BUFFER_SIZE (buffer1) == 1);
fail_unless (gst_buffer_get_size (buffer1) == 1);
gst_buffer_unref (buffer1);
/* read 0 bytes at end should EOS */

6
tests/check/elements/identity.c
View file

@ -87,6 +87,7 @@ GST_START_TEST (test_one_buffer)
{
GstElement *identity;
GstBuffer *buffer;
gpointer data;
identity = setup_identity ();
fail_unless (gst_element_set_state (identity,
@ -95,7 +96,10 @@ GST_START_TEST (test_one_buffer)
buffer = gst_buffer_new_and_alloc (4);
ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
memcpy (GST_BUFFER_DATA (buffer), "data", 4);
data = gst_buffer_map (buffer, NULL, NULL, GST_MAP_WRITE);
memcpy (data, "data", 4);
gst_buffer_unmap (buffer, data, 4);
/* pushing gives away my reference ... */
fail_unless (gst_pad_push (mysrcpad, buffer) == GST_FLOW_OK,

21
tests/check/elements/multiqueue.c
View file

@ -267,6 +267,8 @@ mq_dummypad_chain (GstPad * sinkpad, GstBuffer * buf)
{
guint32 cur_id;
struct PadData *pad_data;
guint8 *data;
gsize size;
pad_data = gst_pad_get_element_private (sinkpad);
@ -274,9 +276,11 @@ mq_dummypad_chain (GstPad * sinkpad, GstBuffer * buf)
fail_if (pad_data == NULL);
/* Read an ID from the first 4 bytes of the buffer data and check it's
* what we expect */
fail_unless (GST_BUFFER_SIZE (buf) >= 4);
data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
fail_unless (size >= 4);
g_static_mutex_unlock (&_check_lock);
cur_id = GST_READ_UINT32_BE (GST_BUFFER_DATA (buf));
cur_id = GST_READ_UINT32_BE (data);
gst_buffer_unmap (buf, data, size);
g_mutex_lock (pad_data->mutex);
@ -429,6 +433,7 @@ run_output_order_test (gint n_linked)
guint8 cur_pad;
GstBuffer *buf;
GstFlowReturn ret;
gpointer data;
cur_pad = pad_pattern[i % n];
@ -436,7 +441,10 @@ run_output_order_test (gint n_linked)
g_static_mutex_lock (&_check_lock);
fail_if (buf == NULL);
g_static_mutex_unlock (&_check_lock);
GST_WRITE_UINT32_BE (GST_BUFFER_DATA (buf), i + 1);
data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
GST_WRITE_UINT32_BE (data, i + 1);
gst_buffer_unmap (buf, data, 4);
GST_BUFFER_TIMESTAMP (buf) = (i + 1) * GST_SECOND;
ret = gst_pad_push (inputpads[cur_pad], buf);
@ -582,6 +590,7 @@ GST_START_TEST (test_sparse_stream)
GstBuffer *buf;
GstFlowReturn ret;
GstClockTime ts;
gpointer data;
ts = gst_util_uint64_scale_int (GST_SECOND, i, 10);
@ -589,7 +598,11 @@ GST_START_TEST (test_sparse_stream)
g_static_mutex_lock (&_check_lock);
fail_if (buf == NULL);
g_static_mutex_unlock (&_check_lock);
GST_WRITE_UINT32_BE (GST_BUFFER_DATA (buf), i + 1);
data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
GST_WRITE_UINT32_BE (data, i + 1);
gst_buffer_unmap (buf, data, 4);
GST_BUFFER_TIMESTAMP (buf) = gst_util_uint64_scale_int (GST_SECOND, i, 10);
/* If i == 0, also push the buffer to the 2nd pad */

124
tests/check/gst/gstbuffer.c
View file

@ -79,9 +79,17 @@ GST_END_TEST;
GST_START_TEST (test_subbuffer)
{
GstBuffer *buffer, *sub;
gsize size, maxsize, ssize;
guint8 *data, *sdata;
buffer = gst_buffer_new_and_alloc (4);
memset (GST_BUFFER_DATA (buffer), 0, 4);
/* check sizes, buffer starts out empty */
data = gst_buffer_map (buffer, &size, &maxsize, GST_MAP_WRITE);
fail_unless (size == 0, "buffer has wrong size");
fail_unless (maxsize == 4, "buffer has wrong size");
memset (data, 0, 4);
/* set some metadata */
GST_BUFFER_TIMESTAMP (buffer) = 1;
GST_BUFFER_DURATION (buffer) = 2;
@ -90,9 +98,11 @@ GST_START_TEST (test_subbuffer)
sub = gst_buffer_create_sub (buffer, 1, 2);
fail_if (sub == NULL, "create_sub of buffer returned NULL");
fail_unless (GST_BUFFER_SIZE (sub) == 2, "subbuffer has wrong size");
fail_unless (memcmp (GST_BUFFER_DATA (buffer) + 1, GST_BUFFER_DATA (sub),
2) == 0, "subbuffer contains the wrong data");
sdata = gst_buffer_map (sub, &ssize, NULL, GST_MAP_READ);
fail_unless (ssize == 2, "subbuffer has wrong size");
fail_unless (memcmp (data + 1, sdata, 2) == 0,
"subbuffer contains the wrong data");
ASSERT_BUFFER_REFCOUNT (buffer, "parent", 2);
ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
fail_unless (GST_BUFFER_TIMESTAMP (sub) == -1,
@ -101,23 +111,26 @@ GST_START_TEST (test_subbuffer)
fail_unless (GST_BUFFER_OFFSET (sub) == -1, "subbuffer has wrong offset");
fail_unless (GST_BUFFER_OFFSET_END (sub) == -1,
"subbuffer has wrong offset end");
gst_buffer_unmap (sub, sdata, ssize);
gst_buffer_unref (sub);
/* create a subbuffer of size 0 */
sub = gst_buffer_create_sub (buffer, 1, 0);
fail_if (sub == NULL, "create_sub of buffer returned NULL");
fail_unless (GST_BUFFER_SIZE (sub) == 0, "subbuffer has wrong size");
fail_unless (memcmp (GST_BUFFER_DATA (buffer) + 1, GST_BUFFER_DATA (sub),
0) == 0, "subbuffer contains the wrong data");
sdata = gst_buffer_map (sub, &ssize, NULL, GST_MAP_READ);
fail_unless (ssize == 0, "subbuffer has wrong size");
fail_unless (memcmp (data + 1, sdata, 0) == 0,
"subbuffer contains the wrong data");
ASSERT_BUFFER_REFCOUNT (buffer, "parent", 2);
ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
gst_buffer_unmap (sub, sdata, ssize);
gst_buffer_unref (sub);
/* test if metadata is coppied, not a complete buffer copy so only the
* timestamp and offset fields are copied. */
sub = gst_buffer_create_sub (buffer, 0, 1);
fail_if (sub == NULL, "create_sub of buffer returned NULL");
fail_unless (GST_BUFFER_SIZE (sub) == 1, "subbuffer has wrong size");
fail_unless (gst_buffer_get_size (sub) == 1, "subbuffer has wrong size");
fail_unless (GST_BUFFER_TIMESTAMP (sub) == 1,
"subbuffer has wrong timestamp");
fail_unless (GST_BUFFER_OFFSET (sub) == 3, "subbuffer has wrong offset");
@ -130,7 +143,7 @@ GST_START_TEST (test_subbuffer)
* fields should be copied. */
sub = gst_buffer_create_sub (buffer, 0, 4);
fail_if (sub == NULL, "create_sub of buffer returned NULL");
fail_unless (GST_BUFFER_SIZE (sub) == 4, "subbuffer has wrong size");
fail_unless (gst_buffer_get_size (sub) == 4, "subbuffer has wrong size");
fail_unless (GST_BUFFER_TIMESTAMP (sub) == 1,
"subbuffer has wrong timestamp");
fail_unless (GST_BUFFER_DURATION (sub) == 2, "subbuffer has wrong duration");
@ -140,6 +153,8 @@ GST_START_TEST (test_subbuffer)
/* clean up */
gst_buffer_unref (sub);
gst_buffer_unmap (buffer, data, size);
gst_buffer_unref (buffer);
}
@ -177,9 +192,14 @@ GST_END_TEST;
GST_START_TEST (test_span)
{
GstBuffer *buffer, *sub1, *sub2, *span;
guint8 *data;
gsize size;
buffer = gst_buffer_new_and_alloc (4);
memcpy (GST_BUFFER_DATA (buffer), "data", 4);
data = gst_buffer_map (buffer, &size, NULL, GST_MAP_WRITE);
memcpy (data, "data", 4);
gst_buffer_unmap (buffer, data, 4);
ASSERT_CRITICAL (gst_buffer_span (NULL, 1, NULL, 2));
ASSERT_CRITICAL (gst_buffer_span (buffer, 1, NULL, 2));
@ -198,48 +218,56 @@ GST_START_TEST (test_span)
/* span will create a new subbuffer from the parent */
span = gst_buffer_span (sub1, 0, sub2, 4);
fail_unless (GST_BUFFER_SIZE (span) == 4, "spanned buffer is wrong size");
data = gst_buffer_map (span, &size, NULL, GST_MAP_READ);
fail_unless (size == 4, "spanned buffer is wrong size");
ASSERT_BUFFER_REFCOUNT (buffer, "parent", 4);
ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
ASSERT_BUFFER_REFCOUNT (span, "span", 1);
fail_unless (memcmp (GST_BUFFER_DATA (span), "data", 4) == 0,
fail_unless (memcmp (data, "data", 4) == 0,
"spanned buffer contains the wrong data");
gst_buffer_unmap (span, data, size);
gst_buffer_unref (span);
ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
/* span from non-contiguous buffers will create new buffers */
span = gst_buffer_span (sub2, 0, sub1, 4);
fail_unless (GST_BUFFER_SIZE (span) == 4, "spanned buffer is wrong size");
data = gst_buffer_map (span, &size, NULL, GST_MAP_READ);
fail_unless (size == 4, "spanned buffer is wrong size");
ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
ASSERT_BUFFER_REFCOUNT (span, "span", 1);
fail_unless (memcmp (GST_BUFFER_DATA (span), "tada", 4) == 0,
fail_unless (memcmp (data, "tada", 4) == 0,
"spanned buffer contains the wrong data");
gst_buffer_unmap (span, data, size);
gst_buffer_unref (span);
ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
/* span with different sizes */
span = gst_buffer_span (sub1, 1, sub2, 3);
fail_unless (GST_BUFFER_SIZE (span) == 3, "spanned buffer is wrong size");
data = gst_buffer_map (span, &size, NULL, GST_MAP_READ);
fail_unless (size == 3, "spanned buffer is wrong size");
ASSERT_BUFFER_REFCOUNT (buffer, "parent", 4);
ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
ASSERT_BUFFER_REFCOUNT (span, "span", 1);
fail_unless (memcmp (GST_BUFFER_DATA (span), "ata", 3) == 0,
fail_unless (memcmp (data, "ata", 3) == 0,
"spanned buffer contains the wrong data");
gst_buffer_unmap (span, data, size);
gst_buffer_unref (span);
ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
span = gst_buffer_span (sub2, 0, sub1, 3);
fail_unless (GST_BUFFER_SIZE (span) == 3, "spanned buffer is wrong size");
data = gst_buffer_map (span, &size, NULL, GST_MAP_READ);
fail_unless (size == 3, "spanned buffer is wrong size");
ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
ASSERT_BUFFER_REFCOUNT (span, "span", 1);
fail_unless (memcmp (GST_BUFFER_DATA (span), "tad", 3) == 0,
fail_unless (memcmp (data, "tad", 3) == 0,
"spanned buffer contains the wrong data");
gst_buffer_unmap (span, data, size);
gst_buffer_unref (span);
ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
@ -262,8 +290,9 @@ create_read_only_buffer (void)
buf = gst_buffer_new ();
/* assign some read-only data to the new buffer */
GST_BUFFER_DATA (buf) = (guint8 *) ro_memory;
GST_BUFFER_SIZE (buf) = sizeof (ro_memory);
gst_buffer_take_memory (buf,
gst_memory_new_wrapped ((gpointer) ro_memory, NULL,
sizeof (ro_memory), 0, sizeof (ro_memory)));
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_READONLY);
@ -273,6 +302,8 @@ create_read_only_buffer (void)
GST_START_TEST (test_make_writable)
{
GstBuffer *buf, *buf2;
guint8 *data;
gsize size;
/* create read-only buffer and make it writable */
buf = create_read_only_buffer ();
@ -281,7 +312,9 @@ GST_START_TEST (test_make_writable)
buf = gst_buffer_make_writable (buf);
fail_unless (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
"writable buffer must not have read-only flag set");
GST_BUFFER_DATA (buf)[4] = 'a';
data = gst_buffer_map (buf, &size, NULL, GST_MAP_WRITE);
data[4] = 'a';
gst_buffer_unmap (buf, data, size);
gst_buffer_unref (buf);
/* alloc'ed buffer with refcount 1 should be writable */
@ -309,6 +342,8 @@ GST_END_TEST;
GST_START_TEST (test_subbuffer_make_writable)
{
GstBuffer *buf, *sub_buf;
guint8 *data;
gsize size;
/* create sub-buffer of read-only buffer and make it writable */
buf = create_read_only_buffer ();
@ -322,7 +357,10 @@ GST_START_TEST (test_subbuffer_make_writable)
sub_buf = gst_buffer_make_writable (sub_buf);
fail_unless (!GST_BUFFER_FLAG_IS_SET (sub_buf, GST_BUFFER_FLAG_READONLY),
"writable buffer must not have read-only flag set");
GST_BUFFER_DATA (sub_buf)[4] = 'a';
data = gst_buffer_map (sub_buf, &size, NULL, GST_MAP_WRITE);
data[4] = 'a';
gst_buffer_unmap (sub_buf, data, size);
gst_buffer_unref (sub_buf);
gst_buffer_unref (buf);
}
@ -381,6 +419,8 @@ GST_END_TEST;
GST_START_TEST (test_copy)
{
GstBuffer *buffer, *copy;
gsize size, ssize;
guint8 *data, *sdata;
buffer = gst_buffer_new_and_alloc (4);
ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
@ -389,21 +429,32 @@ GST_START_TEST (test_copy)
ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
ASSERT_BUFFER_REFCOUNT (copy, "copy", 1);
/* data must be copied and thus point to different memory */
fail_if (GST_BUFFER_DATA (buffer) == GST_BUFFER_DATA (copy));
data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
sdata = gst_buffer_map (copy, &ssize, NULL, GST_MAP_READ);
fail_if (data == sdata);
fail_unless (size == ssize);
gst_buffer_unmap (copy, sdata, ssize);
gst_buffer_unmap (buffer, data, size);
gst_buffer_unref (copy);
gst_buffer_unref (buffer);
/* a 0-sized buffer has NULL data as per docs */
buffer = gst_buffer_new_and_alloc (0);
fail_unless (GST_BUFFER_DATA (buffer) == NULL);
fail_unless (GST_BUFFER_SIZE (buffer) == 0);
data = gst_buffer_map (buffer, &size, NULL, GST_MAP_READ);
fail_unless (data == NULL);
fail_unless (size == 0);
gst_buffer_unmap (buffer, data, size);
/* copying a 0-sized buffer should not crash and also set
* the data member NULL. */
copy = gst_buffer_copy (buffer);
fail_unless (GST_BUFFER_DATA (copy) == NULL);
fail_unless (GST_BUFFER_SIZE (copy) == 0);
data = gst_buffer_map (copy, &size, NULL, GST_MAP_READ);
fail_unless (data == NULL);
fail_unless (size == 0);
gst_buffer_unmap (copy, data, size);
gst_buffer_unref (copy);
gst_buffer_unref (buffer);
@ -414,24 +465,29 @@ GST_END_TEST;
GST_START_TEST (test_try_new_and_alloc)
{
GstBuffer *buf;
gsize size;
guint8 *data;
/* special case: alloc of 0 bytes results in new buffer with NULL data */
buf = gst_buffer_try_new_and_alloc (0);
fail_unless (buf != NULL);
fail_unless (GST_IS_BUFFER (buf));
fail_unless (GST_BUFFER_SIZE (buf) == 0);
fail_unless (GST_BUFFER_DATA (buf) == NULL);
fail_unless (GST_BUFFER_MALLOCDATA (buf) == NULL);
data = gst_buffer_map (buf, &size, NULL, GST_MAP_READ);
fail_unless (data == NULL);
fail_unless (size == 0);
gst_buffer_unmap (buf, data, size);
gst_buffer_unref (buf);
/* normal alloc should still work */
buf = gst_buffer_try_new_and_alloc (640 * 480 * 4);
fail_unless (buf != NULL);
fail_unless (GST_IS_BUFFER (buf));
fail_unless (GST_BUFFER_SIZE (buf) == (640 * 480 * 4));
fail_unless (GST_BUFFER_DATA (buf) != NULL);
fail_unless (GST_BUFFER_MALLOCDATA (buf) != NULL);
GST_BUFFER_DATA (buf)[640 * 479 * 4 + 479] = 0xff;
data = gst_buffer_map (buf, &size, NULL, GST_MAP_WRITE);
fail_unless (data != NULL);
fail_unless (size == (640 * 480 * 4));
data[640 * 479 * 4 + 479] = 0xff;
gst_buffer_unmap (buf, data, size);
gst_buffer_unref (buf);
#if 0

56
tests/check/gst/gstbufferlist.c
View file

@ -47,19 +47,36 @@ cleanup (void)
static GstBuffer *
buffer_from_string (const gchar * str)
{
guint size;
gsize size;
GstBuffer *buf;
gpointer data;
size = strlen (str);
buf = gst_buffer_new_and_alloc (size);
gst_buffer_set_caps (buf, caps);
GST_BUFFER_TIMESTAMP (buf) = TIMESTAMP;
memcpy (GST_BUFFER_DATA (buf), str, size);
GST_BUFFER_SIZE (buf) = size;
data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
memcpy (data, str, size);
gst_buffer_unmap (buf, data, size);
return buf;
}
static void
check_buffer (GstBuffer * buf, gsize size, const gchar * data)
{
gchar *bdata;
gsize bsize, csize, msize;
bdata = gst_buffer_map (buf, &bsize, &msize, GST_META_MAP_READ);
csize = size ? size : bsize;
GST_DEBUG ("%lu %lu %lu", bsize, csize, msize);
fail_unless (bsize == csize);
fail_unless (memcmp (bdata, data, csize) == 0);
gst_buffer_unmap (buf, bdata, bsize);
}
GST_START_TEST (test_add_and_iterate)
{
GstBufferListIterator *it;
@ -546,9 +563,7 @@ GST_START_TEST (test_merge)
gst_buffer_unref (buf);
fail_unless (GST_BUFFER_CAPS (merged_buf) == caps);
fail_unless (GST_BUFFER_TIMESTAMP (merged_buf) == TIMESTAMP);
fail_unless (GST_BUFFER_SIZE (merged_buf) == 3);
fail_unless (memcmp (GST_BUFFER_DATA (merged_buf), "One",
GST_BUFFER_SIZE (merged_buf)) == 0);
check_buffer (merged_buf, 3, "One");
gst_buffer_unref (merged_buf);
/* add another buffer to the same group */
@ -559,17 +574,13 @@ GST_START_TEST (test_merge)
ASSERT_BUFFER_REFCOUNT (merged_buf, "merged_buf", 1);
fail_unless (GST_BUFFER_CAPS (merged_buf) == caps);
fail_unless (GST_BUFFER_TIMESTAMP (merged_buf) == TIMESTAMP);
fail_unless (GST_BUFFER_SIZE (merged_buf) == 8);
fail_unless (memcmp (GST_BUFFER_DATA (merged_buf), "OneGroup",
GST_BUFFER_SIZE (merged_buf)) == 0);
check_buffer (merged_buf, 8, "OneGroup");
/* merging the same group again should return a new buffer with merged data */
buf = gst_buffer_list_iterator_merge_group (merge_it);
ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
fail_unless (buf != merged_buf);
fail_unless (GST_BUFFER_SIZE (buf) == 8);
fail_unless (memcmp (GST_BUFFER_DATA (buf), "OneGroup",
GST_BUFFER_SIZE (buf)) == 0);
check_buffer (buf, 8, "OneGroup");
gst_buffer_unref (buf);
gst_buffer_unref (merged_buf);
@ -583,9 +594,7 @@ GST_START_TEST (test_merge)
ASSERT_BUFFER_REFCOUNT (merged_buf, "merged_buf", 1);
fail_unless (GST_BUFFER_CAPS (merged_buf) == caps);
fail_unless (GST_BUFFER_TIMESTAMP (merged_buf) == TIMESTAMP);
fail_unless (GST_BUFFER_SIZE (merged_buf) == 8);
fail_unless (memcmp (GST_BUFFER_DATA (merged_buf), "OneGroup",
GST_BUFFER_SIZE (merged_buf)) == 0);
check_buffer (merged_buf, 8, "OneGroup");
gst_buffer_unref (merged_buf);
/* merge the second group */
@ -594,9 +603,7 @@ GST_START_TEST (test_merge)
ASSERT_BUFFER_REFCOUNT (merged_buf, "merged_buf", 1);
fail_unless (GST_BUFFER_CAPS (merged_buf) == caps);
fail_unless (GST_BUFFER_TIMESTAMP (merged_buf) == TIMESTAMP);
fail_unless (GST_BUFFER_SIZE (merged_buf) == 12);
fail_unless (memcmp (GST_BUFFER_DATA (merged_buf), "AnotherGroup",
GST_BUFFER_SIZE (merged_buf)) == 0);
check_buffer (merged_buf, 12, "AnotherGroup");
gst_buffer_unref (merged_buf);
gst_buffer_list_iterator_free (merge_it);
@ -609,8 +616,7 @@ GST_START_TEST (test_merge)
buf = gst_buffer_list_iterator_steal (it);
gst_buffer_list_iterator_free (it);
fail_unless (buf != NULL);
fail_unless (memcmp (GST_BUFFER_DATA (buf), "Group",
GST_BUFFER_SIZE (buf)) == 0);
check_buffer (buf, 0, "Group");
gst_buffer_unref (buf);
merge_it = gst_buffer_list_iterate (list);
fail_unless (gst_buffer_list_iterator_next_group (merge_it));
@ -618,9 +624,7 @@ GST_START_TEST (test_merge)
ASSERT_BUFFER_REFCOUNT (merged_buf, "merged_buf", 1);
fail_unless (GST_BUFFER_CAPS (merged_buf) == caps);
fail_unless (GST_BUFFER_TIMESTAMP (merged_buf) == TIMESTAMP);
fail_unless (GST_BUFFER_SIZE (merged_buf) == 3);
fail_unless (memcmp (GST_BUFFER_DATA (merged_buf), "One",
GST_BUFFER_SIZE (merged_buf)) == 0);
check_buffer (merged_buf, 3, "One");
gst_buffer_unref (merged_buf);
/* steal the first buffer too and merge the first group again */
@ -629,8 +633,7 @@ GST_START_TEST (test_merge)
fail_unless (gst_buffer_list_iterator_next (it) != NULL);
buf = gst_buffer_list_iterator_steal (it);
fail_unless (buf != NULL);
fail_unless (memcmp (GST_BUFFER_DATA (buf), "One",
GST_BUFFER_SIZE (buf)) == 0);
check_buffer (buf, 3, "One");
gst_buffer_unref (buf);
gst_buffer_list_iterator_free (it);
fail_unless (gst_buffer_list_iterator_merge_group (merge_it) == NULL);
@ -796,8 +799,7 @@ GST_START_TEST (test_list)
buf = gst_buffer_list_get (list, 0, i);
g_snprintf (name, 10, "%d", i);
fail_unless (memcmp (name, (gchar *) GST_BUFFER_DATA (buf),
GST_BUFFER_SIZE (buf)) == 0);
check_buffer (buf, 0, name);
}
gst_buffer_list_iterator_free (it);
}

7
tests/check/gst/gstelementfactory.c
View file

@ -53,10 +53,9 @@ setup_factory (void)
gst_plugin_feature_set_name (feature, "test");
factory = GST_ELEMENT_FACTORY_CAST (feature);
factory->details.longname = g_strdup ("test");
factory->details.klass = g_strdup ("test");
factory->details.description = g_strdup ("test");
factory->details.author = g_strdup ("test");
#if 0
gst_element_class_set_metadata (factory, "test", "test", "test", "test");
#endif
setup_pad_template (factory, &sink_template);
setup_pad_template (factory, &src_template);

10
tests/check/gst/gstmeta.c
View file

@ -93,7 +93,7 @@ test_transform_func (GstBuffer * transbuf, GstMetaTest * meta,
size = subdata->size;
} else {
offset = 0;
size = GST_BUFFER_SIZE (buffer);
size = gst_buffer_get_size (buffer);
}
GST_DEBUG ("trans called from buffer %p to %p, meta %p, %u-%u", buffer,
@ -104,7 +104,7 @@ test_transform_func (GstBuffer * transbuf, GstMetaTest * meta,
/* same offset, copy timestamps */
test->pts = meta->pts;
test->dts = meta->dts;
if (size == GST_BUFFER_SIZE (buffer)) {
if (size == gst_buffer_get_size (buffer)) {
/* same size, copy duration */
test->duration = meta->duration;
} else {
@ -138,9 +138,13 @@ GST_START_TEST (test_meta_test)
{
GstBuffer *buffer, *copy, *subbuf;
GstMetaTest *meta;
gpointer data;
buffer = gst_buffer_new_and_alloc (4);
memset (GST_BUFFER_DATA (buffer), 0, 4);
data = gst_buffer_map (buffer, NULL, NULL, GST_MAP_WRITE);
memset (data, 0, 4);
gst_buffer_unmap (buffer, data, 4);
/* add some metadata */
meta = GST_META_TEST_ADD (buffer);

2
tests/check/gst/gstminiobject.c
View file

@ -32,7 +32,7 @@ GST_START_TEST (test_copy)
copy = GST_BUFFER (gst_mini_object_copy (GST_MINI_OBJECT_CAST (buffer)));
fail_if (copy == NULL, "Copy of buffer returned NULL");
fail_unless (GST_BUFFER_SIZE (copy) == 4,
fail_unless (gst_buffer_get_size (copy) == 4,
"Copy of buffer has different size");
}

24
tests/check/gst/gstpad.c
View file

@ -404,15 +404,31 @@ buffer_from_string (const gchar * str)
{
guint size;
GstBuffer *buf;
gpointer data;
size = strlen (str);
buf = gst_buffer_new_and_alloc (size);
memcpy (GST_BUFFER_DATA (buf), str, size);
GST_BUFFER_SIZE (buf) = size;
data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
memcpy (data, str, size);
gst_buffer_unmap (buf, data, size);
return buf;
}
static gboolean
buffer_compare (GstBuffer * buf, const gchar * str, gsize size)
{
gboolean res;
gpointer data;
data = gst_buffer_map (buf, NULL, NULL, GST_META_MAP_READ);
res = memcmp (data, str, size) == 0;
gst_buffer_unmap (buf, data, size);
return res;
}
GST_START_TEST (test_push_buffer_list_compat)
{
GstPad *src, *sink;
@ -460,12 +476,12 @@ GST_START_TEST (test_push_buffer_list_compat)
fail_unless_equals_int (g_list_length (buffers), 2);
buffer = GST_BUFFER (buffers->data);
ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
fail_unless (memcmp (GST_BUFFER_DATA (buffer), "ListGroup", 9) == 0);
fail_unless (buffer_compare (buffer, "ListGroup", 9) == 0);
gst_buffer_unref (buffer);
buffers = g_list_delete_link (buffers, buffers);
buffer = GST_BUFFER (buffers->data);
ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
fail_unless (memcmp (GST_BUFFER_DATA (buffer), "AnotherListGroup", 16) == 0);
fail_unless (buffer_compare (buffer, "AnotherListGroup", 16) == 0);
gst_buffer_unref (buffer);
buffers = g_list_delete_link (buffers, buffers);
fail_unless (buffers == NULL);

10
tests/check/gst/gststructure.c
View file

@ -509,11 +509,15 @@ GST_START_TEST (test_vararg_getters)
gint64 i64;
gchar *c;
gint i, num, denom;
guint8 *data;
buf = gst_buffer_new_and_alloc (3);
GST_BUFFER_DATA (buf)[0] = 0xf0;
GST_BUFFER_DATA (buf)[1] = 0x66;
GST_BUFFER_DATA (buf)[2] = 0x0d;
data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
data[0] = 0xf0;
data[1] = 0x66;
data[2] = 0x0d;
gst_buffer_unmap (buf, data, 3);
caps = gst_caps_new_simple ("video/x-foo", NULL);

4
tests/check/gst/gsttag.c
View file

@ -373,8 +373,8 @@ GST_START_TEST (test_buffer_tags)
fail_if (!gst_tag_list_get_buffer_index (tags, GST_TAG_IMAGE, 0, &buf1));
fail_if (!gst_tag_list_get_buffer_index (tags, GST_TAG_PREVIEW_IMAGE, 0,
&buf2));
fail_unless_equals_int (GST_BUFFER_SIZE (buf1), 222);
fail_unless_equals_int (GST_BUFFER_SIZE (buf2), 100);
fail_unless_equals_int (gst_buffer_get_size (buf1), 222);
fail_unless_equals_int (gst_buffer_get_size (buf2), 100);
gst_buffer_unref (buf1);
gst_buffer_unref (buf2);

7
tests/check/gst/gstvalue.c
View file

@ -139,10 +139,15 @@ GST_START_TEST (test_serialize_buffer)
gchar *serialized;
static const char *buf_data = "1234567890abcdef";
gint len;
gpointer data;
len = strlen (buf_data);
buf = gst_buffer_new_and_alloc (len);
memcpy (GST_BUFFER_DATA (buf), buf_data, len);
data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
memcpy (data, buf_data, len);
gst_buffer_unmap (buf, data, len);
ASSERT_MINI_OBJECT_REFCOUNT (buf, "buffer", 1);
/* and assign buffer to mini object */

7
tests/check/libs/typefindhelper.c
View file

@ -54,8 +54,9 @@ GST_START_TEST (test_buffer_range)
buf = gst_buffer_new ();
fail_unless (buf != NULL);
GST_BUFFER_DATA (buf) = (guint8 *) vorbisid;
GST_BUFFER_SIZE (buf) = 30;
gst_buffer_take_memory (buf,
gst_memory_new_wrapped ((gpointer) vorbisid, NULL, 30, 0, 30));
GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_READONLY);
caps = gst_type_find_helper_for_buffer (NULL, buf, NULL);
@ -90,7 +91,7 @@ GST_CHECK_MAIN (gst_typefindhelper);
static void
foobar_typefind (GstTypeFind * tf, gpointer unused)
{
guint8 *data;
const guint8 *data;
data = gst_type_find_peek (tf, 0, 10);
fail_unless (data != NULL);