Merge branch 'master' into 0.11
[platform/upstream/gstreamer.git] / tests / check / gst / gstpad.c
1 /* GStreamer
2  * Copyright (C) <2005> Thomas Vander Stichele <thomas at apestaart dot org>
3  *
4  * gstpad.c: Unit test for GstPad
5  *
6  * This library is free software; you can redistribute it and/or
7  * modify it under the terms of the GNU Library General Public
8  * License as published by the Free Software Foundation; either
9  * version 2 of the License, or (at your option) any later version.
10  *
11  * This library is distributed in the hope that it will be useful,
12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
14  * Library General Public License for more details.
15  *
16  * You should have received a copy of the GNU Library General Public
17  * License along with this library; if not, write to the
18  * Free Software Foundation, Inc., 59 Temple Place - Suite 330,
19  * Boston, MA 02111-1307, USA.
20  */
21
22 #include <gst/check/gstcheck.h>
23
24 GST_START_TEST (test_link)
25 {
26   GstPad *src, *sink;
27   GstPadTemplate *srct;
28
29   GstPadLinkReturn ret;
30   gchar *name;
31
32   src = gst_pad_new ("source", GST_PAD_SRC);
33   fail_if (src == NULL);
34   ASSERT_OBJECT_REFCOUNT (src, "source pad", 1);
35
36   name = gst_pad_get_name (src);
37   fail_unless (strcmp (name, "source") == 0);
38   ASSERT_OBJECT_REFCOUNT (src, "source pad", 1);
39   g_free (name);
40
41   sink = gst_pad_new ("sink", GST_PAD_SINK);
42   fail_if (sink == NULL);
43
44   /* linking without templates or caps should fail */
45   ret = gst_pad_link (src, sink);
46   ASSERT_OBJECT_REFCOUNT (src, "source pad", 1);
47   ASSERT_OBJECT_REFCOUNT (sink, "sink pad", 1);
48   fail_unless (ret == GST_PAD_LINK_NOFORMAT);
49
50   ASSERT_CRITICAL (gst_pad_get_pad_template (NULL));
51
52   srct = gst_pad_get_pad_template (src);
53   fail_unless (srct == NULL);
54   ASSERT_OBJECT_REFCOUNT (src, "source pad", 1);
55
56   /* clean up */
57   ASSERT_OBJECT_REFCOUNT (src, "source pad", 1);
58   gst_object_unref (src);
59   gst_object_unref (sink);
60 }
61
62 GST_END_TEST;
63
64 /* threaded link/unlink */
65 /* use globals */
66 static GstPad *src, *sink;
67
68 static void
69 thread_link_unlink (gpointer data)
70 {
71   THREAD_START ();
72
73   while (THREAD_TEST_RUNNING ()) {
74     gst_pad_link (src, sink);
75     gst_pad_unlink (src, sink);
76     THREAD_SWITCH ();
77   }
78 }
79
80 GST_START_TEST (test_link_unlink_threaded)
81 {
82   GstCaps *caps;
83   int i;
84
85   src = gst_pad_new ("source", GST_PAD_SRC);
86   fail_if (src == NULL);
87   sink = gst_pad_new ("sink", GST_PAD_SINK);
88   fail_if (sink == NULL);
89
90   caps = gst_caps_from_string ("foo/bar");
91   gst_pad_set_caps (src, caps);
92   gst_pad_set_caps (sink, caps);
93   ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
94
95   MAIN_START_THREADS (5, thread_link_unlink, NULL);
96   for (i = 0; i < 1000; ++i) {
97     gst_pad_is_linked (src);
98     gst_pad_is_linked (sink);
99     THREAD_SWITCH ();
100   }
101   MAIN_STOP_THREADS ();
102
103   ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
104   gst_caps_unref (caps);
105
106   ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
107   gst_object_unref (src);
108   gst_object_unref (sink);
109 }
110
111 GST_END_TEST;
112
113 GST_START_TEST (test_refcount)
114 {
115   GstPad *src, *sink;
116   GstCaps *caps;
117   GstPadLinkReturn plr;
118
119   sink = gst_pad_new ("sink", GST_PAD_SINK);
120   fail_if (sink == NULL);
121
122   src = gst_pad_new ("src", GST_PAD_SRC);
123   fail_if (src == NULL);
124
125   caps = gst_caps_from_string ("foo/bar");
126   /* one for me */
127   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
128
129   gst_pad_set_caps (src, caps);
130   gst_pad_set_caps (sink, caps);
131   /* one for me and one for each set_caps */
132   ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
133
134   plr = gst_pad_link (src, sink);
135   fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
136   ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
137
138   gst_pad_unlink (src, sink);
139   ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
140
141   /* cleanup */
142   gst_object_unref (src);
143   gst_object_unref (sink);
144   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
145
146   gst_caps_unref (caps);
147 }
148
149 GST_END_TEST;
150
151 GST_START_TEST (test_get_allowed_caps)
152 {
153   GstPad *src, *sink;
154   GstCaps *caps, *gotcaps;
155   GstBuffer *buffer;
156   GstPadLinkReturn plr;
157
158   ASSERT_CRITICAL (gst_pad_get_allowed_caps (NULL));
159
160   buffer = gst_buffer_new ();
161   ASSERT_CRITICAL (gst_pad_get_allowed_caps ((GstPad *) buffer));
162   gst_buffer_unref (buffer);
163
164   src = gst_pad_new ("src", GST_PAD_SRC);
165   fail_if (src == NULL);
166   caps = gst_pad_get_allowed_caps (src);
167   fail_unless (caps == NULL);
168
169   caps = gst_caps_from_string ("foo/bar");
170
171   sink = gst_pad_new ("sink", GST_PAD_SINK);
172   gst_pad_set_caps (src, caps);
173   gst_pad_set_caps (sink, caps);
174   ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
175
176   plr = gst_pad_link (src, sink);
177   fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
178
179   gotcaps = gst_pad_get_allowed_caps (src);
180   fail_if (gotcaps == NULL);
181   fail_unless (gst_caps_is_equal (gotcaps, caps));
182
183   ASSERT_CAPS_REFCOUNT (gotcaps, "gotcaps", 1);
184   gst_caps_unref (gotcaps);
185
186   gst_pad_unlink (src, sink);
187
188   /* cleanup */
189   ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
190   ASSERT_OBJECT_REFCOUNT (src, "src", 1);
191   ASSERT_OBJECT_REFCOUNT (sink, "sink", 1);
192
193   gst_object_unref (src);
194   gst_object_unref (sink);
195
196   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
197   gst_caps_unref (caps);
198 }
199
200 GST_END_TEST;
201
202 static gboolean
203 name_is_valid (const gchar * name, GstPadPresence presence)
204 {
205   GstPadTemplate *new;
206   GstCaps *any = GST_CAPS_ANY;
207
208   new = gst_pad_template_new (name, GST_PAD_SRC, presence, any);
209   if (new) {
210     gst_object_unref (GST_OBJECT (new));
211     return TRUE;
212   }
213   return FALSE;
214 }
215
216 GST_START_TEST (test_name_is_valid)
217 {
218   gboolean result = FALSE;
219
220   fail_unless (name_is_valid ("src", GST_PAD_ALWAYS));
221   ASSERT_WARNING (name_is_valid ("src%", GST_PAD_ALWAYS));
222   ASSERT_WARNING (result = name_is_valid ("src%d", GST_PAD_ALWAYS));
223   fail_if (result);
224
225   fail_unless (name_is_valid ("src", GST_PAD_REQUEST));
226   ASSERT_WARNING (name_is_valid ("src%s%s", GST_PAD_REQUEST));
227   ASSERT_WARNING (name_is_valid ("src%c", GST_PAD_REQUEST));
228   ASSERT_WARNING (name_is_valid ("src%", GST_PAD_REQUEST));
229   ASSERT_WARNING (name_is_valid ("src%dsrc", GST_PAD_REQUEST));
230
231   fail_unless (name_is_valid ("src", GST_PAD_SOMETIMES));
232   fail_unless (name_is_valid ("src%c", GST_PAD_SOMETIMES));
233 }
234
235 GST_END_TEST;
236
237 static gboolean
238 _probe_handler (GstPad * pad, GstBuffer * buffer, gpointer userdata)
239 {
240   gint ret = GPOINTER_TO_INT (userdata);
241
242   if (ret == 1)
243     return TRUE;
244   return FALSE;
245 }
246
247 GST_START_TEST (test_push_unlinked)
248 {
249   GstPad *src;
250   GstCaps *caps;
251   GstBuffer *buffer;
252   gulong id;
253
254   src = gst_pad_new ("src", GST_PAD_SRC);
255   fail_if (src == NULL);
256   caps = gst_pad_get_allowed_caps (src);
257   fail_unless (caps == NULL);
258
259   caps = gst_caps_from_string ("foo/bar");
260
261   gst_pad_set_caps (src, caps);
262   ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
263
264   /* pushing on an unlinked pad will drop the buffer */
265   buffer = gst_buffer_new ();
266   gst_buffer_ref (buffer);
267   fail_unless (gst_pad_push (src, buffer) == GST_FLOW_NOT_LINKED);
268   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
269   gst_buffer_unref (buffer);
270
271   /* adding a probe that returns FALSE will drop the buffer without trying
272    * to chain */
273   id = gst_pad_add_buffer_probe (src, (GCallback) _probe_handler,
274       GINT_TO_POINTER (0));
275   buffer = gst_buffer_new ();
276   gst_buffer_ref (buffer);
277   fail_unless (gst_pad_push (src, buffer) == GST_FLOW_OK);
278   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
279   gst_buffer_unref (buffer);
280   gst_pad_remove_buffer_probe (src, id);
281
282   /* adding a probe that returns TRUE will still chain the buffer,
283    * and hence drop because pad is unlinked */
284   id = gst_pad_add_buffer_probe (src, (GCallback) _probe_handler,
285       GINT_TO_POINTER (1));
286   buffer = gst_buffer_new ();
287   gst_buffer_ref (buffer);
288   fail_unless (gst_pad_push (src, buffer) == GST_FLOW_NOT_LINKED);
289   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
290   gst_buffer_unref (buffer);
291   gst_pad_remove_buffer_probe (src, id);
292
293
294   /* cleanup */
295   ASSERT_CAPS_REFCOUNT (caps, "caps", 2);
296   ASSERT_OBJECT_REFCOUNT (src, "src", 1);
297
298   gst_object_unref (src);
299
300   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
301   gst_caps_unref (caps);
302 }
303
304 GST_END_TEST;
305
306 GST_START_TEST (test_push_linked)
307 {
308   GstPad *src, *sink;
309   GstPadLinkReturn plr;
310   GstCaps *caps;
311   GstBuffer *buffer;
312   gulong id;
313
314   /* setup */
315   sink = gst_pad_new ("sink", GST_PAD_SINK);
316   fail_if (sink == NULL);
317   gst_pad_set_chain_function (sink, gst_check_chain_func);
318
319   src = gst_pad_new ("src", GST_PAD_SRC);
320   fail_if (src == NULL);
321
322   caps = gst_caps_from_string ("foo/bar");
323   /* one for me */
324   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
325
326   gst_pad_set_caps (src, caps);
327   gst_pad_set_caps (sink, caps);
328   /* one for me and one for each set_caps */
329   ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
330
331   plr = gst_pad_link (src, sink);
332   fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
333   ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
334
335   buffer = gst_buffer_new ();
336 #if 0
337   /* FIXME, new pad should be flushing */
338   gst_buffer_ref (buffer);
339   fail_unless (gst_pad_push (src, buffer) == GST_FLOW_WRONG_STATE);
340   gst_buffer_ref (buffer);
341   fail_unless (gst_pad_chain (sink, buffer) == GST_FLOW_WRONG_STATE);
342 #endif
343
344   /* activate pads */
345   gst_pad_set_active (src, TRUE);
346   gst_pad_set_active (sink, TRUE);
347
348   /* test */
349   /* pushing on a linked pad will drop the ref to the buffer */
350   gst_buffer_ref (buffer);
351   fail_unless (gst_pad_push (src, buffer) == GST_FLOW_OK);
352   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 2);
353   gst_buffer_unref (buffer);
354   fail_unless_equals_int (g_list_length (buffers), 1);
355   buffer = GST_BUFFER (buffers->data);
356   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
357   gst_buffer_unref (buffer);
358   g_list_free (buffers);
359   buffers = NULL;
360
361   /* adding a probe that returns FALSE will drop the buffer without trying
362    * to chain */
363   id = gst_pad_add_buffer_probe (src, (GCallback) _probe_handler,
364       GINT_TO_POINTER (0));
365   buffer = gst_buffer_new ();
366   gst_buffer_ref (buffer);
367   fail_unless (gst_pad_push (src, buffer) == GST_FLOW_OK);
368   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
369   gst_buffer_unref (buffer);
370   gst_pad_remove_buffer_probe (src, id);
371   fail_unless_equals_int (g_list_length (buffers), 0);
372
373   /* adding a probe that returns TRUE will still chain the buffer */
374   id = gst_pad_add_buffer_probe (src, (GCallback) _probe_handler,
375       GINT_TO_POINTER (1));
376   buffer = gst_buffer_new ();
377   gst_buffer_ref (buffer);
378   fail_unless (gst_pad_push (src, buffer) == GST_FLOW_OK);
379   gst_pad_remove_buffer_probe (src, id);
380
381   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 2);
382   gst_buffer_unref (buffer);
383   fail_unless_equals_int (g_list_length (buffers), 1);
384   buffer = GST_BUFFER (buffers->data);
385   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
386   gst_buffer_unref (buffer);
387   g_list_free (buffers);
388   buffers = NULL;
389
390   /* teardown */
391   gst_pad_unlink (src, sink);
392   ASSERT_CAPS_REFCOUNT (caps, "caps", 3);
393   gst_object_unref (src);
394   gst_object_unref (sink);
395   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
396
397   gst_caps_unref (caps);
398 }
399
400 GST_END_TEST;
401
402 static GstBuffer *
403 buffer_from_string (const gchar * str)
404 {
405   guint size;
406   GstBuffer *buf;
407   gpointer data;
408
409   size = strlen (str);
410   buf = gst_buffer_new_and_alloc (size);
411
412   data = gst_buffer_map (buf, NULL, NULL, GST_MAP_WRITE);
413   memcpy (data, str, size);
414   gst_buffer_unmap (buf, data, size);
415
416   return buf;
417 }
418
419 static gboolean
420 buffer_compare (GstBuffer * buf, const gchar * str, gsize size)
421 {
422   gboolean res;
423   gpointer data;
424
425   data = gst_buffer_map (buf, NULL, NULL, GST_MAP_READ);
426   res = memcmp (data, str, size) == 0;
427   GST_DEBUG ("%s <-> %s: %d", (gchar *) data, str, res);
428   gst_buffer_unmap (buf, data, size);
429
430   return res;
431 }
432
433 GST_START_TEST (test_push_buffer_list_compat)
434 {
435   GstPad *src, *sink;
436   GstPadLinkReturn plr;
437   GstCaps *caps;
438   GstBufferList *list;
439   GstBuffer *buffer;
440   guint len;
441
442   /* setup */
443   sink = gst_pad_new ("sink", GST_PAD_SINK);
444   fail_if (sink == NULL);
445   gst_pad_set_chain_function (sink, gst_check_chain_func);
446   /* leave chainlistfunc unset */
447
448   src = gst_pad_new ("src", GST_PAD_SRC);
449   fail_if (src == NULL);
450
451   caps = gst_caps_from_string ("foo/bar");
452
453   gst_pad_set_caps (src, caps);
454   gst_pad_set_caps (sink, caps);
455
456   plr = gst_pad_link (src, sink);
457   fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
458
459   list = gst_buffer_list_new ();
460
461   /* activate pads */
462   gst_pad_set_active (src, TRUE);
463   gst_pad_set_active (sink, TRUE);
464
465   /* test */
466   /* adding to a buffer list will drop the ref to the buffer */
467   len = gst_buffer_list_len (list);
468
469   gst_buffer_list_add (list, buffer_from_string ("ListGroup"));
470   gst_buffer_list_add (list, buffer_from_string ("AnotherListGroup"));
471
472   fail_unless (gst_pad_push_list (src, list) == GST_FLOW_OK);
473   fail_unless_equals_int (g_list_length (buffers), 2);
474   buffer = GST_BUFFER (buffers->data);
475   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
476   fail_unless (buffer_compare (buffer, "ListGroup", 9));
477   gst_buffer_unref (buffer);
478   buffers = g_list_delete_link (buffers, buffers);
479   buffer = GST_BUFFER (buffers->data);
480   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
481   fail_unless (buffer_compare (buffer, "AnotherListGroup", 16));
482   gst_buffer_unref (buffer);
483   buffers = g_list_delete_link (buffers, buffers);
484   fail_unless (buffers == NULL);
485
486   /* teardown */
487   gst_pad_unlink (src, sink);
488   gst_object_unref (src);
489   gst_object_unref (sink);
490   ASSERT_CAPS_REFCOUNT (caps, "caps", 1);
491   gst_caps_unref (caps);
492 }
493
494 GST_END_TEST;
495
496 GST_START_TEST (test_flowreturn)
497 {
498   GstFlowReturn ret;
499   GQuark quark;
500
501   /* test some of the macros */
502   ret = GST_FLOW_UNEXPECTED;
503   fail_if (strcmp (gst_flow_get_name (ret), "unexpected"));
504   quark = gst_flow_to_quark (ret);
505   fail_if (strcmp (g_quark_to_string (quark), "unexpected"));
506
507   ret = GST_FLOW_RESEND;
508   fail_if (strcmp (gst_flow_get_name (ret), "resend"));
509   quark = gst_flow_to_quark (ret);
510   fail_if (strcmp (g_quark_to_string (quark), "resend"));
511
512   /* custom returns */
513   ret = GST_FLOW_CUSTOM_SUCCESS;
514   fail_if (strcmp (gst_flow_get_name (ret), "custom-success"));
515   quark = gst_flow_to_quark (ret);
516   fail_if (strcmp (g_quark_to_string (quark), "custom-success"));
517
518   ret = GST_FLOW_CUSTOM_ERROR;
519   fail_if (strcmp (gst_flow_get_name (ret), "custom-error"));
520   quark = gst_flow_to_quark (ret);
521   fail_if (strcmp (g_quark_to_string (quark), "custom-error"));
522
523   /* custom returns clamping */
524   ret = GST_FLOW_CUSTOM_SUCCESS + 2;
525   fail_if (strcmp (gst_flow_get_name (ret), "custom-success"));
526   quark = gst_flow_to_quark (ret);
527   fail_if (strcmp (g_quark_to_string (quark), "custom-success"));
528
529   ret = GST_FLOW_CUSTOM_ERROR - 2;
530   fail_if (strcmp (gst_flow_get_name (ret), "custom-error"));
531   quark = gst_flow_to_quark (ret);
532   fail_if (strcmp (g_quark_to_string (quark), "custom-error"));
533
534   /* unknown values */
535   ret = GST_FLOW_CUSTOM_ERROR + 2;
536   fail_if (strcmp (gst_flow_get_name (ret), "unknown"));
537   quark = gst_flow_to_quark (ret);
538   fail_unless (quark == 0);
539 }
540
541 GST_END_TEST;
542
543 GST_START_TEST (test_push_negotiation)
544 {
545   GstPad *src, *sink;
546   GstPadLinkReturn plr;
547   GstCaps *srccaps =
548       gst_caps_from_string ("audio/x-raw-int,width={16,32},depth={16,32}");
549   GstCaps *sinkcaps =
550       gst_caps_from_string ("audio/x-raw-int,width=32,depth={16,32}");
551   GstPadTemplate *src_template;
552   GstPadTemplate *sink_template;
553   GstCaps *caps;
554   GstBuffer *buffer;
555
556   /* setup */
557   src_template = gst_pad_template_new ("src", GST_PAD_SRC,
558       GST_PAD_ALWAYS, srccaps);
559   sink_template = gst_pad_template_new ("sink", GST_PAD_SINK,
560       GST_PAD_ALWAYS, sinkcaps);
561
562   sink = gst_pad_new_from_template (sink_template, "sink");
563   fail_if (sink == NULL);
564   gst_pad_set_chain_function (sink, gst_check_chain_func);
565
566   src = gst_pad_new_from_template (src_template, "src");
567   fail_if (src == NULL);
568
569   plr = gst_pad_link (src, sink);
570   fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
571
572   buffer = gst_buffer_new ();
573
574   /* activate pads */
575   gst_pad_set_active (src, TRUE);
576   gst_pad_set_active (sink, TRUE);
577
578   caps = gst_caps_from_string ("audio/x-raw-int,width=16,depth=16");
579
580   /* Should fail if src pad caps are incompatible with sink pad caps */
581   gst_pad_set_caps (src, caps);
582   gst_buffer_set_caps (buffer, caps);
583   gst_buffer_ref (buffer);
584   fail_unless (gst_pad_push (src, buffer) == GST_FLOW_NOT_NEGOTIATED);
585   ASSERT_MINI_OBJECT_REFCOUNT (buffer, "buffer", 1);
586   gst_buffer_unref (buffer);
587
588   /* teardown */
589   gst_pad_unlink (src, sink);
590   gst_object_unref (src);
591   gst_object_unref (sink);
592   gst_caps_unref (caps);
593   gst_object_unref (sink_template);
594   gst_object_unref (src_template);
595 }
596
597 GST_END_TEST;
598
599 /* see that an unref also unlinks the pads */
600 GST_START_TEST (test_src_unref_unlink)
601 {
602   GstPad *src, *sink;
603   GstCaps *caps;
604   GstPadLinkReturn plr;
605
606   sink = gst_pad_new ("sink", GST_PAD_SINK);
607   fail_if (sink == NULL);
608
609   src = gst_pad_new ("src", GST_PAD_SRC);
610   fail_if (src == NULL);
611
612   caps = gst_caps_from_string ("foo/bar");
613
614   gst_pad_set_caps (src, caps);
615   gst_pad_set_caps (sink, caps);
616
617   plr = gst_pad_link (src, sink);
618   fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
619
620   /* unref the srcpad */
621   gst_object_unref (src);
622
623   /* sink should be unlinked now */
624   fail_if (gst_pad_is_linked (sink));
625
626   /* cleanup */
627   gst_object_unref (sink);
628   gst_caps_unref (caps);
629 }
630
631 GST_END_TEST;
632
633 /* see that an unref also unlinks the pads */
634 GST_START_TEST (test_sink_unref_unlink)
635 {
636   GstPad *src, *sink;
637   GstCaps *caps;
638   GstPadLinkReturn plr;
639
640   sink = gst_pad_new ("sink", GST_PAD_SINK);
641   fail_if (sink == NULL);
642
643   src = gst_pad_new ("src", GST_PAD_SRC);
644   fail_if (src == NULL);
645
646   caps = gst_caps_from_string ("foo/bar");
647
648   gst_pad_set_caps (src, caps);
649   gst_pad_set_caps (sink, caps);
650
651   plr = gst_pad_link (src, sink);
652   fail_unless (GST_PAD_LINK_SUCCESSFUL (plr));
653
654   /* unref the sinkpad */
655   gst_object_unref (sink);
656
657   /* src should be unlinked now */
658   fail_if (gst_pad_is_linked (src));
659
660   /* cleanup */
661   gst_object_unref (src);
662   gst_caps_unref (caps);
663 }
664
665 GST_END_TEST;
666
667 static void
668 unblock_async_cb (GstPad * pad, gboolean blocked, gpointer user_data)
669 {
670   gboolean *bool_user_data = (gboolean *) user_data;
671
672   /* here we should have blocked == 1 unblocked == 0 */
673   fail_unless (bool_user_data[0] == TRUE);
674   fail_unless (bool_user_data[1] == FALSE);
675
676   bool_user_data[1] = TRUE;
677 }
678
679 static void
680 block_async_cb (GstPad * pad, gboolean blocked, gpointer user_data)
681 {
682   gboolean *bool_user_data = (gboolean *) user_data;
683
684   /* here we should have blocked == 0 unblocked == 0 */
685   fail_unless (bool_user_data[0] == FALSE);
686   fail_unless (bool_user_data[1] == FALSE);
687
688   bool_user_data[0] = blocked;
689
690   gst_pad_set_blocked_async (pad, FALSE, unblock_async_cb, user_data);
691 }
692
693 GST_START_TEST (test_block_async)
694 {
695   GstPad *pad;
696   /* we set data[0] = TRUE when the pad is blocked, data[1] = TRUE when it's
697    * unblocked */
698   gboolean data[2] = { FALSE, FALSE };
699
700   pad = gst_pad_new ("src", GST_PAD_SRC);
701   fail_unless (pad != NULL);
702
703   gst_pad_set_active (pad, TRUE);
704   gst_pad_set_blocked_async (pad, TRUE, block_async_cb, &data);
705
706   fail_unless (data[0] == FALSE);
707   fail_unless (data[1] == FALSE);
708   gst_pad_push (pad, gst_buffer_new ());
709
710   gst_object_unref (pad);
711 }
712
713 GST_END_TEST;
714
715 #if 0
716 static void
717 block_async_second (GstPad * pad, gboolean blocked, gpointer user_data)
718 {
719   gst_pad_set_blocked_async (pad, FALSE, unblock_async_cb, NULL);
720 }
721
722 static void
723 block_async_first (GstPad * pad, gboolean blocked, gpointer user_data)
724 {
725   static int n_calls = 0;
726   gboolean *bool_user_data = (gboolean *) user_data;
727
728   if (++n_calls > 1)
729     /* we expect this callback to be called only once */
730     g_warn_if_reached ();
731
732   *bool_user_data = blocked;
733
734   /* replace block_async_first with block_async_second so next time the pad is
735    * blocked the latter should be called */
736   gst_pad_set_blocked_async (pad, TRUE, block_async_second, NULL);
737
738   /* unblock temporarily, in the next push block_async_second should be called
739    */
740   gst_pad_push_event (pad, gst_event_new_flush_start ());
741 }
742
743 GST_START_TEST (test_block_async_replace_callback)
744 {
745   GstPad *pad;
746   gboolean blocked;
747
748   pad = gst_pad_new ("src", GST_PAD_SRC);
749   fail_unless (pad != NULL);
750   gst_pad_set_active (pad, TRUE);
751
752   gst_pad_set_blocked_async (pad, TRUE, block_async_first, &blocked);
753   blocked = FALSE;
754
755   gst_pad_push (pad, gst_buffer_new ());
756   fail_unless (blocked == TRUE);
757   /* block_async_first flushes to unblock */
758   gst_pad_push_event (pad, gst_event_new_flush_stop ());
759
760   /* push again, this time block_async_second should be called */
761   gst_pad_push (pad, gst_buffer_new ());
762   fail_unless (blocked == TRUE);
763
764   gst_object_unref (pad);
765 }
766
767 GST_END_TEST;
768 #endif
769
770 static void
771 block_async_full_destroy (gpointer user_data)
772 {
773   gint *state = (gint *) user_data;
774
775   fail_unless (*state < 2);
776
777   GST_DEBUG ("setting state to 2");
778   *state = 2;
779 }
780
781 static void
782 block_async_full_cb (GstPad * pad, gboolean blocked, gpointer user_data)
783 {
784   *(gint *) user_data = (gint) blocked;
785
786   gst_pad_push_event (pad, gst_event_new_flush_start ());
787   GST_DEBUG ("setting state to 1");
788 }
789
790 GST_START_TEST (test_block_async_full_destroy)
791 {
792   GstPad *pad;
793   /* 0 = unblocked, 1 = blocked, 2 = destroyed */
794   gint state = 0;
795
796   pad = gst_pad_new ("src", GST_PAD_SRC);
797   fail_unless (pad != NULL);
798   gst_pad_set_active (pad, TRUE);
799
800   gst_pad_set_blocked_async_full (pad, TRUE, block_async_full_cb,
801       &state, block_async_full_destroy);
802   fail_unless (state == 0);
803
804   gst_pad_push (pad, gst_buffer_new ());
805   /* block_async_full_cb sets state to 1 and then flushes to unblock temporarily
806    */
807   fail_unless (state == 1);
808   gst_pad_push_event (pad, gst_event_new_flush_stop ());
809
810   /* pad was already blocked so nothing happens */
811   gst_pad_set_blocked_async_full (pad, TRUE, block_async_full_cb,
812       &state, block_async_full_destroy);
813   fail_unless (state == 1);
814
815   /* unblock with the same data, callback is called */
816   gst_pad_set_blocked_async_full (pad, FALSE, block_async_full_cb,
817       &state, block_async_full_destroy);
818   fail_unless (state == 2);
819
820   /* block with the same data, callback is called */
821   state = 1;
822   gst_pad_set_blocked_async_full (pad, TRUE, block_async_full_cb,
823       &state, block_async_full_destroy);
824   fail_unless (state == 2);
825
826   /* now change user_data (to NULL in this case) so destroy_notify should be
827    * called */
828   state = 1;
829   gst_pad_set_blocked_async_full (pad, FALSE, block_async_full_cb,
830       NULL, block_async_full_destroy);
831   fail_unless (state == 2);
832
833   gst_object_unref (pad);
834 }
835
836 GST_END_TEST;
837
838 GST_START_TEST (test_block_async_full_destroy_dispose)
839 {
840   GstPad *pad;
841   /* 0 = unblocked, 1 = blocked, 2 = destroyed */
842   gint state = 0;
843
844   pad = gst_pad_new ("src", GST_PAD_SRC);
845   fail_unless (pad != NULL);
846   gst_pad_set_active (pad, TRUE);
847
848   gst_pad_set_blocked_async_full (pad, TRUE, block_async_full_cb,
849       &state, block_async_full_destroy);
850
851   gst_pad_push (pad, gst_buffer_new ());
852   /* block_async_full_cb sets state to 1 and then flushes to unblock temporarily
853    */
854   fail_unless_equals_int (state, 1);
855   gst_pad_push_event (pad, gst_event_new_flush_stop ());
856
857   /* gst_pad_dispose calls the destroy_notify function if necessary */
858   gst_object_unref (pad);
859
860   fail_unless_equals_int (state, 2);
861 }
862
863 GST_END_TEST;
864
865
866 static void
867 unblock_async_no_flush_cb (GstPad * pad, gboolean blocked, gpointer user_data)
868 {
869   gboolean *bool_user_data = (gboolean *) user_data;
870
871   /* here we should have blocked == 1 unblocked == 0 */
872
873   fail_unless (blocked == FALSE);
874
875   fail_unless (bool_user_data[0] == TRUE);
876   fail_unless (bool_user_data[1] == TRUE);
877   fail_unless (bool_user_data[2] == FALSE);
878
879   bool_user_data[2] = TRUE;
880 }
881
882
883 static void
884 unblock_async_not_called (GstPad * pad, gboolean blocked, gpointer user_data)
885 {
886   g_warn_if_reached ();
887 }
888
889 static void
890 block_async_second_no_flush (GstPad * pad, gboolean blocked, gpointer user_data)
891 {
892   gboolean *bool_user_data = (gboolean *) user_data;
893
894   fail_unless (blocked == TRUE);
895
896   fail_unless (bool_user_data[0] == TRUE);
897   fail_unless (bool_user_data[1] == FALSE);
898   fail_unless (bool_user_data[2] == FALSE);
899
900   bool_user_data[1] = TRUE;
901
902   fail_unless (gst_pad_set_blocked_async (pad, FALSE, unblock_async_no_flush_cb,
903           user_data));
904 }
905
906 static void
907 block_async_first_no_flush (GstPad * pad, gboolean blocked, gpointer user_data)
908 {
909   static int n_calls = 0;
910   gboolean *bool_user_data = (gboolean *) user_data;
911
912   fail_unless (blocked == TRUE);
913
914   if (++n_calls > 1)
915     /* we expect this callback to be called only once */
916     g_warn_if_reached ();
917
918   *bool_user_data = blocked;
919
920   fail_unless (bool_user_data[0] == TRUE);
921   fail_unless (bool_user_data[1] == FALSE);
922   fail_unless (bool_user_data[2] == FALSE);
923
924   fail_unless (gst_pad_set_blocked_async (pad, FALSE, unblock_async_not_called,
925           NULL));
926
927   /* replace block_async_first with block_async_second so next time the pad is
928    * blocked the latter should be called */
929   fail_unless (gst_pad_set_blocked_async (pad, TRUE,
930           block_async_second_no_flush, user_data));
931 }
932
933 GST_START_TEST (test_block_async_replace_callback_no_flush)
934 {
935   GstPad *pad;
936   gboolean bool_user_data[3] = { FALSE, FALSE, FALSE };
937
938   pad = gst_pad_new ("src", GST_PAD_SRC);
939   fail_unless (pad != NULL);
940   gst_pad_set_active (pad, TRUE);
941
942   fail_unless (gst_pad_set_blocked_async (pad, TRUE, block_async_first_no_flush,
943           bool_user_data));
944
945   gst_pad_push (pad, gst_buffer_new ());
946   fail_unless (bool_user_data[0] == TRUE);
947   fail_unless (bool_user_data[1] == TRUE);
948   fail_unless (bool_user_data[2] == TRUE);
949
950   gst_object_unref (pad);
951 }
952
953 GST_END_TEST;
954
955
956 static Suite *
957 gst_pad_suite (void)
958 {
959   Suite *s = suite_create ("GstPad");
960   TCase *tc_chain = tcase_create ("general");
961
962   /* turn off timeout */
963   tcase_set_timeout (tc_chain, 60);
964
965   suite_add_tcase (s, tc_chain);
966   tcase_add_test (tc_chain, test_link);
967   tcase_add_test (tc_chain, test_refcount);
968   tcase_add_test (tc_chain, test_get_allowed_caps);
969   tcase_add_test (tc_chain, test_link_unlink_threaded);
970   tcase_add_test (tc_chain, test_name_is_valid);
971   tcase_add_test (tc_chain, test_push_unlinked);
972   tcase_add_test (tc_chain, test_push_linked);
973   tcase_add_test (tc_chain, test_push_buffer_list_compat);
974   tcase_add_test (tc_chain, test_flowreturn);
975   tcase_add_test (tc_chain, test_push_negotiation);
976   tcase_add_test (tc_chain, test_src_unref_unlink);
977   tcase_add_test (tc_chain, test_sink_unref_unlink);
978   tcase_add_test (tc_chain, test_block_async);
979 #if 0
980   tcase_add_test (tc_chain, test_block_async_replace_callback);
981 #endif
982   tcase_add_test (tc_chain, test_block_async_full_destroy);
983   tcase_add_test (tc_chain, test_block_async_full_destroy_dispose);
984   tcase_add_test (tc_chain, test_block_async_replace_callback_no_flush);
985
986   return s;
987 }
988
989 GST_CHECK_MAIN (gst_pad);