tests: make some tests compile

diff --git a/tests/check/elements/fakesrc.c b/tests/check/elements/fakesrc.c
index 3573be6..4df128a 100644 (file)
--- a/tests/check/elements/fakesrc.c
+++ b/tests/check/elements/fakesrc.c
@@ -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 ();

diff --git a/tests/check/elements/filesink.c b/tests/check/elements/filesink.c
index 3188a7f..838bce1 100644 (file)
--- a/tests/check/elements/filesink.c
+++ b/tests/check/elements/filesink.c
@@ -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

diff --git a/tests/check/elements/filesrc.c b/tests/check/elements/filesrc.c
index 970ca9a..7fd95cb 100644 (file)
--- a/tests/check/elements/filesrc.c
+++ b/tests/check/elements/filesrc.c
@@ -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 */

diff --git a/tests/check/elements/identity.c b/tests/check/elements/identity.c
index b845466..abf428c 100644 (file)
--- a/tests/check/elements/identity.c
+++ b/tests/check/elements/identity.c
@@ -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,

diff --git a/tests/check/elements/multiqueue.c b/tests/check/elements/multiqueue.c
index e885ff3..7e9bd90 100644 (file)
--- a/tests/check/elements/multiqueue.c
+++ b/tests/check/elements/multiqueue.c
@@ -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 */

diff --git a/tests/check/gst/gstbuffer.c b/tests/check/gst/gstbuffer.c
index 01700fd..1fcd9f5 100644 (file)
--- a/tests/check/gst/gstbuffer.c
+++ b/tests/check/gst/gstbuffer.c
@@ -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

diff --git a/tests/check/gst/gstbufferlist.c b/tests/check/gst/gstbufferlist.c
index 0885644..4aeea16 100644 (file)
--- a/tests/check/gst/gstbufferlist.c
+++ b/tests/check/gst/gstbufferlist.c
@@ -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);
 }

diff --git a/tests/check/gst/gstelementfactory.c b/tests/check/gst/gstelementfactory.c
index 25dcfd1..e92e86f 100644 (file)
--- a/tests/check/gst/gstelementfactory.c
+++ b/tests/check/gst/gstelementfactory.c
@@ -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);

diff --git a/tests/check/gst/gstmeta.c b/tests/check/gst/gstmeta.c
index 8a8a0c4..1aa2ca1 100644 (file)
--- a/tests/check/gst/gstmeta.c
+++ b/tests/check/gst/gstmeta.c
@@ -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);

diff --git a/tests/check/gst/gstminiobject.c b/tests/check/gst/gstminiobject.c
index 1635749..cb44e14 100644 (file)
--- a/tests/check/gst/gstminiobject.c
+++ b/tests/check/gst/gstminiobject.c
@@ -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");
 }
 

diff --git a/tests/check/gst/gstpad.c b/tests/check/gst/gstpad.c
index e07c18e..6a5636d 100644 (file)
--- a/tests/check/gst/gstpad.c
+++ b/tests/check/gst/gstpad.c
@@ -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);

diff --git a/tests/check/gst/gststructure.c b/tests/check/gst/gststructure.c
index b37bd24..6e0e937 100644 (file)
--- a/tests/check/gst/gststructure.c
+++ b/tests/check/gst/gststructure.c
@@ -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);
 

diff --git a/tests/check/gst/gsttag.c b/tests/check/gst/gsttag.c
index ecf8223..11249df 100644 (file)
--- a/tests/check/gst/gsttag.c
+++ b/tests/check/gst/gsttag.c
@@ -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);

diff --git a/tests/check/gst/gstvalue.c b/tests/check/gst/gstvalue.c
index befdc03..b27f37c 100644 (file)
--- a/tests/check/gst/gstvalue.c
+++ b/tests/check/gst/gstvalue.c
@@ -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 */

diff --git a/tests/check/libs/typefindhelper.c b/tests/check/libs/typefindhelper.c
index e0ead01..d5b5b4f 100644 (file)
--- a/tests/check/libs/typefindhelper.c
+++ b/tests/check/libs/typefindhelper.c
@@ -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);