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