tests: Fix event order warnings and dataflow before stream-start/segment event

diff --git a/tests/check/elements/fakesink.c b/tests/check/elements/fakesink.c
index 131fa5c..639905c 100644 (file)
--- a/tests/check/elements/fakesink.c
+++ b/tests/check/elements/fakesink.c
@@ -98,6 +98,8 @@ GST_START_TEST (test_clipping)
   ret = gst_element_set_state (sink, GST_STATE_PAUSED);
   fail_unless (ret == GST_STATE_CHANGE_ASYNC);
 
+  gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
+
   /* send segment */
   {
     GstEvent *event;
@@ -262,6 +264,8 @@ GST_START_TEST (test_preroll_sync)
   ret = gst_element_set_state (pipeline, GST_STATE_PAUSED);
   fail_unless (ret == GST_STATE_CHANGE_ASYNC);
 
+  gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
+
   /* send segment */
   {
     GstEvent *event;
@@ -475,6 +479,8 @@ GST_START_TEST (test_eos)
     fail_unless (eret == TRUE);
   }
 
+  gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
+
   /* send segment, this should now work again */
   {
     GstEvent *event;
@@ -540,6 +546,8 @@ GST_START_TEST (test_eos2)
   ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);
   fail_unless (ret == GST_STATE_CHANGE_ASYNC);
 
+  gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
+
   /* send segment, this should work */
   {
     GstEvent *event;
@@ -645,6 +653,8 @@ GST_START_TEST (test_position)
   qret = gst_element_query_position (sink, GST_FORMAT_TIME, &qcur);
   fail_unless (qret == FALSE);
 
+  gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
+
   /* send segment, this should work */
   {
     GstSegment segment;

diff --git a/tests/check/elements/filesink.c b/tests/check/elements/filesink.c
index a5b25cd..a28c893 100644 (file)
--- a/tests/check/elements/filesink.c
+++ b/tests/check/elements/filesink.c
@@ -143,6 +143,9 @@ GST_START_TEST (test_seeking)
   gst_query_unref (seeking_query);
 #endif
 
+  fail_unless (gst_pad_push_event (mysrcpad,
+          gst_event_new_stream_start ("test")));
+
   gst_segment_init (&segment, GST_FORMAT_BYTES);
   fail_unless (gst_pad_push_event (mysrcpad, gst_event_new_segment (&segment)));
 

diff --git a/tests/check/elements/funnel.c b/tests/check/elements/funnel.c
index 3aaff1a..29ce15b 100644 (file)
--- a/tests/check/elements/funnel.c
+++ b/tests/check/elements/funnel.c
@@ -36,6 +36,10 @@ struct TestData
 static void
 setup_test_objects (struct TestData *td, GstPadChainFunction chain_func)
 {
+  GstSegment segment;
+
+  gst_segment_init (&segment, GST_FORMAT_BYTES);
+
   td->mycaps = gst_caps_new_empty_simple ("test/test");
 
   td->funnel = gst_element_factory_make ("funnel", NULL);
@@ -57,15 +61,19 @@ setup_test_objects (struct TestData *td, GstPadChainFunction chain_func)
   td->mysink = gst_pad_new ("sink", GST_PAD_SINK);
   gst_pad_set_chain_function (td->mysink, chain_func);
   gst_pad_set_active (td->mysink, TRUE);
-  gst_pad_set_caps (td->mysink, td->mycaps);
 
   td->mysrc1 = gst_pad_new ("src1", GST_PAD_SRC);
   gst_pad_set_active (td->mysrc1, TRUE);
+
+  gst_pad_push_event (td->mysrc1, gst_event_new_stream_start ("test"));
   gst_pad_set_caps (td->mysrc1, td->mycaps);
+  gst_pad_push_event (td->mysrc1, gst_event_new_segment (&segment));
 
   td->mysrc2 = gst_pad_new ("src2", GST_PAD_SRC);
   gst_pad_set_active (td->mysrc2, TRUE);
+  gst_pad_push_event (td->mysrc2, gst_event_new_stream_start ("test"));
   gst_pad_set_caps (td->mysrc2, td->mycaps);
+  gst_pad_push_event (td->mysrc2, gst_event_new_segment (&segment));
 
   fail_unless (GST_PAD_LINK_SUCCESSFUL (gst_pad_link (td->funnelsrc,
               td->mysink)));
@@ -164,6 +172,7 @@ eos_event_func (GstPad * pad, GstObject * parent, GstEvent * event)
 GST_START_TEST (test_funnel_eos)
 {
   struct TestData td;
+  GstSegment segment;
 
   setup_test_objects (&td, chain_ok);
 
@@ -196,6 +205,10 @@ GST_START_TEST (test_funnel_eos)
   fail_unless (gst_pad_push_event (td.mysrc1, gst_event_new_flush_start ()));
   fail_unless (gst_pad_push_event (td.mysrc1, gst_event_new_flush_stop (TRUE)));
 
+  gst_segment_init (&segment, GST_FORMAT_BYTES);
+  gst_pad_push_event (td.mysrc1, gst_event_new_segment (&segment));
+  gst_pad_push_event (td.mysrc2, gst_event_new_segment (&segment));
+
   fail_unless (gst_pad_push (td.mysrc1, gst_buffer_new ()) == GST_FLOW_OK);
   fail_unless (gst_pad_push (td.mysrc2, gst_buffer_new ()) == GST_FLOW_EOS);
 
@@ -236,11 +249,6 @@ funnel_suite (void)
 {
   Suite *s = suite_create ("funnel");
   TCase *tc_chain;
-  GLogLevelFlags fatal_mask;
-
-  fatal_mask = g_log_set_always_fatal (G_LOG_FATAL_MASK);
-  fatal_mask |= G_LOG_LEVEL_WARNING | G_LOG_LEVEL_CRITICAL;
-  g_log_set_always_fatal (fatal_mask);
 
   tc_chain = tcase_create ("funnel simple");
   tcase_add_test (tc_chain, test_funnel_simple);

diff --git a/tests/check/elements/identity.c b/tests/check/elements/identity.c
index 9b01eda..2beb987 100644 (file)
--- a/tests/check/elements/identity.c
+++ b/tests/check/elements/identity.c
@@ -46,12 +46,10 @@ event_func (GstPad * pad, GstObject * parent, GstEvent * event)
 {
   if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) {
     have_eos = TRUE;
-    gst_event_unref (event);
-    return TRUE;
   }
 
   gst_event_unref (event);
-  return FALSE;
+  return TRUE;
 }
 
 static GstElement *
@@ -87,12 +85,17 @@ GST_START_TEST (test_one_buffer)
 {
   GstElement *identity;
   GstBuffer *buffer;
+  GstSegment segment;
 
   identity = setup_identity ();
   fail_unless (gst_element_set_state (identity,
           GST_STATE_PLAYING) == GST_STATE_CHANGE_SUCCESS,
       "could not set to playing");
 
+  gst_segment_init (&segment, GST_FORMAT_BYTES);
+  gst_pad_push_event (mysrcpad, gst_event_new_stream_start ("test"));
+  gst_pad_push_event (mysrcpad, gst_event_new_segment (&segment));
+
   buffer = gst_buffer_new_and_alloc (4);
   ASSERT_BUFFER_REFCOUNT (buffer, "buffer", 1);
 

diff --git a/tests/check/elements/multiqueue.c b/tests/check/elements/multiqueue.c
index f88ed8e..651ff7d 100644 (file)
--- a/tests/check/elements/multiqueue.c
+++ b/tests/check/elements/multiqueue.c
@@ -420,6 +420,9 @@ run_output_order_test (gint n_linked)
   gint i;
   const gint NPADS = 5;
   const gint NBUFFERS = 1000;
+  GstSegment segment;
+
+  gst_segment_init (&segment, GST_FORMAT_BYTES);
 
   g_mutex_init (&mutex);
   g_cond_init (&cond);
@@ -456,6 +459,9 @@ run_output_order_test (gint n_linked)
 
     gst_pad_set_active (inputpads[i], TRUE);
 
+    gst_pad_push_event (inputpads[i], gst_event_new_stream_start ("test"));
+    gst_pad_push_event (inputpads[i], gst_event_new_segment (&segment));
+
     mq_srcpad = mq_sinkpad_to_srcpad (mq, mq_sinkpad);
 
     name = g_strdup_printf ("dummysink%d", i);
@@ -596,6 +602,8 @@ GST_START_TEST (test_sparse_stream)
       "extra-size-bytes", (guint) 0,
       "extra-size-buffers", (guint) 0, "extra-size-time", (guint64) 0, NULL);
 
+  gst_segment_init (&segment, GST_FORMAT_TIME);
+
   /* Construct 2 dummy output pads. */
   for (i = 0; i < 2; i++) {
     GstPad *mq_srcpad, *mq_sinkpad;
@@ -612,6 +620,9 @@ GST_START_TEST (test_sparse_stream)
 
     gst_pad_set_active (inputpads[i], TRUE);
 
+    gst_pad_push_event (inputpads[i], gst_event_new_stream_start ("test"));
+    gst_pad_push_event (inputpads[i], gst_event_new_segment (&segment));
+
     mq_srcpad = mq_sinkpad_to_srcpad (mq, mq_sinkpad);
 
     name = g_strdup_printf ("dummysink%d", i);
@@ -644,12 +655,6 @@ GST_START_TEST (test_sparse_stream)
 
   gst_element_set_state (pipe, GST_STATE_PLAYING);
 
-  /* Push 2 new segment events */
-  gst_segment_init (&segment, GST_FORMAT_TIME);
-  event = gst_event_new_segment (&segment);
-  gst_pad_push_event (inputpads[0], gst_event_ref (event));
-  gst_pad_push_event (inputpads[1], event);
-
   for (i = 0; i < NBUFFERS; i++) {
     GstBuffer *buf;
     GstFlowReturn ret;

diff --git a/tests/check/elements/queue.c b/tests/check/elements/queue.c
index 2da3fd0..9a2ebcf 100644 (file)
--- a/tests/check/elements/queue.c
+++ b/tests/check/elements/queue.c
@@ -223,6 +223,7 @@ GST_START_TEST (test_non_leaky_overrun)
   GstBuffer *buffer2;
   GstBuffer *buffer3;
   GstBuffer *buffer;
+  GstSegment segment;
 
   g_signal_connect (queue, "overrun",
       G_CALLBACK (queue_overrun_link_and_activate), NULL);
@@ -239,7 +240,9 @@ GST_START_TEST (test_non_leaky_overrun)
   UNDERRUN_WAIT ();
   UNDERRUN_UNLOCK ();
 
+  gst_segment_init (&segment, GST_FORMAT_BYTES);
   gst_pad_push_event (mysrcpad, gst_event_new_stream_start ("test"));
+  gst_pad_push_event (mysrcpad, gst_event_new_segment (&segment));
 
   fail_unless (underrun_count == 1);
   fail_unless (overrun_count == 0);
@@ -316,6 +319,7 @@ GST_START_TEST (test_leaky_upstream)
   GstBuffer *buffer2;
   GstBuffer *buffer3;
   GstBuffer *buffer;
+  GstSegment segment;
 
   g_signal_connect (queue, "overrun", G_CALLBACK (queue_overrun), NULL);
   g_object_set (G_OBJECT (queue), "max-size-buffers", 2, "leaky", 1, NULL);
@@ -331,7 +335,9 @@ GST_START_TEST (test_leaky_upstream)
   UNDERRUN_WAIT ();
   UNDERRUN_UNLOCK ();
 
+  gst_segment_init (&segment, GST_FORMAT_BYTES);
   gst_pad_push_event (mysrcpad, gst_event_new_stream_start ("test"));
+  gst_pad_push_event (mysrcpad, gst_event_new_segment (&segment));
 
   fail_unless (overrun_count == 0);
   fail_unless (underrun_count == 1);
@@ -402,6 +408,7 @@ GST_START_TEST (test_leaky_downstream)
   GstBuffer *buffer2;
   GstBuffer *buffer3;
   GstBuffer *buffer;
+  GstSegment segment;
 
   g_signal_connect (queue, "overrun", G_CALLBACK (queue_overrun), NULL);
   g_object_set (G_OBJECT (queue), "max-size-buffers", 2, "leaky", 2, NULL);
@@ -417,7 +424,9 @@ GST_START_TEST (test_leaky_downstream)
   UNDERRUN_WAIT ();
   UNDERRUN_UNLOCK ();
 
+  gst_segment_init (&segment, GST_FORMAT_BYTES);
   gst_pad_push_event (mysrcpad, gst_event_new_stream_start ("test"));
+  gst_pad_push_event (mysrcpad, gst_event_new_segment (&segment));
 
   fail_unless (overrun_count == 0);
   fail_unless (underrun_count == 1);
@@ -483,6 +492,7 @@ GST_START_TEST (test_time_level)
 {
   GstBuffer *buffer = NULL;
   GstClockTime time;
+  GstSegment segment;
 
   g_signal_connect (queue, "overrun",
       G_CALLBACK (queue_overrun_link_and_activate), NULL);
@@ -500,7 +510,9 @@ GST_START_TEST (test_time_level)
   UNDERRUN_WAIT ();
   UNDERRUN_UNLOCK ();
 
+  gst_segment_init (&segment, GST_FORMAT_BYTES);
   gst_pad_push_event (mysrcpad, gst_event_new_stream_start ("test"));
+  gst_pad_push_event (mysrcpad, gst_event_new_segment (&segment));
 
   /* push buffer without duration */
   buffer = gst_buffer_new_and_alloc (4);

diff --git a/tests/check/elements/queue2.c b/tests/check/elements/queue2.c
index 82a6cc6..18170c1 100644 (file)
--- a/tests/check/elements/queue2.c
+++ b/tests/check/elements/queue2.c
@@ -225,6 +225,7 @@ GST_START_TEST (test_filled_read)
   GstBuffer *buffer;
   GstPad *sinkpad, *srcpad;
   GThread *thread;
+  GstSegment segment;
 
   queue2 = gst_element_factory_make ("queue2", NULL);
   sinkpad = gst_element_get_static_pad (queue2, "sink");
@@ -238,6 +239,10 @@ GST_START_TEST (test_filled_read)
   gst_pad_activate_mode (srcpad, GST_PAD_MODE_PULL, TRUE);
   gst_element_set_state (queue2, GST_STATE_PLAYING);
 
+  gst_segment_init (&segment, GST_FORMAT_BYTES);
+  gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
+  gst_pad_send_event (sinkpad, gst_event_new_segment (&segment));
+
   /* fill up the buffer */
   buffer = gst_buffer_new_and_alloc (4 * 1024);
   fail_unless (gst_pad_chain (sinkpad, buffer) == GST_FLOW_OK);

diff --git a/tests/check/elements/selector.c b/tests/check/elements/selector.c
index ca8d2c1..34179e5 100644 (file)
--- a/tests/check/elements/selector.c
+++ b/tests/check/elements/selector.c
@@ -56,8 +56,8 @@ probe_cb (GstPad * pad, GstPadProbeInfo * info, gpointer user_data)
   count++;
   g_object_set_data (G_OBJECT (pad), count_type, GINT_TO_POINTER (count));
 
-  /* drop everything */
-  return GST_PAD_PROBE_DROP;
+  /* drop every buffer */
+  return GST_IS_BUFFER (obj) ? GST_PAD_PROBE_DROP : GST_PAD_PROBE_PASS;
 }
 
 /* Create and link output pad: selector:src%d ! output_pad */
@@ -217,6 +217,7 @@ push_newsegment_events (GList * input_pads)
   for (l = input_pads; l; l = l->next) {
     GstPad *pad = l->data;
 
+    gst_pad_push_event (pad, gst_event_new_stream_start ("test"));
     gst_pad_push_event (pad, gst_event_new_segment (&seg));
   }
 }
@@ -227,12 +228,10 @@ push_switched_buffers (GList * input_pads,
     GstElement * elem, GList * peer_pads, gint num_buffers)
 {
   GstBuffer *buf = NULL;
-  GstCaps *caps = NULL;
   GList *l = peer_pads;
   GstPad *selpad = NULL;
 
   /* setup dummy buffer */
-  caps = gst_caps_from_string ("application/x-unknown");
   buf = gst_buffer_new_and_alloc (1);
 
   while (l != NULL) {
@@ -250,7 +249,6 @@ push_switched_buffers (GList * input_pads,
 
   /* cleanup buffer */
   gst_buffer_unref (buf);
-  gst_caps_unref (caps);
 }
 
 /* Create output-selector with given number of src pads and switch

diff --git a/tests/check/elements/tee.c b/tests/check/elements/tee.c
index 54463c0..b212eaf 100644 (file)
--- a/tests/check/elements/tee.c
+++ b/tests/check/elements/tee.c
@@ -460,6 +460,7 @@ GST_START_TEST (test_flow_aggregation)
   GstPad *teesink, *teesrc1, *teesrc2;
   GstElement *tee;
   GstBuffer *buffer;
+  GstSegment segment;
   GstCaps *caps;
 
   caps = gst_caps_new_empty_simple ("test/test");
@@ -477,19 +478,20 @@ GST_START_TEST (test_flow_aggregation)
   mysink1 = gst_pad_new ("mysink1", GST_PAD_SINK);
   gst_pad_set_chain_function (mysink1, _fake_chain);
   gst_pad_set_active (mysink1, TRUE);
-  gst_pad_set_caps (mysink1, caps);
 
   GST_DEBUG ("Creating mysink2");
   mysink2 = gst_pad_new ("mysink2", GST_PAD_SINK);
   gst_pad_set_chain_function (mysink2, _fake_chain);
   gst_pad_set_active (mysink2, TRUE);
-  gst_pad_set_caps (mysink2, caps);
 
   GST_DEBUG ("Creating mysrc");
   mysrc = gst_pad_new ("mysrc", GST_PAD_SRC);
   gst_pad_set_active (mysrc, TRUE);
-  gst_pad_set_caps (mysrc, caps);
 
+  gst_segment_init (&segment, GST_FORMAT_BYTES);
+  gst_pad_push_event (mysrc, gst_event_new_stream_start ("test"));
+  gst_pad_set_caps (mysrc, caps);
+  gst_pad_push_event (mysrc, gst_event_new_segment (&segment));
 
   fail_unless (gst_pad_link (mysrc, teesink) == GST_PAD_LINK_OK);
   fail_unless (gst_pad_link (teesrc1, mysink1) == GST_PAD_LINK_OK);
@@ -516,7 +518,6 @@ GST_START_TEST (test_flow_aggregation)
   GST_DEBUG ("Trying to push with mysink2 disabled");
   gst_pad_set_active (mysink1, FALSE);
   gst_pad_set_active (mysink2, TRUE);
-  gst_pad_set_caps (mysink2, caps);
   fail_unless (gst_pad_push (mysrc,
           gst_buffer_ref (buffer)) == GST_FLOW_FLUSHING);
 
@@ -528,9 +529,7 @@ GST_START_TEST (test_flow_aggregation)
   /* Test if everything still works in normal state */
   GST_DEBUG ("Reactivate both pads and try pushing");
   gst_pad_set_active (mysink1, TRUE);
-  gst_pad_set_caps (mysink1, caps);
   gst_pad_set_active (mysink2, TRUE);
-  gst_pad_set_caps (mysink2, caps);
   fail_unless (gst_pad_push (mysrc, gst_buffer_ref (buffer)) == GST_FLOW_OK);
 
   /* One unlinked pad must return OK, two unlinked pads must return NOT_LINKED */

diff --git a/tests/check/generic/sinks.c b/tests/check/generic/sinks.c
index d5ca701..372ed9e 100644 (file)
--- a/tests/check/generic/sinks.c
+++ b/tests/check/generic/sinks.c
@@ -919,6 +919,7 @@ GST_START_TEST (test_fake_eos)
   GstPad *sinkpad;
   GstFlowReturn res;
   GThread *thread;
+  GstSegment segment;
 
   pipeline = gst_pipeline_new ("pipeline");
 
@@ -932,6 +933,10 @@ GST_START_TEST (test_fake_eos)
   ret = gst_element_set_state (pipeline, GST_STATE_PLAYING);
   fail_unless (ret == GST_STATE_CHANGE_ASYNC, "no ASYNC state return");
 
+  gst_segment_init (&segment, GST_FORMAT_BYTES);
+  gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
+  gst_pad_send_event (sinkpad, gst_event_new_segment (&segment));
+
   /* push buffer of 100 seconds, since it has a timestamp of 0, it should be
    * rendered immediately and the chain function should return immediately */
   buffer = gst_buffer_new_and_alloc (10);
@@ -1073,6 +1078,8 @@ GST_START_TEST (test_async_done)
   gst_bus_set_sync_handler (bus, (GstBusSyncHandler) async_done_func, sink,
       NULL);
 
+  gst_pad_send_event (sinkpad, gst_event_new_stream_start ("test"));
+
   /* make newsegment, this sets the position to 10sec when the buffer prerolls */
   GST_DEBUG ("sending segment");
   gst_segment_init (&segment, GST_FORMAT_TIME);

diff --git a/tests/check/gst/gstghostpad.c b/tests/check/gst/gstghostpad.c
index a8aa923..c274e6d 100644 (file)
--- a/tests/check/gst/gstghostpad.c
+++ b/tests/check/gst/gstghostpad.c
@@ -1130,6 +1130,7 @@ GST_START_TEST (test_ghost_pads_remove_while_playing)
 {
   GstPad *sinkpad;
   GstPad *srcpad;
+  GstSegment segment;
 
   bin = gst_bin_new (NULL);
   gst_element_set_state (bin, GST_STATE_PLAYING);
@@ -1147,6 +1148,12 @@ GST_START_TEST (test_ghost_pads_remove_while_playing)
   gst_pad_set_active (srcpad, TRUE);
   gst_pad_link (srcpad, ghostsink);
 
+  gst_segment_init (&segment, GST_FORMAT_BYTES);
+  fail_unless (gst_pad_push_event (srcpad,
+          gst_event_new_stream_start ("test")) == TRUE);
+  fail_unless (gst_pad_push_event (srcpad,
+          gst_event_new_segment (&segment)) == TRUE);
+
   gst_pad_add_probe (ghostsrc, GST_PAD_PROBE_TYPE_BUFFER,
       remove_ghostpad_probe_cb, NULL, NULL);
 

diff --git a/tests/check/gst/gstpad.c b/tests/check/gst/gstpad.c
index f567b91..e55ffbc 100644 (file)
--- a/tests/check/gst/gstpad.c
+++ b/tests/check/gst/gstpad.c
@@ -21,6 +21,8 @@
 
 #include <gst/check/gstcheck.h>
 
+static GstSegment dummy_segment;
+
 GST_START_TEST (test_link)
 {
   GstPad *src, *sink;
@@ -226,7 +228,12 @@ sticky_event (GstPad * pad, GstObject * parent, GstEvent * event)
 {
   GstCaps *caps;
 
-  fail_unless (GST_EVENT_TYPE (event) == GST_EVENT_CAPS);
+  fail_unless (GST_EVENT_TYPE (event) == GST_EVENT_CAPS
+      || GST_EVENT_TYPE (event) == GST_EVENT_STREAM_START
+      || GST_EVENT_TYPE (event) == GST_EVENT_SEGMENT);
+
+  if (GST_EVENT_TYPE (event) != GST_EVENT_CAPS)
+    return TRUE;
 
   /* Ensure we get here just once: */
   fail_unless (event_caps == NULL);
@@ -268,14 +275,21 @@ GST_START_TEST (test_sticky_caps_unlinked)
   gst_object_unref (src_template);
   gst_object_unref (sink_template);
 
+  gst_pad_set_active (src, TRUE);
+
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_stream_start ("test")) == TRUE);
+
   caps = gst_caps_from_string ("foo/bar, dummy=(int)1");
   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
 
   event = gst_event_new_caps (caps);
-  gst_pad_set_active (src, TRUE);
   fail_unless (gst_pad_push_event (src, event) == TRUE);
   fail_unless (event_caps == NULL);
 
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
+
   /* Linking and activating will not forward the sticky event yet... */
   fail_unless (GST_PAD_LINK_SUCCESSFUL (gst_pad_link (src, sink)));
   gst_pad_set_active (sink, TRUE);
@@ -332,17 +346,24 @@ GST_START_TEST (test_sticky_caps_unlinked_incompatible)
   gst_object_unref (src_template);
   gst_object_unref (sink_template);
 
+  gst_pad_set_active (src, TRUE);
+
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_stream_start ("test")) == TRUE);
+
   failcaps = gst_caps_from_string ("pony/express, failure=(boolean)true");
   ASSERT_CAPS_REFCOUNT (failcaps, "caps", 1);
 
   event = gst_event_new_caps (failcaps);
   gst_caps_unref (failcaps);
-  gst_pad_set_active (src, TRUE);
   /* The pad isn't linked yet, and anything matches the source pad template
    * (which is ANY) */
   fail_unless (gst_pad_push_event (src, event) == TRUE);
   fail_unless (event_caps == NULL);
 
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
+
   /* Linking and activating will not forward the sticky event yet... */
   fail_unless (GST_PAD_LINK_SUCCESSFUL (gst_pad_link (src, sink)));
   gst_pad_set_active (sink, TRUE);
@@ -401,12 +422,18 @@ GST_START_TEST (test_sticky_caps_flushing)
   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
 
   event = gst_event_new_caps (caps);
+
   gst_pad_set_active (src, TRUE);
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_stream_start ("test")) == TRUE);
   /* The caps event gets accepted by the source pad (and stored) */
   fail_unless (gst_pad_push_event (src, event) == TRUE);
   /* But wasn't forwarded since the sink pad is flushing (not activated) */
   fail_unless (event_caps == NULL);
 
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
+
   /* Activating will not forward the sticky event yet... */
   gst_pad_set_active (sink, TRUE);
   fail_unless (event_caps == NULL);
@@ -499,9 +526,13 @@ GST_START_TEST (test_push_unlinked)
   gst_buffer_unref (buffer);
 
   gst_pad_set_active (src, TRUE);
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_stream_start ("test")) == TRUE);
   GST_DEBUG ("push caps event inactive");
   gst_pad_set_caps (src, caps);
   ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
 
   /* pushing on an unlinked pad will drop the buffer */
   GST_DEBUG ("push buffer unlinked");
@@ -569,15 +600,22 @@ GST_START_TEST (test_push_linked)
   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
 
   gst_pad_set_active (src, TRUE);
+
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_stream_start ("test")) == TRUE);
+
   gst_pad_set_caps (src, caps);
+
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
+
   gst_pad_set_active (sink, TRUE);
-  gst_pad_set_caps (sink, caps);
   /* one for me and one for each set_caps */
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
 
   plr = gst_pad_link (src, sink);
   fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
 
   buffer = gst_buffer_new ();
 
@@ -660,16 +698,19 @@ GST_START_TEST (test_push_linked_flushing)
   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
 
   gst_pad_set_active (src, TRUE);
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_stream_start ("test")) == TRUE);
   gst_pad_set_caps (src, caps);
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
   /* need to activate to make it accept the caps */
   gst_pad_set_active (sink, TRUE);
-  gst_pad_set_caps (sink, caps);
   /* one for me and one for each set_caps */
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
 
   plr = gst_pad_link (src, sink);
   fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
 
   /* not activating the pads here, which keeps them flushing */
   gst_pad_set_active (src, FALSE);
@@ -686,13 +727,18 @@ GST_START_TEST (test_push_linked_flushing)
   gst_pad_set_active (src, TRUE);
   gst_pad_set_active (sink, FALSE);
 
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_stream_start ("test")) == TRUE);
+  gst_pad_set_caps (src, caps);
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
   /* adding a probe that returns FALSE will drop the buffer without trying
    * to chain */
   id = gst_pad_add_probe (src, GST_PAD_PROBE_TYPE_BUFFER, _probe_handler,
       GINT_TO_POINTER (0), NULL);
   buffer = gst_buffer_new ();
   gst_buffer_ref (buffer);
-  fail_unless (gst_pad_push (src, buffer) == GST_FLOW_OK);
+  fail_unless (gst_pad_push (src, buffer) == GST_FLOW_FLUSHING);
   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
   fail_unless_equals_int (g_list_length (buffers), 0);
   gst_buffer_unref (buffer);
@@ -711,7 +757,7 @@ GST_START_TEST (test_push_linked_flushing)
   gst_pad_remove_probe (src, id);
 
   /* cleanup */
-  ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
+  ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
   ASSERT_OBJECT_REFCOUNT (src, "src", 1);
   gst_pad_link (src, sink);
   gst_object_unref (src);
@@ -770,9 +816,16 @@ GST_START_TEST (test_push_buffer_list_compat)
   caps = gst_caps_from_string ("foo/bar");
 
   gst_pad_set_active (src, TRUE);
+
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_stream_start ("test")) == TRUE);
+
   gst_pad_set_caps (src, caps);
+
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
+
   gst_pad_set_active (sink, TRUE);
-  gst_pad_set_caps (sink, caps);
 
   plr = gst_pad_link (src, sink);
   fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
@@ -1005,6 +1058,12 @@ GST_START_TEST (test_block_async)
   fail_unless (pad != NULL);
 
   gst_pad_set_active (pad, TRUE);
+
+  fail_unless (gst_pad_push_event (pad,
+          gst_event_new_stream_start ("test")) == TRUE);
+  fail_unless (gst_pad_push_event (pad,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
+
   id = gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_BLOCK, block_async_cb, &data,
       NULL);
 
@@ -1041,6 +1100,12 @@ test_pad_blocking_with_type (GstPadProbeType type)
   fail_unless (pad != NULL);
 
   gst_pad_set_active (pad, TRUE);
+
+  fail_unless (gst_pad_push_event (pad,
+          gst_event_new_stream_start ("test")) == TRUE);
+  fail_unless (gst_pad_push_event (pad,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
+
   id = gst_pad_add_probe (pad, type, block_async_cb_return_ok, NULL, NULL);
 
 
@@ -1170,6 +1235,12 @@ GST_START_TEST (test_pad_probe_flush_events)
   gst_pad_set_chain_function (sink, gst_check_chain_func);
   gst_pad_set_active (src, TRUE);
   gst_pad_set_active (sink, TRUE);
+
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_stream_start ("test")) == TRUE);
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
+
   fail_unless (gst_pad_link (src, sink) == GST_PAD_LINK_OK);
 
   gst_pad_add_probe (src,
@@ -1182,6 +1253,9 @@ GST_START_TEST (test_pad_probe_flush_events)
   gst_pad_push_event (src, gst_event_new_flush_start ());
   gst_pad_push_event (src, gst_event_new_flush_stop (TRUE));
 
+  fail_unless (gst_pad_push_event (src,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
+
   /* push a buffer so the events are propagated downstream */
   gst_pad_push (src, gst_buffer_new ());
 
@@ -1356,6 +1430,11 @@ GST_START_TEST (test_block_async_full_destroy)
   fail_unless (pad != NULL);
   gst_pad_set_active (pad, TRUE);
 
+  fail_unless (gst_pad_push_event (pad,
+          gst_event_new_stream_start ("test")) == TRUE);
+  fail_unless (gst_pad_push_event (pad,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
+
   id = gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_BLOCK, block_async_full_cb,
       &state, block_async_full_destroy);
   fail_unless (state == 0);
@@ -1385,6 +1464,11 @@ GST_START_TEST (test_block_async_full_destroy_dispose)
   fail_unless (pad != NULL);
   gst_pad_set_active (pad, TRUE);
 
+  fail_unless (gst_pad_push_event (pad,
+          gst_event_new_stream_start ("test")) == TRUE);
+  fail_unless (gst_pad_push_event (pad,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
+
   (void) gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_BLOCK, block_async_full_cb,
       &state, block_async_full_destroy);
 
@@ -1495,6 +1579,11 @@ GST_START_TEST (test_block_async_replace_callback_no_flush)
   fail_unless (pad != NULL);
   gst_pad_set_active (pad, TRUE);
 
+  fail_unless (gst_pad_push_event (pad,
+          gst_event_new_stream_start ("test")) == TRUE);
+  fail_unless (gst_pad_push_event (pad,
+          gst_event_new_segment (&dummy_segment)) == TRUE);
+
   GST_DEBUG ("adding probe");
   id = gst_pad_add_probe (pad, GST_PAD_PROBE_TYPE_BLOCK,
       block_async_first_no_flush, bool_user_data, NULL);
@@ -1550,6 +1639,13 @@ test_sticky_events_handler (GstPad * pad, GstObject * parent, GstEvent * event)
   return TRUE;
 }
 
+static GstFlowReturn
+test_sticky_chain (GstPad * pad, GstObject * parent, GstBuffer * buffer)
+{
+  gst_buffer_unref (buffer);
+  return GST_FLOW_OK;
+}
+
 GST_START_TEST (test_sticky_events)
 {
   GstPad *srcpad, *sinkpad;
@@ -1566,7 +1662,8 @@ GST_START_TEST (test_sticky_events)
   fail_unless (gst_pad_get_stream_id (srcpad) == NULL);
 
   /* push an event, it should be sticky on the srcpad */
-  gst_pad_push_event (srcpad, gst_event_new_stream_start ("test"));
+  fail_unless (gst_pad_push_event (srcpad,
+          gst_event_new_stream_start ("test")) == TRUE);
 
   /* let's see if it stuck */
   id = gst_pad_get_stream_id (srcpad);
@@ -1587,6 +1684,7 @@ GST_START_TEST (test_sticky_events)
   fail_unless (sinkpad != NULL);
   sticky_count = 0;
   gst_pad_set_event_function (sinkpad, test_sticky_events_handler);
+  gst_pad_set_chain_function (sinkpad, test_sticky_chain);
   fail_unless (sticky_count == 0);
   gst_pad_set_active (sinkpad, TRUE);
 
@@ -1601,8 +1699,13 @@ GST_START_TEST (test_sticky_events)
   gst_pad_push_event (srcpad, gst_event_new_caps (caps));
   gst_caps_unref (caps);
 
-  /* should have triggered 2 events */
-  fail_unless (sticky_count == 3);
+  /* should have triggered 2 events, the segment event is still pending */
+  fail_unless_equals_int (sticky_count, 2);
+
+  fail_unless (gst_pad_push (srcpad, gst_buffer_new ()) == GST_FLOW_OK);
+
+  /* should have triggered 3 events */
+  fail_unless_equals_int (sticky_count, 3);
 
   gst_object_unref (srcpad);
   gst_object_unref (sinkpad);
@@ -1619,6 +1722,8 @@ gst_pad_suite (void)
   /* turn off timeout */
   tcase_set_timeout (tc_chain, 60);
 
+  gst_segment_init (&dummy_segment, GST_FORMAT_BYTES);
+
   suite_add_tcase (s, tc_chain);
   tcase_add_test (tc_chain, test_link);
   tcase_add_test (tc_chain, test_refcount);

diff --git a/tests/check/libs/collectpads.c b/tests/check/libs/collectpads.c
index 3eb62ab..97d2e65 100644 (file)
--- a/tests/check/libs/collectpads.c
+++ b/tests/check/libs/collectpads.c
@@ -45,6 +45,7 @@ struct _GstAggregator
   GstPad *srcpad;
   GstPad *sinkpad[2];
   gint padcount;
+  gboolean first;
 };
 struct _GstAggregatorClass
 {
@@ -79,6 +80,16 @@ gst_agregator_collected (GstCollectPads * pads, gpointer user_data)
   if (!inbuf)
     goto eos;
 
+  if (aggregator->first) {
+    GstSegment segment;
+
+    gst_segment_init (&segment, GST_FORMAT_BYTES);
+    gst_pad_push_event (aggregator->srcpad,
+        gst_event_new_stream_start ("test"));
+    gst_pad_push_event (aggregator->srcpad, gst_event_new_segment (&segment));
+    aggregator->first = FALSE;
+  }
+
   /* just forward the first buffer */
   GST_DEBUG_OBJECT (aggregator, "forward buffer %p", inbuf);
   return gst_pad_push (aggregator->srcpad, inbuf);
@@ -226,6 +237,8 @@ gst_aggregator_init (GstAggregator * agregator)
   agregator->collect = gst_collect_pads_new ();
   gst_collect_pads_set_function (agregator->collect,
       GST_DEBUG_FUNCPTR (gst_agregator_collected), agregator);
+
+  agregator->first = TRUE;
 }
 
 static gboolean
@@ -326,6 +339,7 @@ push_buffer (gpointer user_data)
   GstFlowReturn flow;
   GstCaps *caps;
   TestData *test_data = (TestData *) user_data;
+  GstSegment segment;
 
   gst_pad_push_event (test_data->pad, gst_event_new_stream_start ("test"));
 
@@ -333,6 +347,9 @@ push_buffer (gpointer user_data)
   gst_pad_push_event (test_data->pad, gst_event_new_caps (caps));
   gst_caps_unref (caps);
 
+  gst_segment_init (&segment, GST_FORMAT_TIME);
+  gst_pad_push_event (test_data->pad, gst_event_new_segment (&segment));
+
   flow = gst_pad_push (test_data->pad, test_data->buffer);
   fail_unless (flow == GST_FLOW_OK, "got flow %s instead of OK",
       gst_flow_get_name (flow));