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