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_subbuffer)
  36 {
  37   GstBuffer *buffer, *sub;
  38   GstMapInfo info, sinfo;
  39
  40   buffer = gst_buffer_new_and_alloc (4);
  41
  42   /* check sizes, buffer starts out empty */
  43   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_WRITE));
  44   fail_unless (info.size == 4, "buffer has wrong size");
  45   fail_unless (info.maxsize >= 4, "buffer has wrong size");
  46   memset (info.data, 0, 4);
  47   gst_buffer_unmap (buffer, &info);
  48
  49   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_READ));
  50   /* set some metadata */
  51   GST_BUFFER_TIMESTAMP (buffer) = 1;
  52   GST_BUFFER_DURATION (buffer) = 2;
  53   GST_BUFFER_OFFSET (buffer) = 3;
  54   GST_BUFFER_OFFSET_END (buffer) = 4;
  55
  56   sub = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 1, 2);
  57   fail_if (sub == NULL, "copy region of buffer returned NULL");
  58
  59   fail_unless (gst_buffer_map (sub, &sinfo, GST_MAP_READ));
  60   fail_unless (sinfo.size == 2, "subbuffer has wrong size");
  61   fail_unless (memcmp (info.data + 1, sinfo.data, 2) == 0,
  62       "subbuffer contains the wrong data");
  63   ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
  64   fail_unless (GST_BUFFER_TIMESTAMP (sub) == -1,
  65       "subbuffer has wrong timestamp");
  66   fail_unless (GST_BUFFER_DURATION (sub) == -1, "subbuffer has wrong duration");
  67   fail_unless (GST_BUFFER_OFFSET (sub) == -1, "subbuffer has wrong offset");
  68   fail_unless (GST_BUFFER_OFFSET_END (sub) == -1,
  69       "subbuffer has wrong offset end");
  70   gst_buffer_unmap (sub, &sinfo);
  71   gst_buffer_unref (sub);
  72
  73   /* create a subbuffer of size 0 */
  74   sub = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 1, 0);
  75   fail_if (sub == NULL, "copy_region of buffer returned NULL");
  76   fail_unless (gst_buffer_map (sub, &sinfo, GST_MAP_READ));
  77   fail_unless (sinfo.size == 0, "subbuffer has wrong size");
  78   fail_unless (memcmp (info.data + 1, sinfo.data, 0) == 0,
  79       "subbuffer contains the wrong data");
  80   ASSERT_BUFFER_REFCOUNT (sub, "subbuffer", 1);
  81   gst_buffer_unmap (sub, &sinfo);
  82   gst_buffer_unref (sub);
  83
  84   /* test if metadata is coppied, not a complete buffer copy so only the
  85    * timestamp and offset fields are copied. */
  86   sub = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 0, 1);
  87   fail_if (sub == NULL, "copy_region of buffer returned NULL");
  88   fail_unless (gst_buffer_get_size (sub) == 1, "subbuffer has wrong size");
  89   fail_unless (GST_BUFFER_TIMESTAMP (sub) == 1,
  90       "subbuffer has wrong timestamp");
  91   fail_unless (GST_BUFFER_OFFSET (sub) == 3, "subbuffer has wrong offset");
  92   fail_unless (GST_BUFFER_DURATION (sub) == -1, "subbuffer has wrong duration");
  93   fail_unless (GST_BUFFER_OFFSET_END (sub) == -1,
  94       "subbuffer has wrong offset end");
  95   gst_buffer_unref (sub);
  96
  97   /* test if metadata is coppied, a complete buffer is copied so all the timing
  98    * fields should be copied. */
  99   sub = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 0, 4);
 100   fail_if (sub == NULL, "copy_region of buffer returned NULL");
 101   fail_unless (gst_buffer_get_size (sub) == 4, "subbuffer has wrong size");
 102   fail_unless (GST_BUFFER_TIMESTAMP (sub) == 1,
 103       "subbuffer has wrong timestamp");
 104   fail_unless (GST_BUFFER_DURATION (sub) == 2, "subbuffer has wrong duration");
 105   fail_unless (GST_BUFFER_OFFSET (sub) == 3, "subbuffer has wrong offset");
 106   fail_unless (GST_BUFFER_OFFSET_END (sub) == 4,
 107       "subbuffer has wrong offset end");
 108
 109   /* clean up */
 110   gst_buffer_unref (sub);
 111
 112   gst_buffer_unmap (buffer, &info);
 113   gst_buffer_unref (buffer);
 114 }
 115
 116 GST_END_TEST;
 117
 118 GST_START_TEST (test_span)
 119 {
 120   GstBuffer *buffer, *sub1, *sub2, *span;
 121   GstMapInfo info;
 122
 123   buffer = gst_buffer_new_and_alloc (4);
 124
 125   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_WRITE));
 126   memcpy (info.data, "data", 4);
 127   gst_buffer_unmap (buffer, &info);
 128
 129   ASSERT_CRITICAL (gst_buffer_append (NULL, NULL));
 130   ASSERT_CRITICAL (gst_buffer_append (buffer, NULL));
 131   ASSERT_CRITICAL (gst_buffer_append (NULL, buffer));
 132
 133   sub1 = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 0, 2);
 134   fail_if (sub1 == NULL, "copy_region of buffer returned NULL");
 135
 136   sub2 = gst_buffer_copy_region (buffer, GST_BUFFER_COPY_ALL, 2, 2);
 137   fail_if (sub2 == NULL, "copy_region of buffer returned NULL");
 138
 139   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 1);
 140   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 141   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 142
 143   /* span will create a new subbuffer from the parent */
 144   gst_buffer_ref (sub1);
 145   gst_buffer_ref (sub2);
 146   span = gst_buffer_append (sub1, sub2);
 147   fail_unless (gst_buffer_map (span, &info, GST_MAP_READ));
 148   fail_unless (info.size == 4, "spanned buffer is wrong size");
 149   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 1);
 150   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 151   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 152   ASSERT_BUFFER_REFCOUNT (span, "span", 1);
 153   fail_unless (memcmp (info.data, "data", 4) == 0,
 154       "spanned buffer contains the wrong data");
 155   gst_buffer_unmap (span, &info);
 156   gst_buffer_unref (span);
 157   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 1);
 158
 159   /* span from non-contiguous buffers will create new buffers */
 160   gst_buffer_ref (sub1);
 161   gst_buffer_ref (sub2);
 162   span = gst_buffer_append (sub2, sub1);
 163   fail_unless (gst_buffer_map (span, &info, GST_MAP_READ));
 164   fail_unless (info.size == 4, "spanned buffer is wrong size");
 165   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 1);
 166   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 167   ASSERT_BUFFER_REFCOUNT (sub2, "sub2", 1);
 168   ASSERT_BUFFER_REFCOUNT (span, "span", 1);
 169   fail_unless (memcmp (info.data, "tada", 4) == 0,
 170       "spanned buffer contains the wrong data");
 171   gst_buffer_unmap (span, &info);
 172   gst_buffer_unref (span);
 173   ASSERT_BUFFER_REFCOUNT (buffer, "parent", 1);
 174
 175   /* clean up */
 176   gst_buffer_unref (sub1);
 177   gst_buffer_unref (sub2);
 178   gst_buffer_unref (buffer);
 179 }
 180
 181 GST_END_TEST;
 182
 183
 184 static const char ro_memory[] = "abcdefghijklmnopqrstuvwxyz";
 185
 186 static GstBuffer *
 187 create_read_only_buffer (void)
 188 {
 189   GstBuffer *buf;
 190
 191   buf = gst_buffer_new ();
 192
 193   /* assign some read-only data to the new buffer */
 194   gst_buffer_insert_memory (buf, -1,
 195       gst_memory_new_wrapped (GST_MEMORY_FLAG_READONLY,
 196           (gpointer) ro_memory, sizeof (ro_memory),
 197           0, sizeof (ro_memory), NULL, NULL));
 198
 199   return buf;
 200 }
 201
 202 GST_START_TEST (test_make_writable)
 203 {
 204   GstBuffer *buf, *buf2;
 205   GstMapInfo info;
 206
 207   /* create read-only buffer and make it writable */
 208   buf = create_read_only_buffer ();
 209
 210   fail_unless (gst_buffer_map (buf, &info, GST_MAP_WRITE));
 211   info.data[4] = 'a';
 212   gst_buffer_unmap (buf, &info);
 213   gst_buffer_unref (buf);
 214
 215   /* alloc'ed buffer with refcount 1 should be writable */
 216   buf = gst_buffer_new_and_alloc (32);
 217   buf2 = gst_buffer_make_writable (buf);
 218   fail_unless (buf == buf2,
 219       "_make_writable() should have returned same buffer");
 220   gst_buffer_unref (buf2);
 221
 222   /* alloc'ed buffer with refcount >1 should be copied */
 223   buf = gst_buffer_new_and_alloc (32);
 224   gst_buffer_ref (buf);
 225   buf2 = gst_buffer_make_writable (buf);
 226   fail_unless (buf != buf2, "_make_writable() should have returned a copy!");
 227   gst_buffer_unref (buf2);
 228   gst_buffer_unref (buf);
 229 }
 230
 231 GST_END_TEST;
 232
 233 GST_START_TEST (test_subbuffer_make_writable)
 234 {
 235   GstBuffer *buf, *sub_buf;
 236   GstMapInfo info;
 237
 238   /* create sub-buffer of read-only buffer and make it writable */
 239   buf = create_read_only_buffer ();
 240
 241   sub_buf = gst_buffer_copy_region (buf, GST_BUFFER_COPY_ALL, 0, 8);
 242
 243   fail_unless (gst_buffer_map (sub_buf, &info, GST_MAP_WRITE));
 244   fail_if (info.data == NULL);
 245   info.data[4] = 'a';
 246   gst_buffer_unmap (sub_buf, &info);
 247   gst_buffer_unref (sub_buf);
 248   gst_buffer_unref (buf);
 249 }
 250
 251 GST_END_TEST;
 252
 253 GST_START_TEST (test_metadata_writable)
 254 {
 255   GstBuffer *buffer, *sub1;
 256
 257   buffer = gst_buffer_new_and_alloc (4);
 258   GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DISCONT);
 259   GST_BUFFER_FLAG_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT);
 260
 261   /* Buffer with refcount 1 should have writable metadata */
 262   fail_unless (gst_buffer_is_writable (buffer) == TRUE);
 263
 264   /* Check that a buffer with refcount 2 does not have writable metadata */
 265   gst_buffer_ref (buffer);
 266   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 2);
 267   fail_unless (gst_buffer_is_writable (buffer) == FALSE);
 268
 269   /* Check that make_metadata_writable produces a new sub-buffer with
 270    * writable metadata. */
 271   sub1 = gst_buffer_make_writable (buffer);
 272   fail_if (sub1 == buffer);
 273   fail_unless (gst_buffer_is_writable (sub1) == TRUE);
 274
 275   /* Check that make_metadata_writable() maintains the buffer flags */
 276   fail_unless (GST_BUFFER_FLAG_IS_SET (sub1, GST_BUFFER_FLAG_DISCONT));
 277   fail_unless (GST_BUFFER_FLAG_IS_SET (sub1, GST_BUFFER_FLAG_DELTA_UNIT));
 278
 279   /* Unset flags on writable buffer, then make sure they're still
 280    * set on the original buffer */
 281   GST_BUFFER_FLAG_UNSET (sub1, GST_BUFFER_FLAG_DISCONT);
 282   GST_BUFFER_FLAG_UNSET (sub1, GST_BUFFER_FLAG_DELTA_UNIT);
 283   fail_unless (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DISCONT));
 284   fail_unless (GST_BUFFER_FLAG_IS_SET (buffer, GST_BUFFER_FLAG_DELTA_UNIT));
 285
 286   /* Drop the subbuffer and check that the metadata is now writable again */
 287   ASSERT_BUFFER_REFCOUNT (sub1, "sub1", 1);
 288   gst_buffer_unref (sub1);
 289   fail_unless (gst_buffer_is_writable (buffer) == TRUE);
 290
 291   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 292   gst_buffer_unref (buffer);
 293 }
 294
 295 GST_END_TEST;
 296
 297 GST_START_TEST (test_copy)
 298 {
 299   GstBuffer *buffer, *copy;
 300   GstMapInfo info, sinfo;
 301
 302   buffer = gst_buffer_new_and_alloc (4);
 303   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 304
 305   copy = gst_buffer_copy (buffer);
 306   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 307   ASSERT_BUFFER_REFCOUNT (copy, "copy", 1);
 308   /* buffers are copied and must point to different memory */
 309   fail_if (buffer == copy);
 310
 311   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_READ));
 312   fail_unless (gst_buffer_map (copy, &sinfo, GST_MAP_READ));
 313
 314   /* NOTE that data is refcounted */
 315   fail_unless (info.size == sinfo.size);
 316
 317   gst_buffer_unmap (copy, &sinfo);
 318   gst_buffer_unmap (buffer, &info);
 319
 320   gst_buffer_unref (copy);
 321   gst_buffer_unref (buffer);
 322
 323   /* a 0-sized buffer has NULL data as per docs */
 324   buffer = gst_buffer_new_and_alloc (0);
 325   fail_unless (gst_buffer_map (buffer, &info, GST_MAP_READ));
 326   fail_unless (info.data == NULL);
 327   gst_buffer_unmap (buffer, &info);
 328
 329   /* copying a 0-sized buffer should not crash and also set
 330    * the data member NULL. */
 331   copy = gst_buffer_copy (buffer);
 332   fail_unless (gst_buffer_map (copy, &info, GST_MAP_READ));
 333   fail_unless (info.data == NULL);
 334   gst_buffer_unmap (copy, &info);
 335
 336   gst_buffer_unref (copy);
 337   gst_buffer_unref (buffer);
 338 }
 339
 340 GST_END_TEST;
 341
 342 GST_START_TEST (test_try_new_and_alloc)
 343 {
 344   GstBuffer *buf;
 345   GstMapInfo info;
 346
 347   /* special case: alloc of 0 bytes results in new buffer with NULL data */
 348   buf = gst_buffer_new_and_alloc (0);
 349   fail_unless (buf != NULL);
 350   fail_unless (GST_IS_BUFFER (buf));
 351   fail_unless (gst_buffer_map (buf, &info, GST_MAP_READ));
 352   fail_unless (info.data == NULL);
 353   gst_buffer_unmap (buf, &info);
 354   gst_buffer_unref (buf);
 355
 356   /* normal alloc should still work */
 357   buf = gst_buffer_new_and_alloc (640 * 480 * 4);
 358   fail_unless (buf != NULL);
 359   fail_unless (GST_IS_BUFFER (buf));
 360   fail_unless (gst_buffer_map (buf, &info, GST_MAP_WRITE));
 361   fail_unless (info.data != NULL);
 362   fail_unless (info.size == (640 * 480 * 4));
 363   info.data[640 * 479 * 4 + 479] = 0xff;
 364   gst_buffer_unmap (buf, &info);
 365
 366   gst_buffer_unref (buf);
 367
 368 #if 0
 369   /* Disabled this part of the test, because it happily succeeds on 64-bit
 370    * machines that have enough memory+swap, because the address space is large
 371    * enough. There's not really any way to test the failure case except by
 372    * allocating chunks of memory until it fails, which would suck. */
 373
 374   /* now this better fail (don't run in valgrind, it will abort
 375    * or warn when passing silly arguments to malloc) */
 376   if (!RUNNING_ON_VALGRIND) {
 377     buf = gst_buffer_new_and_alloc ((guint) - 1);
 378     fail_unless (buf == NULL);
 379   }
 380 #endif
 381 }
 382
 383 GST_END_TEST;
 384
 385 GST_START_TEST (test_size)
 386 {
 387   GstBuffer *buf;
 388   GstMemory *mem;
 389   gsize maxalloc, maxalloc2, maxalloc3, maxalloc4;
 390   gsize size, maxsize, offset;
 391
 392   /* one memory block */
 393   buf = gst_buffer_new_allocate (NULL, 100, NULL);
 394
 395   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 396   fail_unless (size == 100);
 397   fail_unless (offset == 0);
 398   fail_unless (maxalloc >= 100);
 399
 400   mem = gst_buffer_get_memory (buf, 0);
 401   gst_memory_resize (mem, 10, 70);
 402   gst_memory_unref (mem);
 403
 404   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 405   fail_unless (size == 70);
 406   fail_unless (offset == 10);
 407   fail_unless (maxsize == maxalloc);
 408
 409   /* new memory */
 410   mem = gst_allocator_alloc (NULL, 100, NULL);
 411   size = gst_memory_get_sizes (mem, &offset, &maxalloc2);
 412   fail_unless (size == 100);
 413   fail_unless (offset == 0);
 414   fail_unless (maxalloc2 >= 100);
 415
 416   gst_memory_resize (mem, 20, 60);
 417   size = gst_memory_get_sizes (mem, &offset, &maxsize);
 418   fail_unless (size == 60);
 419   fail_unless (offset == 20);
 420   fail_unless (maxsize == maxalloc2);
 421
 422   /* append */
 423   gst_buffer_insert_memory (buf, -1, mem);
 424
 425   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 426   fail_unless (size == 130);
 427   fail_unless (offset == 10);
 428   /* the maxsize is the size of the first buffer plus the remaining size in the
 429    * second buffer */
 430   fail_unless (maxalloc == 80 + (maxalloc2 - 20));
 431
 432   /* appending an empty block */
 433   mem = gst_allocator_alloc (NULL, 100, NULL);
 434   size = gst_memory_get_sizes (mem, &offset, &maxalloc3);
 435   gst_memory_resize (mem, 0, 0);
 436   gst_buffer_insert_memory (buf, -1, mem);
 437
 438   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 439   fail_unless (size == 130);
 440   fail_unless (offset == 10);
 441   /* the maxsize is the size of the first buffer plus the remaining size in the
 442    * second buffer and the last empty buffer*/
 443   fail_unless (maxalloc == 80 + (maxalloc2 - 20) + maxalloc3);
 444
 445   /* prepending an empty block */
 446   mem = gst_allocator_alloc (NULL, 100, NULL);
 447   size = gst_memory_get_sizes (mem, &offset, &maxalloc4);
 448   gst_memory_resize (mem, 0, 0);
 449   gst_buffer_insert_memory (buf, 0, mem);
 450
 451   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 452   fail_unless (size == 130);
 453   /* empty buffer maxsize can be used as offset */
 454   fail_unless (offset == 10 + maxalloc4);
 455   /* the maxsize is the size of the first buffer plus the remaining size in the
 456    * second buffer and the last empty buffer*/
 457   fail_unless (maxalloc == 80 + (maxalloc2 - 20) + maxalloc3 + maxalloc4);
 458
 459   gst_buffer_unref (buf);
 460 }
 461
 462 GST_END_TEST;
 463
 464 GST_START_TEST (test_resize)
 465 {
 466   GstBuffer *buf;
 467   gsize maxalloc;
 468   gsize size, maxsize, offset;
 469
 470   /* one memory block */
 471   buf = gst_buffer_new_allocate (NULL, 100, NULL);
 472
 473   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 474   fail_unless (size == 100);
 475   fail_unless (offset == 0);
 476   fail_unless (maxalloc >= 100);
 477
 478   ASSERT_CRITICAL (gst_buffer_resize (buf, 200, 50));
 479   ASSERT_CRITICAL (gst_buffer_resize (buf, 0, 150));
 480   ASSERT_CRITICAL (gst_buffer_resize (buf, 1, maxalloc));
 481   ASSERT_CRITICAL (gst_buffer_resize (buf, maxalloc, 1));
 482
 483   /* this does nothing */
 484   gst_buffer_resize (buf, 0, 100);
 485
 486   /* nothing should have changed */
 487   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 488   fail_unless (size == 100);
 489   fail_unless (offset == 0);
 490   fail_unless (maxsize == maxalloc);
 491
 492   gst_buffer_resize (buf, 0, 50);
 493   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 494   fail_unless (size == 50);
 495   fail_unless (offset == 0);
 496   fail_unless (maxsize == maxalloc);
 497
 498   gst_buffer_resize (buf, 0, 100);
 499   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 500   fail_unless (size == 100);
 501   fail_unless (offset == 0);
 502   fail_unless (maxsize == maxalloc);
 503
 504   gst_buffer_resize (buf, 1, 99);
 505   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 506   fail_unless (size == 99);
 507   fail_unless (offset == 1);
 508   fail_unless (maxsize == maxalloc);
 509
 510   ASSERT_CRITICAL (gst_buffer_resize (buf, 1, maxalloc - 1));
 511
 512   gst_buffer_resize (buf, 0, 99);
 513   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 514   fail_unless (size == 99);
 515   fail_unless (offset == 1);
 516   fail_unless (maxsize == maxalloc);
 517
 518   gst_buffer_resize (buf, -1, 100);
 519   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 520   fail_unless (size == 100);
 521   fail_unless (offset == 0);
 522   fail_unless (maxsize == maxalloc);
 523
 524   ASSERT_CRITICAL (gst_buffer_resize (buf, -1, 100));
 525
 526   gst_buffer_resize (buf, 50, 40);
 527   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 528   fail_unless (size == 40);
 529   fail_unless (offset == 50);
 530   fail_unless (maxsize == maxalloc);
 531
 532   gst_buffer_resize (buf, -50, 100);
 533   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 534   fail_unless (size == 100);
 535   fail_unless (offset == 0);
 536   fail_unless (maxsize == maxalloc);
 537
 538   gst_buffer_resize (buf, 0, 0);
 539   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 540   fail_unless (size == 0);
 541   fail_unless (offset == 0);
 542   fail_unless (maxsize == maxalloc);
 543
 544   gst_buffer_resize (buf, 0, 100);
 545   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 546   fail_unless (size == 100);
 547   fail_unless (offset == 0);
 548   fail_unless (maxsize == maxalloc);
 549
 550   gst_buffer_resize (buf, 0, 100);
 551   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 552   fail_unless (size == 100);
 553   fail_unless (offset == 0);
 554   fail_unless (maxsize == maxalloc);
 555
 556   gst_buffer_unref (buf);
 557 }
 558
 559 GST_END_TEST;
 560
 561 GST_START_TEST (test_map)
 562 {
 563   GstBuffer *buf;
 564   GstMapInfo map;
 565   gsize maxalloc;
 566   gsize size, offset;
 567
 568   buf = gst_buffer_new ();
 569   gst_buffer_insert_memory (buf, -1, gst_allocator_alloc (NULL, 50, NULL));
 570   gst_buffer_insert_memory (buf, -1, gst_allocator_alloc (NULL, 50, NULL));
 571
 572   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 573   fail_unless (size == 100);
 574   fail_unless (offset == 0);
 575   fail_unless (maxalloc >= 100);
 576   fail_unless (gst_buffer_n_memory (buf) == 2);
 577
 578   /* make readonly */
 579   gst_buffer_ref (buf);
 580   /* map should merge */
 581   gst_buffer_map (buf, &map, GST_MAP_READ);
 582   /* merged memory is not stored */
 583   fail_unless (gst_buffer_n_memory (buf) == 2);
 584   gst_buffer_unmap (buf, &map);
 585
 586   fail_unless (gst_buffer_n_memory (buf) == 2);
 587
 588   /* can't map write on readonly buffer */
 589   ASSERT_CRITICAL (gst_buffer_map (buf, &map, GST_MAP_WRITE));
 590   /* make writable again */
 591   gst_buffer_unref (buf);
 592
 593   /* should merge and store */
 594   gst_buffer_map (buf, &map, GST_MAP_READ);
 595   fail_unless (gst_buffer_n_memory (buf) == 1);
 596   gst_buffer_unmap (buf, &map);
 597
 598   gst_buffer_map (buf, &map, GST_MAP_WRITE);
 599   gst_buffer_unmap (buf, &map);
 600
 601   gst_buffer_unref (buf);
 602 }
 603
 604 GST_END_TEST;
 605
 606
 607 static Suite *
 608 gst_buffer_suite (void)
 609 {
 610   Suite *s = suite_create ("GstBuffer");
 611   TCase *tc_chain = tcase_create ("general");
 612
 613   suite_add_tcase (s, tc_chain);
 614   tcase_add_test (tc_chain, test_subbuffer);
 615   tcase_add_test (tc_chain, test_subbuffer_make_writable);
 616   tcase_add_test (tc_chain, test_make_writable);
 617   tcase_add_test (tc_chain, test_span);
 618   tcase_add_test (tc_chain, test_metadata_writable);
 619   tcase_add_test (tc_chain, test_copy);
 620   tcase_add_test (tc_chain, test_try_new_and_alloc);
 621   tcase_add_test (tc_chain, test_size);
 622   tcase_add_test (tc_chain, test_resize);
 623   tcase_add_test (tc_chain, test_map);
 624
 625   return s;
 626 }
 627
 628 GST_CHECK_MAIN (gst_buffer);