tests/check/elements/gdppay.c

   1 /* GStreamer
   2  *
   3  * Copyright (C) 2006 Thomas Vander Stichele <thomas at apestaart dot org>
   4  *
   5  * This library is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU Library General Public
   7  * License as published by the Free Software Foundation; either
   8  * version 2 of the License, or (at your option) any later version.
   9  *
  10  * This library is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  13  * Library General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU Library General Public
  16  * License along with this library; if not, write to the
  17  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
  18  * Boston, MA 02111-1307, USA.
  19  */
  20
  21 #include <string.h>
  22 #include <unistd.h>
  23
  24 #include <gst/check/gstcheck.h>
  25 #include <gst/dataprotocol/dataprotocol.h>
  26
  27 gboolean have_eos = FALSE;
  28
  29 /* For ease of programming we use globals to keep refs for our floating
  30  * src and sink pads we create; otherwise we always have to do get_pad,
  31  * get_peer, and then remove references in every test function */
  32 GstPad *mysrcpad, *myshsrcpad, *mysinkpad;
  33
  34 #define AUDIO_CAPS_TEMPLATE_STRING \
  35   "audio/x-raw-int, " \
  36     "rate = (int) [ 1, MAX ], " \
  37     "channels = (int) [ 1, 8 ], " \
  38     "endianness = (int) BYTE_ORDER, " \
  39     "width = (int) {8, 16}, " \
  40     "depth = (int) {8, 16}, " \
  41     "signed = (boolean) true"
  42
  43 #define AUDIO_CAPS_STRING \
  44   "audio/x-raw-int, " \
  45     "rate = (int) 1000, " \
  46     "channels = (int) 2, " \
  47     "endianness = (int) BYTE_ORDER, " \
  48     "width = (int) 16, " \
  49     "depth = (int) 16, " \
  50     "signed = (boolean) true"
  51
  52
  53 static GstStaticPadTemplate sinktemplate = GST_STATIC_PAD_TEMPLATE ("sink",
  54     GST_PAD_SINK,
  55     GST_PAD_ALWAYS,
  56     GST_STATIC_CAPS ("application/x-gdp")
  57     );
  58 static GstStaticPadTemplate srctemplate = GST_STATIC_PAD_TEMPLATE ("src",
  59     GST_PAD_SRC,
  60     GST_PAD_ALWAYS,
  61     GST_STATIC_CAPS (AUDIO_CAPS_TEMPLATE_STRING)
  62     );
  63
  64 /* takes over reference for outcaps */
  65 GstElement *
  66 setup_gdppay ()
  67 {
  68   GstElement *gdppay;
  69
  70   GST_DEBUG ("setup_gdppay");
  71   gdppay = gst_check_setup_element ("gdppay");
  72   mysrcpad = gst_check_setup_src_pad (gdppay, &srctemplate, NULL);
  73   mysinkpad = gst_check_setup_sink_pad (gdppay, &sinktemplate, NULL);
  74
  75   return gdppay;
  76 }
  77
  78 void
  79 cleanup_gdppay (GstElement * gdppay)
  80 {
  81   GST_DEBUG ("cleanup_gdppay");
  82
  83   gst_check_teardown_src_pad (gdppay);
  84   gst_check_teardown_sink_pad (gdppay);
  85   gst_check_teardown_element (gdppay);
  86 }
  87
  88 GST_START_TEST (test_audio)
  89 {
  90   GstCaps *caps;
  91   GstElement *gdppay;
  92   GstBuffer *inbuffer, *outbuffer;
  93   GstEvent *event;
  94   gchar *caps_string;
  95   gint length;
  96
  97   gdppay = setup_gdppay ();
  98
  99   fail_unless (gst_element_set_state (gdppay,
 100           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 101       "could not set to playing");
 102
 103   GST_DEBUG ("new segment");
 104   event =
 105       gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, 0, GST_SECOND, 0);
 106   fail_unless (gst_pad_push_event (mysrcpad, event));
 107
 108   /* no buffer should be pushed yet, waiting for caps */
 109   fail_unless_equals_int (g_list_length (buffers), 0);
 110
 111   GST_DEBUG ("first buffer");
 112   inbuffer = gst_buffer_new_and_alloc (4);
 113   caps = gst_caps_from_string (AUDIO_CAPS_STRING);
 114   gst_buffer_set_caps (inbuffer, caps);
 115   caps_string = gst_caps_to_string (caps);
 116
 117   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 118
 119   /* pushing gives away my reference */
 120   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 121
 122   /* we should have three buffers now */
 123   fail_unless_equals_int (g_list_length (buffers), 3);
 124
 125   /* first buffer is the serialized new_segment event;
 126    * the element also holds a ref to it */
 127   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 128   buffers = g_list_remove (buffers, outbuffer);
 129   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 2);
 130   gst_buffer_unref (outbuffer);
 131
 132   /* second buffer is the serialized caps;
 133    * the element also holds a ref to it */
 134   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 135   buffers = g_list_remove (buffers, outbuffer);
 136   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 2);
 137   length = GST_DP_HEADER_LENGTH + (strlen (caps_string) + 1);
 138   fail_unless_equals_int (GST_BUFFER_SIZE (outbuffer), length);
 139   gst_buffer_unref (outbuffer);
 140
 141   /* the third buffer is the GDP buffer for our pushed buffer */
 142   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 143   buffers = g_list_remove (buffers, outbuffer);
 144   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
 145   length = GST_DP_HEADER_LENGTH + 4;
 146   fail_unless_equals_int (GST_BUFFER_SIZE (outbuffer), length);
 147   gst_buffer_unref (outbuffer);
 148
 149   /* second buffer */
 150   GST_DEBUG ("second buffer");
 151   inbuffer = gst_buffer_new_and_alloc (4);
 152   gst_buffer_set_caps (inbuffer, caps);
 153
 154   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 155
 156   /* pushing gives away my reference */
 157   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 158
 159   fail_unless_equals_int (g_list_length (buffers), 1);
 160   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 161   buffers = g_list_remove (buffers, outbuffer);
 162   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
 163
 164   /* the third output buffer is data */
 165   length = GST_DP_HEADER_LENGTH + 4;
 166   fail_unless_equals_int (GST_BUFFER_SIZE (outbuffer), length);
 167   gst_buffer_unref (outbuffer);
 168
 169   /* a third buffer without caps set explicitly; should work */
 170   GST_DEBUG ("Creating third buffer, no caps set");
 171   inbuffer = gst_buffer_new_and_alloc (4);
 172
 173   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 174
 175   /* pushing gives away my reference */
 176   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 177
 178   fail_unless_equals_int (g_list_length (buffers), 1);
 179   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 180   buffers = g_list_remove (buffers, outbuffer);
 181   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
 182
 183   /* the fourth output buffer is data */
 184   length = GST_DP_HEADER_LENGTH + 4;
 185   fail_unless_equals_int (GST_BUFFER_SIZE (outbuffer), length);
 186   gst_buffer_unref (outbuffer);
 187
 188
 189   fail_unless (gst_element_set_state (gdppay,
 190           GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
 191
 192   gst_caps_unref (caps);
 193   g_free (caps_string);
 194   g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
 195   g_list_free (buffers);
 196   buffers = NULL;
 197   ASSERT_OBJECT_REFCOUNT (gdppay, "gdppay", 1);
 198   gst_object_unref (gdppay);
 199 }
 200
 201 GST_END_TEST;
 202
 203 static GstStaticPadTemplate shsrctemplate = GST_STATIC_PAD_TEMPLATE ("src",
 204     GST_PAD_SRC,
 205     GST_PAD_ALWAYS,
 206     GST_STATIC_CAPS ("application/x-gst-test-streamheader")
 207     );
 208
 209
 210 GstElement *
 211 setup_gdppay_streamheader ()
 212 {
 213   GstElement *gdppay;
 214
 215   GST_DEBUG ("setup_gdppay");
 216   gdppay = gst_check_setup_element ("gdppay");
 217   myshsrcpad = gst_check_setup_src_pad (gdppay, &shsrctemplate, NULL);
 218   mysinkpad = gst_check_setup_sink_pad (gdppay, &sinktemplate, NULL);
 219
 220   return gdppay;
 221 }
 222
 223 /* this test serializes a stream that already has a streamheader of its own.
 224  * the streamheader should then be serialized and put on the GDP stream's
 225  * streamheader */
 226 GST_START_TEST (test_streamheader)
 227 {
 228   GstCaps *caps, *sinkcaps;
 229   GstElement *gdppay;
 230   GstBuffer *inbuffer, *outbuffer, *shbuffer;
 231   GstEvent *event;
 232   gchar *caps_string;
 233   gint length;
 234   GstStructure *structure;
 235   GValue array = { 0 };
 236   GValue value = { 0 };
 237   const GValue *sh;
 238   GArray *shbuffers;
 239
 240
 241   gdppay = setup_gdppay_streamheader ();
 242
 243   fail_unless (gst_element_set_state (gdppay,
 244           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 245       "could not set to playing");
 246
 247   GST_DEBUG ("new segment");
 248   event =
 249       gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, 0, GST_SECOND, 0);
 250   fail_unless (gst_pad_push_event (myshsrcpad, event));
 251
 252   /* no buffer should be pushed yet, still waiting for caps */
 253   fail_unless_equals_int (g_list_length (buffers), 0);
 254
 255   GST_DEBUG ("first buffer");
 256   inbuffer = gst_buffer_new_and_alloc (4);
 257   memcpy (GST_BUFFER_DATA (inbuffer), "head", 4);
 258   caps = gst_caps_from_string ("application/x-gst-test-streamheader");
 259   structure = gst_caps_get_structure (caps, 0);
 260   GST_BUFFER_FLAG_SET (inbuffer, GST_BUFFER_FLAG_IN_CAPS);
 261   g_value_init (&array, GST_TYPE_ARRAY);
 262   g_value_init (&value, GST_TYPE_BUFFER);
 263   shbuffer = gst_buffer_copy (inbuffer);
 264   gst_value_set_buffer (&value, shbuffer);
 265   gst_buffer_unref (shbuffer);
 266   gst_value_array_append_value (&array, &value);
 267   g_value_unset (&value);
 268   gst_structure_set_value (structure, "streamheader", &array);
 269   g_value_unset (&array);
 270   caps_string = gst_caps_to_string (caps);
 271
 272   gst_buffer_set_caps (inbuffer, caps);
 273   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 274
 275   /* pushing gives away my reference */
 276   fail_unless (gst_pad_push (myshsrcpad, inbuffer) == GST_FLOW_OK);
 277
 278   /* we should have three buffers now */
 279   fail_unless_equals_int (g_list_length (buffers), 3);
 280
 281   /* our sink pad should now have GDP caps with a streamheader that includes
 282    * GDP wrappings of our streamheader */
 283   sinkcaps = gst_pad_get_negotiated_caps (mysinkpad);
 284   structure = gst_caps_get_structure (sinkcaps, 0);
 285   fail_unless_equals_string ((gchar *) gst_structure_get_name (structure),
 286       "application/x-gdp");
 287   fail_unless (gst_structure_has_field (structure, "streamheader"));
 288   sh = gst_structure_get_value (structure, "streamheader");
 289   fail_unless (G_VALUE_TYPE (sh) == GST_TYPE_ARRAY);
 290   shbuffers = g_value_peek_pointer (sh);
 291   /* a serialized new_segment, a serialized caps, and serialization of our
 292    * incoming streamheader */
 293   fail_unless_equals_int (shbuffers->len, 3);
 294
 295   gst_caps_unref (sinkcaps);
 296
 297   /* first buffer is the serialized new_segment event;
 298    * the element also holds a ref to it */
 299   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 300   buffers = g_list_remove (buffers, outbuffer);
 301   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 2);
 302   gst_buffer_unref (outbuffer);
 303
 304   /* second buffer is the serialized caps;
 305    * the element also holds a ref to it */
 306   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 307   buffers = g_list_remove (buffers, outbuffer);
 308   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 2);
 309   length = GST_DP_HEADER_LENGTH + (strlen (caps_string) + 1);
 310   fail_unless_equals_int (GST_BUFFER_SIZE (outbuffer), length);
 311   gst_buffer_unref (outbuffer);
 312
 313   /* the third buffer is the GDP buffer for our pushed buffer */
 314   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 315   buffers = g_list_remove (buffers, outbuffer);
 316   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
 317   length = GST_DP_HEADER_LENGTH + 4;
 318   fail_unless_equals_int (GST_BUFFER_SIZE (outbuffer), length);
 319   gst_buffer_unref (outbuffer);
 320
 321   /* second buffer */
 322   GST_DEBUG ("second buffer");
 323   inbuffer = gst_buffer_new_and_alloc (4);
 324   gst_buffer_set_caps (inbuffer, caps);
 325
 326   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 327
 328   /* pushing gives away my reference */
 329   fail_unless (gst_pad_push (myshsrcpad, inbuffer) == GST_FLOW_OK);
 330
 331   fail_unless_equals_int (g_list_length (buffers), 1);
 332   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 333   buffers = g_list_remove (buffers, outbuffer);
 334   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
 335
 336   /* the third output buffer is data */
 337   length = GST_DP_HEADER_LENGTH + 4;
 338   fail_unless_equals_int (GST_BUFFER_SIZE (outbuffer), length);
 339   gst_buffer_unref (outbuffer);
 340
 341   /* a third buffer without caps set explicitly; should work */
 342   GST_DEBUG ("Creating third buffer, no caps set");
 343   inbuffer = gst_buffer_new_and_alloc (4);
 344
 345   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 346
 347   /* pushing gives away my reference */
 348   fail_unless (gst_pad_push (myshsrcpad, inbuffer) == GST_FLOW_OK);
 349
 350   fail_unless_equals_int (g_list_length (buffers), 1);
 351   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 352   buffers = g_list_remove (buffers, outbuffer);
 353   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
 354
 355   /* the fourth output buffer is data */
 356   length = GST_DP_HEADER_LENGTH + 4;
 357   fail_unless_equals_int (GST_BUFFER_SIZE (outbuffer), length);
 358   gst_buffer_unref (outbuffer);
 359
 360
 361   fail_unless (gst_element_set_state (gdppay,
 362           GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
 363
 364   gst_caps_unref (caps);
 365   g_free (caps_string);
 366   g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
 367   g_list_free (buffers);
 368   buffers = NULL;
 369   ASSERT_OBJECT_REFCOUNT (gdppay, "gdppay", 1);
 370   gst_object_unref (gdppay);
 371 }
 372
 373 GST_END_TEST;
 374
 375
 376 GST_START_TEST (test_first_no_caps)
 377 {
 378   GstElement *gdppay;
 379   GstBuffer *inbuffer;
 380
 381   gdppay = setup_gdppay ();
 382
 383   fail_unless (gst_element_set_state (gdppay,
 384           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 385       "could not set to playing");
 386
 387   GST_DEBUG ("first buffer");
 388   inbuffer = gst_buffer_new_and_alloc (4);
 389   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 390
 391   /* pushing should trigger an error */
 392   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_NOT_NEGOTIATED);
 393
 394   fail_unless_equals_int (g_list_length (buffers), 0);
 395
 396   fail_unless (gst_element_set_state (gdppay,
 397           GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
 398
 399   g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
 400   g_list_free (buffers);
 401   buffers = NULL;
 402   ASSERT_OBJECT_REFCOUNT (gdppay, "gdppay", 1);
 403   gst_object_unref (gdppay);
 404 }
 405
 406 GST_END_TEST;
 407
 408 /* element should still work if no new_segment is sent before the first
 409  * buffer */
 410 GST_START_TEST (test_first_no_new_segment)
 411 {
 412   GstElement *gdppay;
 413   GstBuffer *inbuffer;
 414   GstCaps *caps;
 415
 416   gdppay = setup_gdppay ();
 417
 418   fail_unless (gst_element_set_state (gdppay,
 419           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 420       "could not set to playing");
 421
 422   GST_DEBUG ("first buffer");
 423   inbuffer = gst_buffer_new_and_alloc (4);
 424   caps = gst_caps_from_string (AUDIO_CAPS_STRING);
 425   gst_buffer_set_caps (inbuffer, caps);
 426
 427   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 428
 429   /* pushing gives away my reference */
 430   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 431
 432   /* we should have three buffers now;
 433    * one for an "invented" new segment, one for GDP caps, and one with our
 434    * buffer */
 435   fail_unless_equals_int (g_list_length (buffers), 3);
 436
 437   fail_unless (gst_element_set_state (gdppay,
 438           GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
 439
 440   g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
 441   g_list_free (buffers);
 442   buffers = NULL;
 443   ASSERT_OBJECT_REFCOUNT (gdppay, "gdppay", 1);
 444   gst_object_unref (gdppay);
 445 }
 446
 447 GST_END_TEST;
 448
 449 GST_START_TEST (test_crc)
 450 {
 451   GstCaps *caps;
 452   GstElement *gdppay;
 453   GstBuffer *inbuffer, *outbuffer;
 454   GstEvent *event;
 455   gchar *caps_string;
 456   gint length;
 457   guint16 crc_calculated, crc_read;
 458
 459   gdppay = setup_gdppay ();
 460   g_object_set (gdppay, "crc-header", TRUE, NULL);
 461
 462   fail_unless (gst_element_set_state (gdppay,
 463           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
 464       "could not set to playing");
 465
 466   GST_DEBUG ("new segment");
 467   event =
 468       gst_event_new_new_segment (FALSE, 1.0, GST_FORMAT_TIME, 0, GST_SECOND, 0);
 469   fail_unless (gst_pad_push_event (mysrcpad, event));
 470
 471   /* no buffer should be pushed yet, waiting for caps */
 472   fail_unless_equals_int (g_list_length (buffers), 0);
 473
 474   GST_DEBUG ("first buffer");
 475   inbuffer = gst_buffer_new_and_alloc (4);
 476   caps = gst_caps_from_string (AUDIO_CAPS_STRING);
 477   gst_buffer_set_caps (inbuffer, caps);
 478   caps_string = gst_caps_to_string (caps);
 479
 480   ASSERT_BUFFER_REFCOUNT (inbuffer, "inbuffer", 1);
 481
 482   /* pushing gives away my reference */
 483   fail_unless (gst_pad_push (mysrcpad, inbuffer) == GST_FLOW_OK);
 484
 485   /* we should have three buffers now */
 486   fail_unless_equals_int (g_list_length (buffers), 3);
 487
 488   /* first buffer is the serialized new_segment event;
 489    * the element also holds a ref to it */
 490   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 491   buffers = g_list_remove (buffers, outbuffer);
 492   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 2);
 493
 494   /* verify the header checksum */
 495   /* CRC's start at 58 in the header */
 496   crc_calculated = gst_dp_crc (GST_BUFFER_DATA (outbuffer), 58);
 497   crc_read = GST_READ_UINT16_BE (GST_BUFFER_DATA (outbuffer) + 58);
 498   fail_unless_equals_int (crc_calculated, crc_read);
 499
 500   /* change a byte in the header and verify that the checksum now fails */
 501   GST_BUFFER_DATA (outbuffer)[0] = 0xff;
 502   crc_calculated = gst_dp_crc (GST_BUFFER_DATA (outbuffer), 58);
 503   fail_if (crc_calculated == crc_read,
 504       "Introducing a byte error in the header should make the checksum fail");
 505
 506   gst_buffer_unref (outbuffer);
 507
 508   /* second buffer is the serialized caps;
 509    * the element also holds a ref to it */
 510   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 511   buffers = g_list_remove (buffers, outbuffer);
 512   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 2);
 513   length = GST_DP_HEADER_LENGTH + (strlen (caps_string) + 1);
 514   fail_unless_equals_int (GST_BUFFER_SIZE (outbuffer), length);
 515   gst_buffer_unref (outbuffer);
 516
 517   /* the third buffer is the GDP buffer for our pushed buffer */
 518   fail_if ((outbuffer = (GstBuffer *) buffers->data) == NULL);
 519   buffers = g_list_remove (buffers, outbuffer);
 520   ASSERT_BUFFER_REFCOUNT (outbuffer, "outbuffer", 1);
 521   length = GST_DP_HEADER_LENGTH + 4;
 522   fail_unless_equals_int (GST_BUFFER_SIZE (outbuffer), length);
 523   gst_buffer_unref (outbuffer);
 524
 525   fail_unless (gst_element_set_state (gdppay,
 526           GST_STATE_NULL) == GST_STATE_CHANGE_SUCCESS, "could not set to null");
 527
 528   gst_caps_unref (caps);
 529   g_free (caps_string);
 530   g_list_foreach (buffers, (GFunc) gst_mini_object_unref, NULL);
 531   g_list_free (buffers);
 532   buffers = NULL;
 533   ASSERT_OBJECT_REFCOUNT (gdppay, "gdppay", 1);
 534   gst_object_unref (gdppay);
 535 }
 536
 537 GST_END_TEST;
 538
 539
 540 Suite *
 541 gdppay_suite (void)
 542 {
 543   Suite *s = suite_create ("gdppay");
 544   TCase *tc_chain = tcase_create ("general");
 545
 546   suite_add_tcase (s, tc_chain);
 547   tcase_add_test (tc_chain, test_audio);
 548   tcase_add_test (tc_chain, test_first_no_caps);
 549   tcase_add_test (tc_chain, test_first_no_new_segment);
 550   tcase_add_test (tc_chain, test_streamheader);
 551   tcase_add_test (tc_chain, test_crc);
 552
 553   return s;
 554 }
 555
 556 int
 557 main (int argc, char **argv)
 558 {
 559   int nf;
 560
 561   Suite *s = gdppay_suite ();
 562   SRunner *sr = srunner_create (s);
 563
 564   gst_check_init (&argc, &argv);
 565
 566   srunner_run_all (sr, CK_NORMAL);
 567   nf = srunner_ntests_failed (sr);
 568   srunner_free (sr);
 569
 570   return nf;
 571 }