tests/check/gst/gstbuffer.c

   1 /* GStreamer
   2  *
   3  * unit test for GstBuffer
   4  *
   5  * Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
   6  *
   7  * This library is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU Library General Public
   9  * License as published by the Free Software Foundation; either
  10  * version 2 of the License, or (at your option) any later version.
  11  *
  12  * This library is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  15  * Library General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU Library General Public
  18  * License along with this library; if not, write to the
  19  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  20  * Boston, MA 02111-1307, USA.
  21  */
  22
  23 #ifdef HAVE_CONFIG_H
  24 # include "config.h"
  25 #endif
  26
  27 #ifdef HAVE_VALGRIND_H
  28 # include <valgrind/valgrind.h>
  29 #else
  30 # define RUNNING_ON_VALGRIND FALSE
  31 #endif
  32
  33 #include <gst/check/gstcheck.h>
  34
  35 GST_START_TEST (test_caps)
  36 {
  37   GstBuffer *buffer;
  38   GstCaps *caps, *caps2;
  39
  40   buffer = gst_buffer_new_and_alloc (4);
  41   caps = gst_caps_from_string ("audio/x-raw-int");
  42   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
  43
  44   fail_unless (GST_BUFFER_CAPS (buffer) == NULL);
  45
  46   gst_buffer_set_caps (buffer, caps);
  47   ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
  48
  49   fail_unless (GST_BUFFER_CAPS (buffer) == caps);
  50   ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
  51
  52   fail_unless (gst_buffer_get_caps (buffer) == caps);
  53   gst_caps_unref (caps);
  54   ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
  55
  56   caps2 = gst_caps_from_string ("audio/x-raw-float");
  57   ASSERT_CAPS_REFCOUNT (caps2, "caps2", 1);
  58
  59   gst_buffer_set_caps (buffer, caps2);
  60   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
  61   ASSERT_CAPS_REFCOUNT (caps2, "caps2", 2);
  62
  63   gst_buffer_set_caps (buffer, NULL);
  64   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
  65   ASSERT_CAPS_REFCOUNT (caps2, "caps2", 1);
  66
  67   /* clean up, with caps2 still set as caps */
  68   gst_buffer_set_caps (buffer, caps2);
  69   ASSERT_CAPS_REFCOUNT (caps2, "caps2", 2);
  70   gst_buffer_unref (buffer);
  71   ASSERT_CAPS_REFCOUNT (caps2, "caps2", 1);
  72   gst_caps_unref (caps);
  73   gst_caps_unref (caps2);
  74 }
  75
  76 GST_END_TEST;
  77
  78
  79 GST_START_TEST (test_subbuffer)
  80 {
  81   GstBuffer *buffer, *sub;
  82
  83   buffer = gst_buffer_new_and_alloc (4);
  84   memset (GST_BUFFER_DATA (buffer), 0, 4);
  85   /* set some metadata */
  86   GST_BUFFER_TIMESTAMP (buffer) = 1;
  87   GST_BUFFER_DURATION (buffer) = 2;
  88   GST_BUFFER_OFFSET (buffer) = 3;
  89   GST_BUFFER_OFFSET_END (buffer) = 4;
  90
  91   sub = gst_buffer_create_sub (buffer, 1, 2);
  92   fail_if (sub == NULL, "create_sub of buffer returned NULL");
  93   fail_unless (GST_BUFFER_SIZE (sub) == 2, "subbuffer has wrong size");
  94   fail_unless (memcmp (GST_BUFFER_DATA (buffer) + 1, GST_BUFFER_DATA (sub),
  95           2) == 0, "subbuffer contains the wrong data");
  96   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 2);
  97   ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
  98   fail_unless (GST_BUFFER_TIMESTAMP (sub) == -1,
  99       "subbuffer has wrong timestamp");
 100   fail_unless (GST_BUFFER_DURATION (sub) == -1, "subbuffer has wrong duration");
 101   fail_unless (GST_BUFFER_OFFSET (sub) == -1, "subbuffer has wrong offset");
 102   fail_unless (GST_BUFFER_OFFSET_END (sub) == -1,
 103       "subbuffer has wrong offset end");
 104   gst_buffer_unref (sub);
 105
 106   /* create a subbuffer of size 0 */
 107   sub = gst_buffer_create_sub (buffer, 1, 0);
 108   fail_if (sub == NULL, "create_sub of buffer returned NULL");
 109   fail_unless (GST_BUFFER_SIZE (sub) == 0, "subbuffer has wrong size");
 110   fail_unless (memcmp (GST_BUFFER_DATA (buffer) + 1, GST_BUFFER_DATA (sub),
 111           0) == 0, "subbuffer contains the wrong data");
 112   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 2);
 113   ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
 114   gst_buffer_unref (sub);
 115
 116   /* test if metadata is coppied, not a complete buffer copy so only the
 117    * timestamp and offset fields are copied. */
 118   sub = gst_buffer_create_sub (buffer, 0, 1);
 119   fail_if (sub == NULL, "create_sub of buffer returned NULL");
 120   fail_unless (GST_BUFFER_SIZE (sub) == 1, "subbuffer has wrong size");
 121   fail_unless (GST_BUFFER_TIMESTAMP (sub) == 1,
 122       "subbuffer has wrong timestamp");
 123   fail_unless (GST_BUFFER_OFFSET (sub) == 3, "subbuffer has wrong offset");
 124   fail_unless (GST_BUFFER_DURATION (sub) == -1, "subbuffer has wrong duration");
 125   fail_unless (GST_BUFFER_OFFSET_END (sub) == -1,
 126       "subbuffer has wrong offset end");
 127   gst_buffer_unref (sub);
 128
 129   /* test if metadata is coppied, a complete buffer is copied so all the timing
 130    * fields should be copied. */
 131   sub = gst_buffer_create_sub (buffer, 0, 4);
 132   fail_if (sub == NULL, "create_sub of buffer returned NULL");
 133   fail_unless (GST_BUFFER_SIZE (sub) == 4, "subbuffer has wrong size");
 134   fail_unless (GST_BUFFER_TIMESTAMP (sub) == 1,
 135       "subbuffer has wrong timestamp");
 136   fail_unless (GST_BUFFER_DURATION (sub) == 2, "subbuffer has wrong duration");
 137   fail_unless (GST_BUFFER_OFFSET (sub) == 3, "subbuffer has wrong offset");
 138   fail_unless (GST_BUFFER_OFFSET_END (sub) == 4,
 139       "subbuffer has wrong offset end");
 140
 141   /* clean up */
 142   gst_buffer_unref (sub);
 143   gst_buffer_unref (buffer);
 144 }
 145
 146 GST_END_TEST;
 147
 148 GST_START_TEST (test_is_span_fast)
 149 {
 150   GstBuffer *buffer, *sub1, *sub2;
 151
 152   buffer = gst_buffer_new_and_alloc (4);
 153
 154   sub1 = gst_buffer_create_sub (buffer, 0, 2);
 155   fail_if (sub1 == NULL, "create_sub of buffer returned NULL");
 156
 157   sub2 = gst_buffer_create_sub (buffer, 2, 2);
 158   fail_if (sub2 == NULL, "create_sub of buffer returned NULL");
 159
 160   fail_if (gst_buffer_is_span_fast (buffer, sub2) == TRUE,
 161       "a parent buffer can't be span_fasted");
 162
 163   fail_if (gst_buffer_is_span_fast (sub1, buffer) == TRUE,
 164       "a parent buffer can't be span_fasted");
 165
 166   fail_if (gst_buffer_is_span_fast (sub1, sub2) == FALSE,
 167       "two subbuffers next to each other should be span_fast");
 168
 169   /* clean up */
 170   gst_buffer_unref (sub1);
 171   gst_buffer_unref (sub2);
 172   gst_buffer_unref (buffer);
 173 }
 174
 175 GST_END_TEST;
 176
 177 GST_START_TEST (test_span)
 178 {
 179   GstBuffer *buffer, *sub1, *sub2, *span;
 180
 181   buffer = gst_buffer_new_and_alloc (4);
 182   memcpy (GST_BUFFER_DATA (buffer), "data", 4);
 183
 184   ASSERT_CRITICAL (gst_buffer_span (NULL, 1, NULL, 2));
 185   ASSERT_CRITICAL (gst_buffer_span (buffer, 1, NULL, 2));
 186   ASSERT_CRITICAL (gst_buffer_span (NULL, 1, buffer, 2));
 187   ASSERT_CRITICAL (gst_buffer_span (buffer, 0, buffer, 10));
 188
 189   sub1 = gst_buffer_create_sub (buffer, 0, 2);
 190   fail_if (sub1 == NULL, "create_sub of buffer returned NULL");
 191
 192   sub2 = gst_buffer_create_sub (buffer, 2, 2);
 193   fail_if (sub2 == NULL, "create_sub of buffer returned NULL");
 194
 195   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 196   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 197   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 198
 199   /* span will create a new subbuffer from the parent */
 200   span = gst_buffer_span (sub1, 0, sub2, 4);
 201   fail_unless (GST_BUFFER_SIZE (span) == 4, "spanned buffer is wrong size");
 202   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 4);
 203   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 204   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 205   ASSERT_BUFFER_REFCOUNT (span, "span", 1);
 206   fail_unless (memcmp (GST_BUFFER_DATA (span), "data", 4) == 0,
 207       "spanned buffer contains the wrong data");
 208   gst_buffer_unref (span);
 209   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 210
 211   /* span from non-contiguous buffers will create new buffers */
 212   span = gst_buffer_span (sub2, 0, sub1, 4);
 213   fail_unless (GST_BUFFER_SIZE (span) == 4, "spanned buffer is wrong size");
 214   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 215   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 216   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 217   ASSERT_BUFFER_REFCOUNT (span, "span", 1);
 218   fail_unless (memcmp (GST_BUFFER_DATA (span), "tada", 4) == 0,
 219       "spanned buffer contains the wrong data");
 220   gst_buffer_unref (span);
 221   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 222
 223   /* span with different sizes */
 224   span = gst_buffer_span (sub1, 1, sub2, 3);
 225   fail_unless (GST_BUFFER_SIZE (span) == 3, "spanned buffer is wrong size");
 226   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 4);
 227   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 228   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 229   ASSERT_BUFFER_REFCOUNT (span, "span", 1);
 230   fail_unless (memcmp (GST_BUFFER_DATA (span), "ata", 3) == 0,
 231       "spanned buffer contains the wrong data");
 232   gst_buffer_unref (span);
 233   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 234
 235   span = gst_buffer_span (sub2, 0, sub1, 3);
 236   fail_unless (GST_BUFFER_SIZE (span) == 3, "spanned buffer is wrong size");
 237   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 238   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 239   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 240   ASSERT_BUFFER_REFCOUNT (span, "span", 1);
 241   fail_unless (memcmp (GST_BUFFER_DATA (span), "tad", 3) == 0,
 242       "spanned buffer contains the wrong data");
 243   gst_buffer_unref (span);
 244   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 3);
 245
 246   /* clean up */
 247   gst_buffer_unref (sub1);
 248   gst_buffer_unref (sub2);
 249   gst_buffer_unref (buffer);
 250 }
 251
 252 GST_END_TEST;
 253
 254
 255 static const char ro_memory[] = "abcdefghijklmnopqrstuvwxyz";
 256
 257 static GstBuffer *
 258 create_read_only_buffer (void)
 259 {
 260   GstBuffer *buf;
 261
 262   buf = (GstBuffer *) gst_mini_object_new (GST_TYPE_BUFFER);
 263
 264   /* assign some read-only data to the new buffer */
 265   GST_BUFFER_DATA (buf) = (guint8 *) ro_memory;
 266   GST_BUFFER_SIZE (buf) = sizeof (ro_memory);
 267
 268   GST_BUFFER_FLAG_SET (buf, GST_BUFFER_FLAG_READONLY);
 269
 270   return buf;
 271 }
 272
 273 GST_START_TEST (test_make_writable)
 274 {
 275   GstBuffer *buf, *buf2;
 276
 277   /* create read-only buffer and make it writable */
 278   buf = create_read_only_buffer ();
 279   fail_unless (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
 280       "read-only buffer should have read-only flag set");
 281   buf = gst_buffer_make_writable (buf);
 282   fail_unless (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
 283       "writable buffer must not have read-only flag set");
 284   GST_BUFFER_DATA (buf)[4] = 'a';
 285   gst_buffer_unref (buf);
 286
 287   /* alloc'ed buffer with refcount 1 should be writable */
 288   buf = gst_buffer_new_and_alloc (32);
 289   fail_unless (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
 290       "_new_and_alloc'ed buffer must not have read-only flag set");
 291   buf2 = gst_buffer_make_writable (buf);
 292   fail_unless (buf == buf2,
 293       "_make_writable() should have returned same buffer");
 294   gst_buffer_unref (buf2);
 295
 296   /* alloc'ed buffer with refcount >1 should be copied */
 297   buf = gst_buffer_new_and_alloc (32);
 298   fail_unless (!GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
 299       "_new_and_alloc'ed buffer must not have read-only flag set");
 300   gst_buffer_ref (buf);
 301   buf2 = gst_buffer_make_writable (buf);
 302   fail_unless (buf != buf2, "_make_writable() should have returned a copy!");
 303   gst_buffer_unref (buf2);
 304   gst_buffer_unref (buf);
 305 }
 306
 307 GST_END_TEST;
 308
 309 GST_START_TEST (test_subbuffer_make_writable)
 310 {
 311   GstBuffer *buf, *sub_buf;
 312
 313   /* create sub-buffer of read-only buffer and make it writable */
 314   buf = create_read_only_buffer ();
 315   fail_unless (GST_BUFFER_FLAG_IS_SET (buf, GST_BUFFER_FLAG_READONLY),
 316       "read-only buffer should have read-only flag set");
 317
 318   sub_buf = gst_buffer_create_sub (buf, 0, 8);
 319   fail_unless (GST_BUFFER_FLAG_IS_SET (sub_buf, GST_BUFFER_FLAG_READONLY),
 320       "sub-buffer of read-only buffer should have read-only flag set");
 321
 322   sub_buf = gst_buffer_make_writable (sub_buf);
 323   fail_unless (!GST_BUFFER_FLAG_IS_SET (sub_buf, GST_BUFFER_FLAG_READONLY),
 324       "writable buffer must not have read-only flag set");
 325   GST_BUFFER_DATA (sub_buf)[4] = 'a';
 326   gst_buffer_unref (sub_buf);
 327   gst_buffer_unref (buf);
 328 }
 329
 330 GST_END_TEST;
 331
 332 GST_START_TEST (test_metadata_writable)
 333 {
 334   GstBuffer *buffer, *sub1;
 335
 336   buffer = gst_buffer_new_and_alloc (4);
 337   GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
 338   GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
 339
 340   /* Buffer with refcount 1 should have writable metadata */
 341   fail_unless (gst_buffer_is_metadata_writable (buffer) == TRUE);
 342
 343   /* Check that a buffer with refcount 2 does not have writable metadata */
 344   gst_buffer_ref (buffer);
 345   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 2);
 346   fail_unless (gst_buffer_is_metadata_writable (buffer) == FALSE);
 347
 348   /* Check that make_metadata_writable produces a new sub-buffer with
 349    * writable metadata. */
 350   sub1 = gst_buffer_make_metadata_writable (buffer);
 351   fail_if (sub1 == buffer);
 352   fail_unless (gst_buffer_is_metadata_writable (sub1) == TRUE);
 353
 354   /* Check that the original metadata is still not writable
 355    * (subbuffer should be holding a reference, and so should we) */
 356   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 2);
 357   fail_unless (gst_buffer_is_metadata_writable (buffer) == FALSE);
 358
 359   /* Check that make_metadata_writable() maintains the buffer flags */
 360   fail_unless (GST_BUFFER_FLAG_IS_SET (sub1, GST_BUFFER_FLAG_DISCONT));
 361   fail_unless (GST_BUFFER_FLAG_IS_SET (sub1, GST_BUFFER_FLAG_DELTA_UNIT));
 362
 363   /* Unset flags on writable buffer, then make sure they're still
 364    * set on the original buffer */
 365   GST_BUFFER_FLAG_UNSET (sub1, GST_BUFFER_FLAG_DISCONT);
 366   GST_BUFFER_FLAG_UNSET (sub1, GST_BUFFER_FLAG_DELTA_UNIT);
 367   fail_unless (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT));
 368   fail_unless (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT));
 369
 370   /* Drop the subbuffer and check that the metadata is now writable again */
 371   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 372   gst_buffer_unref (sub1);
 373   fail_unless (gst_buffer_is_metadata_writable (buffer) == TRUE);
 374
 375   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 376   gst_buffer_unref (buffer);
 377 }
 378
 379 GST_END_TEST;
 380
 381 GST_START_TEST (test_copy)
 382 {
 383   GstBuffer *buffer, *copy;
 384
 385   buffer = gst_buffer_new_and_alloc (4);
 386   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 387
 388   copy = gst_buffer_copy (buffer);
 389   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 390   ASSERT_BUFFER_REFCOUNT (copy, "copy", 1);
 391   /* data must be copied and thus point to different memory */
 392   fail_if (GST_BUFFER_DATA (buffer) == GST_BUFFER_DATA (copy));
 393
 394   gst_buffer_unref (copy);
 395   gst_buffer_unref (buffer);
 396
 397   /* a 0-sized buffer has NULL data as per docs */
 398   buffer = gst_buffer_new_and_alloc (0);
 399   fail_unless (GST_BUFFER_DATA (buffer) == NULL);
 400   fail_unless (GST_BUFFER_SIZE (buffer) == 0);
 401
 402   /* copying a 0-sized buffer should not crash and also set
 403    * the data member NULL. */
 404   copy = gst_buffer_copy (buffer);
 405   fail_unless (GST_BUFFER_DATA (copy) == NULL);
 406   fail_unless (GST_BUFFER_SIZE (copy) == 0);
 407
 408   gst_buffer_unref (copy);
 409   gst_buffer_unref (buffer);
 410 }
 411
 412 GST_END_TEST;
 413
 414 GST_START_TEST (test_try_new_and_alloc)
 415 {
 416   GstBuffer *buf;
 417
 418   /* special case: alloc of 0 bytes results in new buffer with NULL data */
 419   buf = gst_buffer_try_new_and_alloc (0);
 420   fail_unless (buf != NULL);
 421   fail_unless (GST_IS_BUFFER (buf));
 422   fail_unless (GST_BUFFER_SIZE (buf) == 0);
 423   fail_unless (GST_BUFFER_DATA (buf) == NULL);
 424   fail_unless (GST_BUFFER_MALLOCDATA (buf) == NULL);
 425   gst_buffer_unref (buf);
 426
 427   /* normal alloc should still work */
 428   buf = gst_buffer_try_new_and_alloc (640 * 480 * 4);
 429   fail_unless (buf != NULL);
 430   fail_unless (GST_IS_BUFFER (buf));
 431   fail_unless (GST_BUFFER_SIZE (buf) == (640 * 480 * 4));
 432   fail_unless (GST_BUFFER_DATA (buf) != NULL);
 433   fail_unless (GST_BUFFER_MALLOCDATA (buf) != NULL);
 434   GST_BUFFER_DATA (buf)[640 * 479 * 4 + 479] = 0xff;
 435   gst_buffer_unref (buf);
 436
 437 #if 0
 438   /* Disabled this part of the test, because it happily succeeds on 64-bit
 439    * machines that have enough memory+swap, because the address space is large
 440    * enough. There's not really any way to test the failure case except by
 441    * allocating chunks of memory until it fails, which would suck. */
 442
 443   /* now this better fail (don't run in valgrind, it will abort
 444    * or warn when passing silly arguments to malloc) */
 445   if (!RUNNING_ON_VALGRIND) {
 446     buf = gst_buffer_try_new_and_alloc ((guint) - 1);
 447     fail_unless (buf == NULL);
 448   }
 449 #endif
 450 }
 451
 452 GST_END_TEST;
 453
 454 GST_START_TEST (test_qdata)
 455 {
 456   GstStructure *s;
 457   GstBuffer *buf, *buf2, *buf3;
 458   GQuark q1, q2, q3;
 459
 460   q1 = g_quark_from_static_string ("GstFooBar");
 461   q2 = g_quark_from_static_string ("MyBorkData");
 462   q3 = g_quark_from_static_string ("DoNotExist");
 463
 464   buf = gst_buffer_new ();
 465   ASSERT_CRITICAL (gst_buffer_set_qdata (buf, q1, (s =
 466               gst_structure_id_empty_new (q2))));
 467   gst_structure_free (s);
 468
 469   gst_buffer_set_qdata (buf, q1, gst_structure_id_empty_new (q1));
 470   gst_buffer_set_qdata (buf, q2, gst_structure_id_empty_new (q2));
 471   fail_unless (gst_buffer_get_qdata (buf, q3) == NULL);
 472   fail_unless (gst_buffer_get_qdata (buf, q1) != NULL);
 473   fail_unless (gst_buffer_get_qdata (buf, q2) != NULL);
 474
 475   /* full copy */
 476   buf2 = gst_buffer_copy (buf);
 477
 478   /* now back to the original buffer... */
 479   gst_buffer_set_qdata (buf, q1, NULL);
 480   fail_unless (gst_buffer_get_qdata (buf, q1) == NULL);
 481
 482   /* force creation of sub-buffer with writable metadata */
 483   gst_buffer_ref (buf);
 484   buf3 = gst_buffer_make_metadata_writable (buf);
 485
 486   /* and check the copies/subbuffers.. */
 487   fail_unless (gst_buffer_get_qdata (buf2, q3) == NULL);
 488   fail_unless (gst_buffer_get_qdata (buf2, q1) != NULL);
 489   fail_unless (gst_buffer_get_qdata (buf2, q2) != NULL);
 490
 491   fail_unless (gst_buffer_get_qdata (buf3, q3) == NULL);
 492   fail_unless (gst_buffer_get_qdata (buf3, q1) == NULL);
 493   fail_unless (gst_buffer_get_qdata (buf3, q2) != NULL);
 494   gst_buffer_set_qdata (buf3, q1, gst_structure_id_empty_new (q1));
 495   fail_unless (gst_buffer_get_qdata (buf3, q1) != NULL);
 496
 497   /* original buffer shouldn't have changed */
 498   fail_unless (gst_buffer_get_qdata (buf, q1) == NULL);
 499
 500   gst_buffer_unref (buf);
 501   gst_buffer_unref (buf2);
 502   gst_buffer_unref (buf3);
 503 }
 504
 505 GST_END_TEST;
 506
 507 static Suite *
 508 gst_buffer_suite (void)
 509 {
 510   Suite *s = suite_create ("GstBuffer");
 511   TCase *tc_chain = tcase_create ("general");
 512
 513   suite_add_tcase (s, tc_chain);
 514   tcase_add_test (tc_chain, test_caps);
 515   tcase_add_test (tc_chain, test_subbuffer);
 516   tcase_add_test (tc_chain, test_subbuffer_make_writable);
 517   tcase_add_test (tc_chain, test_make_writable);
 518   tcase_add_test (tc_chain, test_is_span_fast);
 519   tcase_add_test (tc_chain, test_span);
 520   tcase_add_test (tc_chain, test_metadata_writable);
 521   tcase_add_test (tc_chain, test_copy);
 522   tcase_add_test (tc_chain, test_try_new_and_alloc);
 523   tcase_add_test (tc_chain, test_qdata);
 524
 525   return s;
 526 }
 527
 528 GST_CHECK_MAIN (gst_buffer);