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., 51 Franklin St, Fifth Floor,
  20  * Boston, MA 02110-1301, 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   /* check if copy is an independent copy when written to */
 340   buffer = gst_buffer_new_and_alloc (4);
 341   gst_buffer_memset (buffer, 0, 0, 4);
 342   copy = gst_buffer_copy (buffer);
 343   fail_unless (gst_buffer_is_writable (copy));
 344   gst_buffer_memset (copy, 0, 0x80, 4);
 345   gst_buffer_map (buffer, &info, GST_MAP_READ);
 346   fail_if (gst_buffer_memcmp (copy, 0, info.data, info.size) == 0);
 347   gst_buffer_unmap (buffer, &info);
 348
 349   gst_buffer_unref (copy);
 350   gst_buffer_unref (buffer);
 351
 352   /* copy should still be independent if copied when mapped */
 353   buffer = gst_buffer_new_and_alloc (4);
 354   gst_buffer_memset (buffer, 0, 0, 4);
 355   gst_buffer_map (buffer, &info, GST_MAP_WRITE);
 356   copy = gst_buffer_copy (buffer);
 357   fail_unless (gst_buffer_is_writable (copy));
 358   gst_buffer_memset (copy, 0, 0x80, 4);
 359   gst_buffer_unmap (buffer, &info);
 360   gst_buffer_map (buffer, &info, GST_MAP_READ);
 361   fail_if (gst_buffer_memcmp (copy, 0, info.data, info.size) == 0);
 362   gst_buffer_unmap (buffer, &info);
 363
 364   gst_buffer_unref (copy);
 365   gst_buffer_unref (buffer);
 366
 367   /* check if a writable clone of a buffer is independent when written to */
 368   buffer = gst_buffer_new_and_alloc (4);
 369   gst_buffer_memset (buffer, 0, 0, 4);
 370   copy = gst_buffer_ref (buffer);
 371   copy = gst_buffer_make_writable (copy);
 372   fail_unless (gst_buffer_is_writable (copy));
 373   gst_buffer_memset (copy, 0, 0x80, 4);
 374   gst_buffer_map (buffer, &info, GST_MAP_READ);
 375   fail_if (gst_buffer_memcmp (copy, 0, info.data, info.size) == 0);
 376   gst_buffer_unmap (buffer, &info);
 377
 378   gst_buffer_unref (copy);
 379   gst_buffer_unref (buffer);
 380 }
 381
 382 GST_END_TEST;
 383
 384 GST_START_TEST (test_try_new_and_alloc)
 385 {
 386   GstBuffer *buf;
 387   GstMapInfo info;
 388
 389   /* special case: alloc of 0 bytes results in new buffer with NULL data */
 390   buf = gst_buffer_new_and_alloc (0);
 391   fail_unless (buf != NULL);
 392   fail_unless (GST_IS_BUFFER (buf));
 393   fail_unless (gst_buffer_map (buf, &info, GST_MAP_READ));
 394   fail_unless (info.data == NULL);
 395   gst_buffer_unmap (buf, &info);
 396   gst_buffer_unref (buf);
 397
 398   /* normal alloc should still work */
 399   buf = gst_buffer_new_and_alloc (640 * 480 * 4);
 400   fail_unless (buf != NULL);
 401   fail_unless (GST_IS_BUFFER (buf));
 402   fail_unless (gst_buffer_map (buf, &info, GST_MAP_WRITE));
 403   fail_unless (info.data != NULL);
 404   fail_unless (info.size == (640 * 480 * 4));
 405   info.data[640 * 479 * 4 + 479] = 0xff;
 406   gst_buffer_unmap (buf, &info);
 407
 408   gst_buffer_unref (buf);
 409
 410 #if 0
 411   /* Disabled this part of the test, because it happily succeeds on 64-bit
 412    * machines that have enough memory+swap, because the address space is large
 413    * enough. There's not really any way to test the failure case except by
 414    * allocating chunks of memory until it fails, which would suck. */
 415
 416   /* now this better fail (don't run in valgrind, it will abort
 417    * or warn when passing silly arguments to malloc) */
 418   if (!RUNNING_ON_VALGRIND) {
 419     buf = gst_buffer_new_and_alloc ((guint) - 1);
 420     fail_unless (buf == NULL);
 421   }
 422 #endif
 423 }
 424
 425 GST_END_TEST;
 426
 427 GST_START_TEST (test_size)
 428 {
 429   GstBuffer *buf;
 430   GstMemory *mem;
 431   gsize maxalloc, maxalloc2, maxalloc3, maxalloc4;
 432   gsize size, maxsize, offset;
 433
 434   /* one memory block */
 435   buf = gst_buffer_new_allocate (NULL, 100, NULL);
 436
 437   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 438   fail_unless (size == 100);
 439   fail_unless (offset == 0);
 440   fail_unless (maxalloc >= 100);
 441
 442   mem = gst_buffer_get_memory (buf, 0);
 443   gst_memory_resize (mem, 10, 70);
 444   gst_memory_unref (mem);
 445
 446   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 447   fail_unless (size == 70);
 448   fail_unless (offset == 10);
 449   fail_unless (maxsize == maxalloc);
 450
 451   /* new memory */
 452   mem = gst_allocator_alloc (NULL, 100, NULL);
 453   size = gst_memory_get_sizes (mem, &offset, &maxalloc2);
 454   fail_unless (size == 100);
 455   fail_unless (offset == 0);
 456   fail_unless (maxalloc2 >= 100);
 457
 458   gst_memory_resize (mem, 20, 60);
 459   size = gst_memory_get_sizes (mem, &offset, &maxsize);
 460   fail_unless (size == 60);
 461   fail_unless (offset == 20);
 462   fail_unless (maxsize == maxalloc2);
 463
 464   /* append */
 465   gst_buffer_insert_memory (buf, -1, mem);
 466
 467   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 468   fail_unless (size == 130);
 469   fail_unless (offset == 10);
 470   /* the maxsize is the size of the first buffer plus the remaining size in the
 471    * second buffer */
 472   fail_unless (maxalloc == 80 + (maxalloc2 - 20));
 473
 474   /* appending an empty block */
 475   mem = gst_allocator_alloc (NULL, 100, NULL);
 476   size = gst_memory_get_sizes (mem, &offset, &maxalloc3);
 477   gst_memory_resize (mem, 0, 0);
 478   gst_buffer_insert_memory (buf, -1, mem);
 479
 480   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 481   fail_unless (size == 130);
 482   fail_unless (offset == 10);
 483   /* the maxsize is the size of the first buffer plus the remaining size in the
 484    * second buffer and the last empty buffer*/
 485   fail_unless (maxalloc == 80 + (maxalloc2 - 20) + maxalloc3);
 486
 487   /* prepending an empty block */
 488   mem = gst_allocator_alloc (NULL, 100, NULL);
 489   size = gst_memory_get_sizes (mem, &offset, &maxalloc4);
 490   gst_memory_resize (mem, 0, 0);
 491   gst_buffer_insert_memory (buf, 0, mem);
 492
 493   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 494   fail_unless (size == 130);
 495   /* empty buffer maxsize can be used as offset */
 496   fail_unless (offset == 10 + maxalloc4);
 497   /* the maxsize is the size of the first buffer plus the remaining size in the
 498    * second buffer and the last empty buffer*/
 499   fail_unless (maxalloc == 80 + (maxalloc2 - 20) + maxalloc3 + maxalloc4);
 500
 501   gst_buffer_unref (buf);
 502 }
 503
 504 GST_END_TEST;
 505
 506 GST_START_TEST (test_resize)
 507 {
 508   GstBuffer *buf;
 509   gsize maxalloc;
 510   gsize size, maxsize, offset;
 511
 512   /* one memory block */
 513   buf = gst_buffer_new_allocate (NULL, 100, NULL);
 514
 515   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 516   fail_unless (size == 100);
 517   fail_unless (offset == 0);
 518   fail_unless (maxalloc >= 100);
 519
 520   ASSERT_CRITICAL (gst_buffer_resize (buf, 200, 50));
 521   ASSERT_CRITICAL (gst_buffer_resize (buf, 0, 150));
 522   ASSERT_CRITICAL (gst_buffer_resize (buf, 1, maxalloc));
 523   ASSERT_CRITICAL (gst_buffer_resize (buf, maxalloc, 1));
 524
 525   /* this does nothing */
 526   gst_buffer_resize (buf, 0, 100);
 527
 528   /* nothing should have changed */
 529   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 530   fail_unless (size == 100);
 531   fail_unless (offset == 0);
 532   fail_unless (maxsize == maxalloc);
 533
 534   gst_buffer_resize (buf, 0, 50);
 535   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 536   fail_unless (size == 50);
 537   fail_unless (offset == 0);
 538   fail_unless (maxsize == maxalloc);
 539
 540   gst_buffer_resize (buf, 0, 100);
 541   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 542   fail_unless (size == 100);
 543   fail_unless (offset == 0);
 544   fail_unless (maxsize == maxalloc);
 545
 546   gst_buffer_resize (buf, 1, 99);
 547   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 548   fail_unless (size == 99);
 549   fail_unless (offset == 1);
 550   fail_unless (maxsize == maxalloc);
 551
 552   ASSERT_CRITICAL (gst_buffer_resize (buf, 1, maxalloc - 1));
 553
 554   gst_buffer_resize (buf, 0, 99);
 555   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 556   fail_unless (size == 99);
 557   fail_unless (offset == 1);
 558   fail_unless (maxsize == maxalloc);
 559
 560   gst_buffer_resize (buf, -1, 100);
 561   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 562   fail_unless (size == 100);
 563   fail_unless (offset == 0);
 564   fail_unless (maxsize == maxalloc);
 565
 566   ASSERT_CRITICAL (gst_buffer_resize (buf, -1, 100));
 567
 568   gst_buffer_resize (buf, 50, 40);
 569   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 570   fail_unless (size == 40);
 571   fail_unless (offset == 50);
 572   fail_unless (maxsize == maxalloc);
 573
 574   gst_buffer_resize (buf, -50, 100);
 575   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 576   fail_unless (size == 100);
 577   fail_unless (offset == 0);
 578   fail_unless (maxsize == maxalloc);
 579
 580   gst_buffer_resize (buf, 0, 0);
 581   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 582   fail_unless (size == 0);
 583   fail_unless (offset == 0);
 584   fail_unless (maxsize == maxalloc);
 585
 586   gst_buffer_resize (buf, 0, 100);
 587   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 588   fail_unless (size == 100);
 589   fail_unless (offset == 0);
 590   fail_unless (maxsize == maxalloc);
 591
 592   gst_buffer_resize (buf, 0, 100);
 593   size = gst_buffer_get_sizes (buf, &offset, &maxsize);
 594   fail_unless (size == 100);
 595   fail_unless (offset == 0);
 596   fail_unless (maxsize == maxalloc);
 597
 598   gst_buffer_unref (buf);
 599 }
 600
 601 GST_END_TEST;
 602
 603 GST_START_TEST (test_map)
 604 {
 605   GstBuffer *buf;
 606   GstMapInfo map, map2;
 607   gsize maxalloc;
 608   gsize size, offset;
 609
 610   buf = gst_buffer_new ();
 611   gst_buffer_insert_memory (buf, -1, gst_allocator_alloc (NULL, 50, NULL));
 612   gst_buffer_insert_memory (buf, -1, gst_allocator_alloc (NULL, 50, NULL));
 613
 614   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 615   fail_unless (size == 100);
 616   fail_unless (offset == 0);
 617   fail_unless (maxalloc >= 100);
 618   fail_unless (gst_buffer_n_memory (buf) == 2);
 619
 620   /* make readonly */
 621   gst_buffer_ref (buf);
 622   /* map should merge */
 623   gst_buffer_map (buf, &map, GST_MAP_READ);
 624   /* merged memory is not stored */
 625   fail_unless (gst_buffer_n_memory (buf) == 2);
 626   gst_buffer_unmap (buf, &map);
 627
 628   fail_unless (gst_buffer_n_memory (buf) == 2);
 629
 630   /* can't map write on readonly buffer */
 631   ASSERT_CRITICAL (gst_buffer_map (buf, &map, GST_MAP_WRITE));
 632   /* make writable again */
 633   gst_buffer_unref (buf);
 634
 635   /* should merge and store */
 636   gst_buffer_map (buf, &map, GST_MAP_READ);
 637   fail_unless (gst_buffer_n_memory (buf) == 1);
 638   gst_buffer_unmap (buf, &map);
 639
 640   gst_buffer_map (buf, &map, GST_MAP_WRITE);
 641   gst_buffer_unmap (buf, &map);
 642
 643   /* mapping same kind should be ok using same memory */
 644   gst_buffer_map (buf, &map, GST_MAP_WRITE);
 645   fail_unless (gst_buffer_map (buf, &map2, GST_MAP_WRITE));
 646   fail_unless (map.memory == map2.memory);
 647   gst_buffer_unmap (buf, &map2);
 648   gst_buffer_unmap (buf, &map);
 649
 650   /* ... but different kind should give temporary memory */
 651   gst_buffer_map (buf, &map, GST_MAP_WRITE);
 652   fail_unless (gst_buffer_map (buf, &map2, GST_MAP_READ));
 653   fail_if (map.memory == map2.memory);
 654   gst_buffer_unmap (buf, &map2);
 655   gst_buffer_unmap (buf, &map);
 656
 657   gst_buffer_unref (buf);
 658 }
 659
 660 GST_END_TEST;
 661
 662 GST_START_TEST (test_find)
 663 {
 664   GstBuffer *buf;
 665   gsize maxalloc;
 666   gsize size, offset;
 667   guint idx, length;
 668
 669   buf = gst_buffer_new ();
 670   gst_buffer_append_memory (buf, gst_allocator_alloc (NULL, 0, NULL));
 671   gst_buffer_append_memory (buf, gst_allocator_alloc (NULL, 10, NULL));
 672   gst_buffer_append_memory (buf, gst_allocator_alloc (NULL, 15, NULL));
 673   gst_buffer_append_memory (buf, gst_allocator_alloc (NULL, 0, NULL));
 674
 675   size = gst_buffer_get_sizes (buf, &offset, &maxalloc);
 676   fail_unless (size == 25);
 677   fail_unless (offset >= 0);
 678   fail_unless (maxalloc >= 25);
 679   fail_unless (gst_buffer_n_memory (buf) == 4);
 680
 681   fail_unless (gst_buffer_find_memory (buf, 0, 5, &idx, &length, &offset));
 682   fail_unless (idx == 1);
 683   fail_unless (length == 1);
 684   fail_unless (offset == 0);
 685
 686   fail_unless (gst_buffer_find_memory (buf, 0, 10, &idx, &length, &offset));
 687   fail_unless (idx == 1);
 688   fail_unless (length == 1);
 689   fail_unless (offset == 0);
 690
 691   fail_unless (gst_buffer_find_memory (buf, 5, 4, &idx, &length, &offset));
 692   fail_unless (idx == 1);
 693   fail_unless (length == 1);
 694   fail_unless (offset == 5);
 695
 696   fail_unless (gst_buffer_find_memory (buf, 5, 5, &idx, &length, &offset));
 697   fail_unless (idx == 1);
 698   fail_unless (length == 1);
 699   fail_unless (offset == 5);
 700
 701   fail_unless (gst_buffer_find_memory (buf, 5, 6, &idx, &length, &offset));
 702   fail_unless (idx == 1);
 703   fail_unless (length == 2);
 704   fail_unless (offset == 5);
 705
 706   fail_unless (gst_buffer_find_memory (buf, 10, 6, &idx, &length, &offset));
 707   fail_unless (idx == 2);
 708   fail_unless (length == 1);
 709   fail_unless (offset == 0);
 710
 711   fail_unless (gst_buffer_find_memory (buf, 10, 15, &idx, &length, &offset));
 712   fail_unless (idx == 2);
 713   fail_unless (length == 1);
 714   fail_unless (offset == 0);
 715
 716   fail_unless (gst_buffer_find_memory (buf, 11, 14, &idx, &length, &offset));
 717   fail_unless (idx == 2);
 718   fail_unless (length == 1);
 719   fail_unless (offset == 1);
 720
 721   fail_unless (gst_buffer_find_memory (buf, 0, 25, &idx, &length, &offset));
 722   fail_unless (idx == 1);
 723   fail_unless (length == 2);
 724   fail_unless (offset == 0);
 725
 726   fail_unless (gst_buffer_find_memory (buf, 24, 0, &idx, &length, &offset));
 727   fail_unless (idx == 2);
 728   fail_unless (length == 1);
 729   fail_unless (offset == 14);
 730
 731   fail_if (gst_buffer_find_memory (buf, 11, 15, &idx, &length, &offset));
 732   fail_if (gst_buffer_find_memory (buf, 0, 26, &idx, &length, &offset));
 733   fail_if (gst_buffer_find_memory (buf, 25, 0, &idx, &length, &offset));
 734
 735   fail_unless (gst_buffer_find_memory (buf, 1, -1, &idx, &length, &offset));
 736   fail_unless (idx == 1);
 737   fail_unless (length == 3);
 738   fail_unless (offset == 1);
 739
 740   gst_buffer_unref (buf);
 741 }
 742
 743 GST_END_TEST;
 744
 745
 746 static Suite *
 747 gst_buffer_suite (void)
 748 {
 749   Suite *s = suite_create ("GstBuffer");
 750   TCase *tc_chain = tcase_create ("general");
 751
 752   suite_add_tcase (s, tc_chain);
 753   tcase_add_test (tc_chain, test_subbuffer);
 754   tcase_add_test (tc_chain, test_subbuffer_make_writable);
 755   tcase_add_test (tc_chain, test_make_writable);
 756   tcase_add_test (tc_chain, test_span);
 757   tcase_add_test (tc_chain, test_metadata_writable);
 758   tcase_add_test (tc_chain, test_copy);
 759   tcase_add_test (tc_chain, test_try_new_and_alloc);
 760   tcase_add_test (tc_chain, test_size);
 761   tcase_add_test (tc_chain, test_resize);
 762   tcase_add_test (tc_chain, test_map);
 763   tcase_add_test (tc_chain, test_find);
 764
 765   return s;
 766 }
 767
 768 GST_CHECK_MAIN (gst_buffer);