tests/check/gst/gstbufferlist.c

   1 /* GStreamer
   2  *
   3  * unit test for GstBufferList
   4  *
   5  * Copyright (C) 2009 Axis Communications <dev-gstreamer at axis dot com>
   6  * @author Jonas Holmberg <jonas dot holmberg at axis dot com>
   7  *
   8  * This library is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Library General Public
  10  * License as published by the Free Software Foundation; either
  11  * version 2 of the License, or (at your option) any later version.
  12  *
  13  * This library is distributed in the hope that it will be useful,
  14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  16  * Library General Public License for more details.
  17  *
  18  * You should have received a copy of the GNU Library General Public
  19  * License along with this library; if not, write to the
  20  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  21  * Boston, MA 02111-1307, USA.
  22  */
  23
  24 #include <gst/check/gstcheck.h>
  25 #include <gst/gstbufferlist.h>
  26 #include <string.h>
  27
  28 #define TIMESTAMP 42
  29
  30 static GstBufferList *list;
  31 static GstCaps *caps;
  32
  33 static void
  34 setup (void)
  35 {
  36   list = gst_buffer_list_new ();
  37   caps = gst_caps_new_empty_simple ("text/plain");
  38 }
  39
  40 static void
  41 cleanup (void)
  42 {
  43   gst_caps_unref (caps);
  44   gst_buffer_list_unref (list);
  45 }
  46
  47 #if 0
  48 static GstBuffer *
  49 buffer_from_string (const gchar * str)
  50 {
  51   gsize size;
  52   GstBuffer *buf;
  53   gpointer data;
  54
  55   size = strlen (str);
  56   buf = gst_buffer_new_and_alloc (size);
  57   gst_buffer_set_caps (buf, caps);
  58   GST_BUFFER_TIMESTAMP (buf) = TIMESTAMP;
  59
  60   data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
  61   memcpy (data, str, size);
  62   gst_buffer_unmap (buf, data, size);
  63
  64   return buf;
  65 }
  66
  67 static void
  68 check_buffer (GstBuffer * buf, gsize size, const gchar * data)
  69 {
  70   gchar *bdata;
  71   gsize bsize, csize, msize;
  72
  73   bdata = gst_buffer_map (buf, &bsize, &msize, GST_MAP_READ);
  74   csize = size ? size : bsize;
  75   GST_DEBUG ("%lu %lu %lu", bsize, csize, msize);
  76   fail_unless (bsize == csize);
  77   fail_unless (memcmp (bdata, data, csize) == 0);
  78   gst_buffer_unmap (buf, bdata, bsize);
  79 }
  80 #endif
  81
  82 GST_START_TEST (test_add_and_iterate)
  83 {
  84   GstBuffer *buf1;
  85   GstBuffer *buf2;
  86
  87   /* buffer list is initially empty */
  88   fail_unless (gst_buffer_list_length (list) == 0);
  89
  90   ASSERT_CRITICAL (gst_buffer_list_insert (list, 0, NULL));
  91   ASSERT_CRITICAL (gst_buffer_list_insert (NULL, 0, NULL));
  92
  93   buf1 = gst_buffer_new ();
  94
  95   /* add a group of 2 buffers */
  96   fail_unless (gst_buffer_list_length (list) == 0);
  97   ASSERT_CRITICAL (gst_buffer_list_insert (list, -1, NULL));
  98   ASSERT_BUFFER_REFCOUNT (buf1, "buf1", 1);
  99   gst_buffer_list_add (list, buf1);
 100   ASSERT_BUFFER_REFCOUNT (buf1, "buf1", 1);     /* list takes ownership */
 101   fail_unless (gst_buffer_list_length (list) == 1);
 102   buf2 = gst_buffer_new ();
 103   gst_buffer_list_add (list, buf2);
 104   ASSERT_BUFFER_REFCOUNT (buf2, "buf2", 1);
 105   fail_unless (gst_buffer_list_length (list) == 2);
 106 }
 107
 108 GST_END_TEST;
 109
 110 #if 0
 111 GST_START_TEST (test_make_writable)
 112 {
 113   GstBufferListIterator *it;
 114   GstBufferList *wlist;
 115   GstBuffer *buf1;
 116   GstBuffer *buf2;
 117   GstBuffer *buf3;
 118   GstBuffer *buf;
 119
 120   /* add buffers to list */
 121   it = gst_buffer_list_iterate (list);
 122   gst_buffer_list_iterator_add_group (it);
 123   buf1 = gst_buffer_new_and_alloc (1);
 124   gst_buffer_list_iterator_add (it, buf1);
 125   gst_buffer_list_iterator_add_group (it);
 126   buf2 = gst_buffer_new_and_alloc (2);
 127   gst_buffer_list_iterator_add (it, buf2);
 128   buf3 = gst_buffer_new_and_alloc (3);
 129   gst_buffer_list_iterator_add (it, buf3);
 130   gst_buffer_list_iterator_free (it);
 131
 132   /* making it writable with refcount 1 returns the same list */
 133   wlist = gst_buffer_list_make_writable (list);
 134   fail_unless (wlist == list);
 135   it = gst_buffer_list_iterate (list);
 136   fail_unless (gst_buffer_list_iterator_next_group (it));
 137   buf = gst_buffer_list_iterator_next (it);
 138   fail_unless (buf == buf1);
 139   ASSERT_BUFFER_REFCOUNT (buf1, "buf1", 1);
 140   fail_unless (gst_buffer_list_iterator_next (it) == NULL);
 141   fail_unless (gst_buffer_list_iterator_next_group (it));
 142   buf = gst_buffer_list_iterator_next (it);
 143   fail_unless (buf == buf2);
 144   ASSERT_BUFFER_REFCOUNT (buf2, "buf2", 1);
 145   buf = gst_buffer_list_iterator_next (it);
 146   fail_unless (buf == buf3);
 147   ASSERT_BUFFER_REFCOUNT (buf3, "buf3", 1);
 148   fail_unless (gst_buffer_list_iterator_next (it) == NULL);
 149   fail_if (gst_buffer_list_iterator_next_group (it));
 150   gst_buffer_list_iterator_free (it);
 151
 152   /* making it writable with refcount 2 returns a copy of the list with
 153    * increased refcount on the buffers in the list */
 154   gst_buffer_list_ref (list);
 155   fail_unless (GST_MINI_OBJECT_REFCOUNT_VALUE (list) == 2);
 156   wlist = gst_buffer_list_make_writable (list);
 157   fail_unless (GST_MINI_OBJECT_REFCOUNT_VALUE (list) == 1);
 158   fail_unless (GST_MINI_OBJECT_REFCOUNT_VALUE (wlist) == 1);
 159   fail_unless (wlist != list);
 160   it = gst_buffer_list_iterate (wlist);
 161   fail_unless (gst_buffer_list_iterator_next_group (it));
 162   buf = gst_buffer_list_iterator_next (it);
 163   fail_unless (buf == buf1);
 164   ASSERT_BUFFER_REFCOUNT (buf1, "buf1", 2);
 165   fail_unless (gst_buffer_list_iterator_next (it) == NULL);
 166   fail_unless (gst_buffer_list_iterator_next_group (it));
 167   buf = gst_buffer_list_iterator_next (it);
 168   fail_unless (buf == buf2);
 169   ASSERT_BUFFER_REFCOUNT (buf2, "buf2", 2);
 170   buf = gst_buffer_list_iterator_next (it);
 171   fail_unless (buf == buf3);
 172   ASSERT_BUFFER_REFCOUNT (buf3, "buf3", 2);
 173   fail_unless (gst_buffer_list_iterator_next (it) == NULL);
 174   fail_if (gst_buffer_list_iterator_next_group (it));
 175   gst_buffer_list_iterator_free (it);
 176   gst_buffer_list_unref (wlist);
 177 }
 178
 179 GST_END_TEST;
 180
 181 GST_START_TEST (test_copy)
 182 {
 183   GstBufferListIterator *it;
 184   GstBufferList *list_copy;
 185   GstBuffer *buf1;
 186   GstBuffer *buf2;
 187   GstBuffer *buf3;
 188   GstBuffer *buf;
 189
 190   /* add buffers to the list */
 191   it = gst_buffer_list_iterate (list);
 192   gst_buffer_list_iterator_add_group (it);
 193   buf1 = gst_buffer_new ();
 194   gst_buffer_list_iterator_add (it, buf1);
 195   gst_buffer_list_iterator_add_group (it);
 196   buf2 = gst_buffer_new ();
 197   gst_buffer_list_iterator_add (it, buf2);
 198   buf3 = gst_buffer_new ();
 199   gst_buffer_list_iterator_add (it, buf3);
 200   gst_buffer_list_iterator_free (it);
 201
 202   /* make a copy */
 203   list_copy = gst_buffer_list_copy (list);
 204   fail_unless (GST_MINI_OBJECT_REFCOUNT_VALUE (list) == 1);
 205   fail_unless (GST_MINI_OBJECT_REFCOUNT_VALUE (list_copy) == 1);
 206   fail_unless (list_copy != list);
 207   it = gst_buffer_list_iterate (list_copy);
 208   fail_unless (gst_buffer_list_iterator_next_group (it));
 209   buf = gst_buffer_list_iterator_next (it);
 210   fail_unless (buf == buf1);
 211   ASSERT_BUFFER_REFCOUNT (buf1, "buf1", 2);
 212   fail_unless (gst_buffer_list_iterator_next (it) == NULL);
 213   fail_unless (gst_buffer_list_iterator_next_group (it));
 214   buf = gst_buffer_list_iterator_next (it);
 215   fail_unless (buf == buf2);
 216   ASSERT_BUFFER_REFCOUNT (buf2, "buf2", 2);
 217   buf = gst_buffer_list_iterator_next (it);
 218   fail_unless (buf == buf3);
 219   ASSERT_BUFFER_REFCOUNT (buf3, "buf3", 2);
 220   fail_unless (gst_buffer_list_iterator_next (it) == NULL);
 221   fail_if (gst_buffer_list_iterator_next_group (it));
 222   gst_buffer_list_iterator_free (it);
 223   gst_buffer_list_unref (list_copy);
 224 }
 225
 226 GST_END_TEST;
 227
 228 GST_START_TEST (test_steal)
 229 {
 230   GstBufferListIterator *it;
 231   GstBuffer *buf1;
 232   GstBuffer *buf2;
 233   GstBuffer *buf3;
 234   GstBuffer *buf;
 235
 236   /* add buffers to the list */
 237   it = gst_buffer_list_iterate (list);
 238   gst_buffer_list_iterator_add_group (it);
 239   buf1 = gst_buffer_new ();
 240   gst_buffer_list_iterator_add (it, buf1);
 241   gst_buffer_list_iterator_add_group (it);
 242   buf2 = gst_buffer_new ();
 243   gst_buffer_list_iterator_add (it, buf2);
 244   buf3 = gst_buffer_new ();
 245   gst_buffer_list_iterator_add (it, buf3);
 246   gst_buffer_list_iterator_free (it);
 247
 248   /* check some error handling */
 249   ASSERT_CRITICAL ((buf = gst_buffer_list_iterator_steal (NULL)));
 250   fail_unless (buf == NULL);
 251   it = gst_buffer_list_iterate (list);
 252   ASSERT_CRITICAL ((buf = gst_buffer_list_iterator_steal (it)));
 253   fail_unless (buf == NULL);
 254
 255   /* steal the first buffer */
 256   ASSERT_CRITICAL ((buf = gst_buffer_list_iterator_steal (it)));
 257   fail_unless (gst_buffer_list_iterator_next_group (it));
 258   ASSERT_CRITICAL ((buf = gst_buffer_list_iterator_steal (it)));
 259   fail_unless (gst_buffer_list_iterator_next (it) == buf1);
 260   buf = gst_buffer_list_iterator_steal (it);
 261   fail_unless (buf == buf1);
 262   ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
 263   gst_buffer_unref (buf);
 264   ASSERT_CRITICAL ((buf = gst_buffer_list_iterator_steal (it)));
 265   fail_unless (buf == NULL);
 266
 267   /* steal the second buffer */
 268   fail_unless (gst_buffer_list_iterator_next_group (it));
 269   ASSERT_CRITICAL ((buf = gst_buffer_list_iterator_steal (it)));
 270   fail_unless (gst_buffer_list_iterator_next (it) == buf2);
 271   buf = gst_buffer_list_iterator_steal (it);
 272   fail_unless (buf == buf2);
 273   ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
 274   gst_buffer_unref (buf);
 275   ASSERT_CRITICAL ((buf = gst_buffer_list_iterator_steal (it)));
 276
 277   /* steal the third buffer */
 278   fail_unless (gst_buffer_list_iterator_next (it) == buf3);
 279   buf = gst_buffer_list_iterator_steal (it);
 280   fail_unless (buf == buf3);
 281   ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
 282   gst_buffer_unref (buf);
 283   ASSERT_CRITICAL ((buf = gst_buffer_list_iterator_steal (it)));
 284
 285   gst_buffer_list_iterator_free (it);
 286
 287   /* iterate again when all buffers have been stolen */
 288   it = gst_buffer_list_iterate (list);
 289   fail_unless (gst_buffer_list_iterator_next (it) == NULL);
 290   fail_unless (gst_buffer_list_iterator_next_group (it));
 291   fail_unless (gst_buffer_list_iterator_next (it) == NULL);
 292   fail_unless (gst_buffer_list_iterator_next_group (it));
 293   fail_unless (gst_buffer_list_iterator_next (it) == NULL);
 294   fail_if (gst_buffer_list_iterator_next_group (it));
 295   gst_buffer_list_iterator_free (it);
 296 }
 297
 298 GST_END_TEST;
 299
 300 GST_START_TEST (test_take)
 301 {
 302   GstBufferListIterator *it;
 303   GstBuffer *buf1;
 304   GstBuffer *buf2;
 305   GstBuffer *buf3;
 306   GstBuffer *buf;
 307
 308   /* add buffers to the list */
 309   it = gst_buffer_list_iterate (list);
 310   gst_buffer_list_iterator_add_group (it);
 311   buf1 = gst_buffer_new ();
 312   gst_buffer_ref (buf1);
 313   gst_buffer_list_iterator_add (it, buf1);
 314   gst_buffer_list_iterator_add_group (it);
 315   buf2 = gst_buffer_new ();
 316   gst_buffer_ref (buf2);
 317   gst_buffer_list_iterator_add (it, buf2);
 318   buf3 = gst_buffer_new ();
 319   gst_buffer_ref (buf3);
 320   gst_buffer_list_iterator_add (it, buf3);
 321   gst_buffer_list_iterator_free (it);
 322
 323   /* check some error handling */
 324   ASSERT_CRITICAL (gst_buffer_list_iterator_take (NULL, NULL));
 325   it = gst_buffer_list_iterate (list);
 326   ASSERT_CRITICAL (gst_buffer_list_iterator_take (it, NULL));
 327   buf = gst_buffer_new ();
 328   gst_buffer_ref (buf);
 329   ASSERT_CRITICAL (gst_buffer_list_iterator_take (NULL, buf));
 330   ASSERT_BUFFER_REFCOUNT (buf, "buf", 2);
 331
 332   /* replace the first buffer */
 333   ASSERT_CRITICAL (gst_buffer_list_iterator_take (it, buf));
 334   ASSERT_BUFFER_REFCOUNT (buf, "buf", 2);
 335   fail_unless (gst_buffer_list_iterator_next_group (it));
 336   ASSERT_CRITICAL (gst_buffer_list_iterator_take (it, buf));
 337   ASSERT_BUFFER_REFCOUNT (buf, "buf", 2);
 338   fail_unless (gst_buffer_list_iterator_next (it) == buf1);
 339   ASSERT_CRITICAL (gst_buffer_list_iterator_take (it, NULL));
 340   ASSERT_BUFFER_REFCOUNT (buf1, "buf1", 2);
 341   gst_buffer_list_iterator_take (it, buf);
 342   ASSERT_BUFFER_REFCOUNT (buf, "buf", 2);
 343   ASSERT_BUFFER_REFCOUNT (buf1, "buf1", 1);
 344   gst_buffer_unref (buf1);
 345
 346   /* replace the first buffer again, with itself */
 347   gst_buffer_ref (buf);
 348   gst_buffer_list_iterator_take (it, buf);
 349   ASSERT_BUFFER_REFCOUNT (buf, "buf", 2);
 350
 351   /* replace the second buffer */
 352   gst_buffer_ref (buf);
 353   fail_unless (gst_buffer_list_iterator_next (it) == NULL);
 354   ASSERT_CRITICAL (gst_buffer_list_iterator_take (it, buf));
 355   ASSERT_BUFFER_REFCOUNT (buf, "buf", 3);
 356   fail_unless (gst_buffer_list_iterator_next_group (it));
 357   ASSERT_BUFFER_REFCOUNT (buf2, "buf2", 2);
 358   ASSERT_CRITICAL (gst_buffer_list_iterator_take (it, buf));
 359   ASSERT_BUFFER_REFCOUNT (buf, "buf", 3);
 360   ASSERT_BUFFER_REFCOUNT (buf2, "buf2", 2);
 361   fail_unless (gst_buffer_list_iterator_next (it) == buf2);
 362   ASSERT_CRITICAL (gst_buffer_list_iterator_take (it, NULL));
 363   ASSERT_BUFFER_REFCOUNT (buf2, "buf2", 2);
 364   gst_buffer_list_iterator_take (it, buf);
 365   ASSERT_BUFFER_REFCOUNT (buf, "buf", 3);
 366   ASSERT_BUFFER_REFCOUNT (buf2, "buf2", 1);
 367   gst_buffer_unref (buf2);
 368
 369   /* replace the third buffer */
 370   gst_buffer_ref (buf);
 371   fail_unless (gst_buffer_list_iterator_next (it) == buf3);
 372   ASSERT_BUFFER_REFCOUNT (buf3, "buf3", 2);
 373   gst_buffer_list_iterator_take (it, buf);
 374   ASSERT_BUFFER_REFCOUNT (buf, "buf", 4);
 375   ASSERT_BUFFER_REFCOUNT (buf3, "buf3", 1);
 376   gst_buffer_unref (buf3);
 377   fail_if (gst_buffer_list_iterator_next_group (it));
 378   ASSERT_CRITICAL (gst_buffer_list_iterator_take (it, buf));
 379   ASSERT_BUFFER_REFCOUNT (buf, "buf", 4);
 380   gst_buffer_unref (buf);
 381
 382   gst_buffer_list_iterator_free (it);
 383 }
 384
 385 GST_END_TEST;
 386
 387 static gpointer do_data_func_data;
 388 static gboolean notified;
 389
 390 static GstBuffer *
 391 do_data_func (GstBuffer * buffer, gpointer data)
 392 {
 393   do_data_func_data = data;
 394   fail_if (notified);
 395
 396   return buffer;
 397 }
 398
 399 static GstBuffer *
 400 do_func_null (GstBuffer * buffer)
 401 {
 402   gst_buffer_unref (buffer);
 403
 404   return NULL;
 405 }
 406
 407 GST_START_TEST (test_do)
 408 {
 409   GstBufferListIterator *it;
 410   GstBuffer *buf1;
 411   GstBuffer *buf;
 412   gchar *data;
 413
 414   /* error handling */
 415   ASSERT_CRITICAL ((buf = gst_buffer_list_iterator_do (NULL, NULL, NULL)));
 416   fail_unless (buf == NULL);
 417   fail_unless (buf == NULL);
 418   it = gst_buffer_list_iterate (list);
 419   ASSERT_CRITICAL ((buf = gst_buffer_list_iterator_do (it, NULL, NULL)));
 420   fail_unless (buf == NULL);
 421   fail_unless (buf == NULL);
 422
 423   /* add buffers to the list */
 424   gst_buffer_list_iterator_add_group (it);
 425   buf1 = gst_buffer_new ();
 426   gst_buffer_ref (buf1);
 427   gst_buffer_list_iterator_add (it, buf1);
 428   gst_buffer_list_iterator_add_group (it);
 429   gst_buffer_list_iterator_free (it);
 430
 431   /* call do-function */
 432   it = gst_buffer_list_iterate (list);
 433   fail_unless (gst_buffer_list_iterator_next_group (it));
 434   ASSERT_CRITICAL ((buf =
 435           gst_buffer_list_iterator_do (it,
 436               (GstBufferListDoFunction) gst_buffer_ref, NULL)));
 437   fail_unless (buf == NULL);
 438   data = (char *) "data";
 439   ASSERT_CRITICAL ((buf = gst_buffer_list_iterator_do (it, do_data_func,
 440               data)));
 441   fail_unless (buf == NULL);
 442   fail_unless (do_data_func_data != data);
 443   buf = gst_buffer_list_iterator_next (it);
 444   fail_unless (buf == buf1);
 445   ASSERT_BUFFER_REFCOUNT (buf1, "buf1", 2);
 446   buf =
 447       gst_buffer_list_iterator_do (it, (GstBufferListDoFunction) gst_buffer_ref,
 448       NULL);
 449   fail_unless (buf == buf1);
 450   ASSERT_BUFFER_REFCOUNT (buf1, "buf1", 3);
 451   gst_buffer_unref (buf);
 452   buf = gst_buffer_list_iterator_do (it, do_data_func, data);
 453   fail_unless (buf == buf1);
 454   fail_unless (do_data_func_data == data);
 455
 456   /* do-function that return a new buffer replaces the buffer in the list */
 457   ASSERT_BUFFER_REFCOUNT (buf1, "buf1", 2);
 458   buf = gst_buffer_list_iterator_do (it,
 459       (GstBufferListDoFunction) gst_mini_object_make_writable, NULL);
 460   fail_unless (buf != buf1);
 461   ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
 462   ASSERT_BUFFER_REFCOUNT (buf, "buf1", 1);
 463   gst_buffer_replace (&buf1, buf);
 464
 465   /* do-function that return NULL removes the buffer from the list */
 466   ASSERT_BUFFER_REFCOUNT (buf1, "buf1", 2);
 467   fail_unless (gst_buffer_list_iterator_do (it,
 468           (GstBufferListDoFunction) do_func_null, NULL) == NULL);
 469   ASSERT_BUFFER_REFCOUNT (buf1, "buf1", 1);
 470   ASSERT_CRITICAL ((buf =
 471           gst_buffer_list_iterator_do (it,
 472               (GstBufferListDoFunction) gst_buffer_ref, NULL)));
 473   fail_unless (buf == NULL);
 474   fail_unless (gst_buffer_list_iterator_next (it) == NULL);
 475   gst_buffer_list_iterator_free (it);
 476   it = gst_buffer_list_iterate (list);
 477   fail_unless (gst_buffer_list_iterator_next_group (it));
 478   fail_unless (gst_buffer_list_iterator_next (it) == NULL);
 479   fail_if (gst_buffer_list_iterator_next_group (it));
 480   gst_buffer_list_iterator_free (it);
 481   gst_buffer_unref (buf1);
 482 }
 483
 484 GST_END_TEST;
 485
 486 GST_START_TEST (test_merge)
 487 {
 488   GstBufferListIterator *it;
 489   GstBufferListIterator *merge_it;
 490   GstBuffer *merged_buf;
 491   GstBuffer *buf;
 492
 493   it = gst_buffer_list_iterate (list);
 494   fail_unless (gst_buffer_list_iterator_merge_group (it) == NULL);
 495
 496   /* create a new group and add a buffer */
 497   gst_buffer_list_iterator_add_group (it);
 498   fail_unless (gst_buffer_list_iterator_merge_group (it) == NULL);
 499   buf = buffer_from_string ("One");
 500   gst_buffer_ref (buf);
 501   gst_buffer_list_iterator_add (it, buf);
 502
 503   /* merging a group with one buffer returns a copy of the buffer */
 504   merge_it = gst_buffer_list_iterate (list);
 505   fail_unless (gst_buffer_list_iterator_next_group (merge_it));
 506   merged_buf = gst_buffer_list_iterator_merge_group (merge_it);
 507   fail_unless (merged_buf != buf);
 508   ASSERT_BUFFER_REFCOUNT (merged_buf, "merged_buf", 1);
 509   gst_buffer_unref (buf);
 510   fail_unless (GST_BUFFER_CAPS (merged_buf) == caps);
 511   fail_unless (GST_BUFFER_TIMESTAMP (merged_buf) == TIMESTAMP);
 512   check_buffer (merged_buf, 3, "One");
 513   gst_buffer_unref (merged_buf);
 514
 515   /* add another buffer to the same group */
 516   gst_buffer_list_iterator_add (it, buffer_from_string ("Group"));
 517
 518   /* merging a group returns a new buffer with merged data */
 519   merged_buf = gst_buffer_list_iterator_merge_group (merge_it);
 520   ASSERT_BUFFER_REFCOUNT (merged_buf, "merged_buf", 1);
 521   fail_unless (GST_BUFFER_CAPS (merged_buf) == caps);
 522   fail_unless (GST_BUFFER_TIMESTAMP (merged_buf) == TIMESTAMP);
 523   check_buffer (merged_buf, 8, "OneGroup");
 524
 525   /* merging the same group again should return a new buffer with merged data */
 526   buf = gst_buffer_list_iterator_merge_group (merge_it);
 527   ASSERT_BUFFER_REFCOUNT (buf, "buf", 1);
 528   fail_unless (buf != merged_buf);
 529   check_buffer (buf, 8, "OneGroup");
 530   gst_buffer_unref (buf);
 531   gst_buffer_unref (merged_buf);
 532
 533   /* add a new group */
 534   gst_buffer_list_iterator_add_group (it);
 535   gst_buffer_list_iterator_add (it, buffer_from_string ("AnotherGroup"));
 536   gst_buffer_list_iterator_free (it);
 537
 538   /* merge the first group again */
 539   merged_buf = gst_buffer_list_iterator_merge_group (merge_it);
 540   ASSERT_BUFFER_REFCOUNT (merged_buf, "merged_buf", 1);
 541   fail_unless (GST_BUFFER_CAPS (merged_buf) == caps);
 542   fail_unless (GST_BUFFER_TIMESTAMP (merged_buf) == TIMESTAMP);
 543   check_buffer (merged_buf, 8, "OneGroup");
 544   gst_buffer_unref (merged_buf);
 545
 546   /* merge the second group */
 547   fail_unless (gst_buffer_list_iterator_next_group (merge_it));
 548   merged_buf = gst_buffer_list_iterator_merge_group (merge_it);
 549   ASSERT_BUFFER_REFCOUNT (merged_buf, "merged_buf", 1);
 550   fail_unless (GST_BUFFER_CAPS (merged_buf) == caps);
 551   fail_unless (GST_BUFFER_TIMESTAMP (merged_buf) == TIMESTAMP);
 552   check_buffer (merged_buf, 12, "AnotherGroup");
 553   gst_buffer_unref (merged_buf);
 554
 555   gst_buffer_list_iterator_free (merge_it);
 556
 557   /* steal the second buffer and merge the first group again */
 558   it = gst_buffer_list_iterate (list);
 559   fail_unless (gst_buffer_list_iterator_next_group (it));
 560   fail_unless (gst_buffer_list_iterator_next (it) != NULL);
 561   fail_unless (gst_buffer_list_iterator_next (it) != NULL);
 562   buf = gst_buffer_list_iterator_steal (it);
 563   gst_buffer_list_iterator_free (it);
 564   fail_unless (buf != NULL);
 565   check_buffer (buf, 0, "Group");
 566   gst_buffer_unref (buf);
 567   merge_it = gst_buffer_list_iterate (list);
 568   fail_unless (gst_buffer_list_iterator_next_group (merge_it));
 569   merged_buf = gst_buffer_list_iterator_merge_group (merge_it);
 570   ASSERT_BUFFER_REFCOUNT (merged_buf, "merged_buf", 1);
 571   fail_unless (GST_BUFFER_CAPS (merged_buf) == caps);
 572   fail_unless (GST_BUFFER_TIMESTAMP (merged_buf) == TIMESTAMP);
 573   check_buffer (merged_buf, 3, "One");
 574   gst_buffer_unref (merged_buf);
 575
 576   /* steal the first buffer too and merge the first group again */
 577   it = gst_buffer_list_iterate (list);
 578   fail_unless (gst_buffer_list_iterator_next_group (it));
 579   fail_unless (gst_buffer_list_iterator_next (it) != NULL);
 580   buf = gst_buffer_list_iterator_steal (it);
 581   fail_unless (buf != NULL);
 582   check_buffer (buf, 3, "One");
 583   gst_buffer_unref (buf);
 584   gst_buffer_list_iterator_free (it);
 585   fail_unless (gst_buffer_list_iterator_merge_group (merge_it) == NULL);
 586   gst_buffer_list_iterator_free (merge_it);
 587 }
 588
 589 GST_END_TEST;
 590
 591 typedef struct
 592 {
 593   GstBuffer *buf[3][3];
 594   guint iter;
 595 } ForeachData;
 596
 597 static GstBufferListItem
 598 foreach_func1 (GstBuffer ** buffer, guint group, guint idx, ForeachData * data)
 599 {
 600   fail_unless (buffer != NULL);
 601   fail_unless (*buffer == data->buf[group][idx]);
 602
 603   data->iter++;
 604
 605   return GST_BUFFER_LIST_CONTINUE;
 606 }
 607
 608 static GstBufferListItem
 609 foreach_func2 (GstBuffer ** buffer, guint group, guint idx, ForeachData * data)
 610 {
 611   fail_unless (idx == 0);
 612   fail_unless (buffer != NULL);
 613   fail_unless (*buffer == data->buf[group][idx]);
 614
 615   data->iter++;
 616
 617   return GST_BUFFER_LIST_SKIP_GROUP;
 618 }
 619
 620 static GstBufferListItem
 621 foreach_func3 (GstBuffer ** buffer, guint group, guint idx, ForeachData * data)
 622 {
 623   fail_unless (group == 0);
 624   fail_unless (idx == 0);
 625   fail_unless (buffer != NULL);
 626   fail_unless (*buffer == data->buf[group][idx]);
 627
 628   data->iter++;
 629
 630   return GST_BUFFER_LIST_END;
 631 }
 632
 633 static GstBufferListItem
 634 foreach_func4 (GstBuffer ** buffer, guint group, guint idx, ForeachData * data)
 635 {
 636   fail_unless (idx == 0);
 637   fail_unless (buffer != NULL);
 638   fail_unless (*buffer == data->buf[group][idx]);
 639
 640   gst_buffer_unref (*buffer);
 641   *buffer = NULL;
 642   data->iter++;
 643
 644   return GST_BUFFER_LIST_SKIP_GROUP;
 645 }
 646
 647 static GstBufferListItem
 648 foreach_func5 (GstBuffer ** buffer, guint group, guint idx, ForeachData * data)
 649 {
 650   fail_unless (buffer != NULL);
 651
 652   data->iter++;
 653
 654   return GST_BUFFER_LIST_CONTINUE;
 655 }
 656
 657 GST_START_TEST (test_foreach)
 658 {
 659   GstBufferListIterator *it;
 660   ForeachData data;
 661
 662   /* add buffers to the list */
 663   it = gst_buffer_list_iterate (list);
 664   gst_buffer_list_iterator_add_group (it);
 665   data.buf[0][0] = gst_buffer_new ();
 666   gst_buffer_list_iterator_add (it, data.buf[0][0]);
 667   gst_buffer_list_iterator_add_group (it);
 668   data.buf[1][0] = gst_buffer_new ();
 669   gst_buffer_list_iterator_add (it, data.buf[1][0]);
 670   data.buf[1][1] = gst_buffer_new ();
 671   gst_buffer_list_iterator_add (it, data.buf[1][1]);
 672   gst_buffer_list_iterator_free (it);
 673
 674   fail_unless (gst_buffer_list_get (list, 0, 0) == data.buf[0][0]);
 675   fail_unless (gst_buffer_list_get (list, 0, 1) == NULL);
 676   fail_unless (gst_buffer_list_get (list, 1, 0) == data.buf[1][0]);
 677   fail_unless (gst_buffer_list_get (list, 1, 1) == data.buf[1][1]);
 678   fail_unless (gst_buffer_list_get (list, 1, 2) == NULL);
 679   fail_unless (gst_buffer_list_get (list, 2, 0) == NULL);
 680   fail_unless (gst_buffer_list_get (list, 2, 1) == NULL);
 681   fail_unless (gst_buffer_list_get (list, 3, 3) == NULL);
 682
 683   /* iterate everything */
 684   data.iter = 0;
 685   gst_buffer_list_foreach (list, (GstBufferListFunc) foreach_func1, &data);
 686   fail_unless (data.iter == 3);
 687
 688   /* iterate only the first buffer of groups */
 689   data.iter = 0;
 690   gst_buffer_list_foreach (list, (GstBufferListFunc) foreach_func2, &data);
 691   fail_unless (data.iter == 2);
 692
 693   /* iterate only the first buffer */
 694   data.iter = 0;
 695   gst_buffer_list_foreach (list, (GstBufferListFunc) foreach_func3, &data);
 696   fail_unless (data.iter == 1);
 697
 698   /* remove the first buffer of each group */
 699   data.iter = 0;
 700   gst_buffer_list_foreach (list, (GstBufferListFunc) foreach_func4, &data);
 701   fail_unless (data.iter == 2);
 702
 703   fail_unless (gst_buffer_list_get (list, 0, 0) == NULL);
 704   fail_unless (gst_buffer_list_get (list, 0, 1) == NULL);
 705   fail_unless (gst_buffer_list_get (list, 1, 0) == data.buf[1][1]);
 706   fail_unless (gst_buffer_list_get (list, 1, 1) == NULL);
 707   fail_unless (gst_buffer_list_get (list, 1, 2) == NULL);
 708   fail_unless (gst_buffer_list_get (list, 2, 0) == NULL);
 709
 710   /* iterate everything, just one more buffer now */
 711   data.iter = 0;
 712   gst_buffer_list_foreach (list, (GstBufferListFunc) foreach_func5, &data);
 713   fail_unless (data.iter == 1);
 714 }
 715
 716 GST_END_TEST;
 717
 718 GST_START_TEST (test_list)
 719 {
 720   GstBufferListIterator *it;
 721   GList *l = NULL;
 722   gint i;
 723
 724   for (i = 0; i < 10; i++) {
 725     gchar name[10];
 726     g_snprintf (name, 10, "%d", i);
 727     l = g_list_append (l, buffer_from_string (name));
 728   }
 729
 730   /* add buffers to the list */
 731   it = gst_buffer_list_iterate (list);
 732   gst_buffer_list_iterator_add_group (it);
 733   gst_buffer_list_iterator_add_list (it, l);
 734
 735   /* add a buffer */
 736   gst_buffer_list_iterator_add (it, buffer_from_string ("10"));
 737
 738   /* add another list */
 739   l = g_list_append (NULL, buffer_from_string ("11"));
 740   gst_buffer_list_iterator_add_list (it, l);
 741
 742   for (i = 0; i < 12; i++) {
 743     GstBuffer *buf;
 744     gchar name[10];
 745
 746     buf = gst_buffer_list_get (list, 0, i);
 747     g_snprintf (name, 10, "%d", i);
 748     check_buffer (buf, 0, name);
 749   }
 750   gst_buffer_list_iterator_free (it);
 751 }
 752
 753 GST_END_TEST;
 754 #endif
 755
 756 static Suite *
 757 gst_buffer_list_suite (void)
 758 {
 759   Suite *s = suite_create ("GstBufferList");
 760   TCase *tc_chain = tcase_create ("general");
 761
 762   suite_add_tcase (s, tc_chain);
 763   tcase_add_checked_fixture (tc_chain, setup, cleanup);
 764   tcase_add_test (tc_chain, test_add_and_iterate);
 765 #if 0
 766   tcase_add_test (tc_chain, test_make_writable);
 767   tcase_add_test (tc_chain, test_copy);
 768   tcase_add_test (tc_chain, test_steal);
 769   tcase_add_test (tc_chain, test_take);
 770   tcase_add_test (tc_chain, test_do);
 771   tcase_add_test (tc_chain, test_merge);
 772   tcase_add_test (tc_chain, test_foreach);
 773   tcase_add_test (tc_chain, test_list);
 774 #endif
 775
 776   return s;
 777 }
 778
 779 GST_CHECK_MAIN (gst_buffer_list);