diff --git a/tests/check/elements/rtprtx.c b/tests/check/elements/rtprtx.c
index 4c51394167..b1b8f1d602 100644
--- a/tests/check/elements/rtprtx.c
+++ b/tests/check/elements/rtprtx.c
@@ -563,6 +563,501 @@ GST_START_TEST (test_drop_one_sender)
 
 GST_END_TEST;
 
+GMutex lock_eos;
+static gint nb_sources;
+static gint nb_eos;
+
+static void
+message_received_multiple (GstBus * bus, GstMessage * message,
+    GstPipeline * bin)
+{
+  GST_INFO ("bus message from \"%" GST_PTR_FORMAT "\": %" GST_PTR_FORMAT,
+      GST_MESSAGE_SRC (message), message);
+
+  switch (message->type) {
+    case GST_MESSAGE_EOS:
+      g_main_loop_quit (main_loop);
+      break;
+    case GST_MESSAGE_WARNING:{
+      GError *gerror;
+      gchar *debug;
+
+      gst_message_parse_warning (message, &gerror, &debug);
+      gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
+      g_error_free (gerror);
+      g_free (debug);
+      break;
+    }
+    case GST_MESSAGE_ERROR:{
+      GError *gerror;
+      gchar *debug;
+
+      gst_message_parse_error (message, &gerror, &debug);
+      gst_object_default_error (GST_MESSAGE_SRC (message), gerror, debug);
+      g_error_free (gerror);
+      g_free (debug);
+      g_main_loop_quit (main_loop);
+      break;
+    }
+    default:
+      break;
+  }
+}
+
+typedef struct
+{
+  guint count;
+  guint nb_packets;
+  guint drop_every_n_packets;
+  guint payload_type_master;
+} RTXSendMultipleData;
+
+/* drop some packets */
+static GstPadProbeReturn
+rtprtxsend_srcpad_probe_multiple (GstPad * pad, GstPadProbeInfo * info,
+    gpointer user_data)
+{
+  GstPadProbeReturn ret = GST_PAD_PROBE_OK;
+
+  if (info->type == (GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_PUSH)) {
+    GstBuffer *buffer = GST_BUFFER (info->data);
+    RTXSendMultipleData *rtxdata = (RTXSendMultipleData *) user_data;
+    GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
+    guint payload_type = 0;
+
+    gst_rtp_buffer_map (buffer, GST_MAP_READ, &rtp);
+    payload_type = gst_rtp_buffer_get_payload_type (&rtp);
+
+    /* main stream packets */
+    if (payload_type == rtxdata->payload_type_master) {
+      /* count packets of the main stream */
+      ++rtxdata->nb_packets;
+      /* drop some packets */
+      if (rtxdata->count < rtxdata->drop_every_n_packets) {
+        ++rtxdata->count;
+      } else {
+        /* drop a packet every 'rtxdata->count' packets */
+        rtxdata->count = 1;
+        ret = GST_PAD_PROBE_DROP;
+      }
+    } else {
+      /* retransmission packets */
+    }
+
+    gst_rtp_buffer_unmap (&rtp);
+  }
+
+  return ret;
+}
+
+/* make sure every sources has sent all their buffers */
+static GstPadProbeReturn
+source_srcpad_probe_multiple (GstPad * pad, GstPadProbeInfo * info,
+    gpointer user_data)
+{
+  GstPadProbeReturn ret = GST_PAD_PROBE_OK;
+
+  if (info->type ==
+      (GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM | GST_PAD_PROBE_TYPE_PUSH)) {
+    GstEvent *event = GST_PAD_PROBE_INFO_EVENT (info);
+    if (GST_EVENT_TYPE (event) == GST_EVENT_EOS) {
+      g_mutex_lock (&lock_eos);
+      ++nb_eos;
+      if (nb_eos < nb_sources)
+        ret = GST_PAD_PROBE_DROP;
+      g_mutex_unlock (&lock_eos);
+    }
+  }
+
+  return ret;
+}
+
+/* add one branch videotestsrc ! rtpvrawpay ! rtprtxsend ! queue ! funnel. */
+static RTXSendMultipleData *
+add_sender (GstElement * bin, const gchar * src_name,
+    const gchar * payloader_name, guint payload_type_master,
+    guint payload_type_aux)
+{
+  GstElement *src = NULL;
+  GstElement *rtppayloader = NULL;
+  GstElement *rtprtxsend = NULL;
+  GstElement *queue = NULL;
+  GstElement *funnel = NULL;
+  GstPad *srcpad = NULL;
+  gboolean res = FALSE;
+  RTXSendMultipleData *send_rtxdata = g_slice_new0 (RTXSendMultipleData);
+
+  send_rtxdata->count = 1;
+  send_rtxdata->nb_packets = 0;
+  send_rtxdata->drop_every_n_packets = 0;
+  send_rtxdata->payload_type_master = payload_type_master;
+
+  src = gst_element_factory_make (src_name, NULL);
+  rtppayloader = gst_element_factory_make (payloader_name, NULL);
+  rtprtxsend = gst_element_factory_make ("rtprtxsend", NULL);
+  queue = gst_element_factory_make ("queue", NULL);
+  funnel = gst_bin_get_by_name (GST_BIN (bin), "funnel");
+
+  g_object_set (src, "num-buffers", 25, NULL);
+  g_object_set (rtppayloader, "pt", payload_type_master, NULL);
+  g_object_set (rtppayloader, "seqnum-offset", 1, NULL);
+  g_object_set (rtprtxsend, "rtx-payload-type", payload_type_aux, NULL);
+  /* we want that every drop packet be resent fast */
+  g_object_set (queue, "max-size-buffers", 1, NULL);
+  g_object_set (queue, "flush-on-eos", FALSE, NULL);
+
+  gst_bin_add_many (GST_BIN (bin), src, rtppayloader, rtprtxsend, queue, NULL);
+
+  res = gst_element_link (src, rtppayloader);
+  fail_unless (res == TRUE, NULL);
+  res = gst_element_link (rtppayloader, rtprtxsend);
+  fail_unless (res == TRUE, NULL);
+  res = gst_element_link (rtprtxsend, queue);
+  fail_unless (res == TRUE, NULL);
+  res = gst_element_link (queue, funnel);
+  fail_unless (res == TRUE, NULL);
+  gst_object_unref (funnel);
+
+  /* to drop some packets */
+  srcpad = gst_element_get_static_pad (rtprtxsend, "src");
+  gst_pad_add_probe (srcpad,
+      (GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_PUSH),
+      (GstPadProbeCallback) rtprtxsend_srcpad_probe_multiple, send_rtxdata,
+      NULL);
+  gst_object_unref (srcpad);
+
+  /* to make sure every sources has sent all their buffers */
+  srcpad = gst_element_get_static_pad (queue, "src");
+  gst_pad_add_probe (srcpad,
+      (GST_PAD_PROBE_TYPE_EVENT_DOWNSTREAM | GST_PAD_PROBE_TYPE_PUSH),
+      (GstPadProbeCallback) source_srcpad_probe_multiple, NULL, NULL);
+  gst_object_unref (srcpad);
+
+  ++nb_sources;
+
+  return send_rtxdata;
+}
+
+typedef struct
+{
+  GHashTable *ssrc_to_nb_packets_map;
+  GHashTable *ssrc_to_seqnum_offset_map;
+  guint seqnum_offset;
+} RTXReceiveMultipleData;
+
+static GstPadProbeReturn
+rtprtxreceive_srcpad_probe_multiple (GstPad * pad, GstPadProbeInfo * info,
+    gpointer user_data)
+{
+  if (info->type == (GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_PUSH)) {
+    GstBuffer *buffer = GST_BUFFER (info->data);
+    RTXReceiveMultipleData *rtxdata = (RTXReceiveMultipleData *) user_data;
+    GstRTPBuffer rtp = GST_RTP_BUFFER_INIT;
+    guint ssrc = 0;
+    guint seqnum = 0;
+    gpointer seqnum_prev = 0;
+    guint nb_packets = 0;
+
+    gst_rtp_buffer_map (buffer, GST_MAP_READ, &rtp);
+    ssrc = gst_rtp_buffer_get_ssrc (&rtp);
+    seqnum = gst_rtp_buffer_get_seq (&rtp);
+
+    if (!g_hash_table_lookup_extended (rtxdata->ssrc_to_seqnum_offset_map,
+            GUINT_TO_POINTER (ssrc), NULL, &seqnum_prev)) {
+      /*In our test we take care to never drop the first buffer */
+      g_hash_table_insert (rtxdata->ssrc_to_seqnum_offset_map,
+          GUINT_TO_POINTER (ssrc), GUINT_TO_POINTER (seqnum));
+      g_hash_table_insert (rtxdata->ssrc_to_nb_packets_map,
+          GUINT_TO_POINTER (ssrc), GUINT_TO_POINTER (1));
+      return GST_PAD_PROBE_OK;
+    }
+
+    /* check if there is a dropped packet
+     * (in our test every packet arrived in increasing order) */
+    if (seqnum > GPOINTER_TO_UINT (seqnum_prev) + rtxdata->seqnum_offset) {
+      GstPad *peerpad = gst_pad_get_peer (pad);
+      guint i = 0;
+
+      /* ask retransmission of missing packets */
+      for (i = GPOINTER_TO_UINT (seqnum_prev) + rtxdata->seqnum_offset;
+          i < seqnum; i += rtxdata->seqnum_offset) {
+        GstEvent *event = gst_event_new_custom (GST_EVENT_CUSTOM_UPSTREAM,
+            gst_structure_new ("GstRTPRetransmissionRequest",
+                "seqnum", G_TYPE_UINT, i,
+                "ssrc", G_TYPE_UINT, gst_rtp_buffer_get_ssrc (&rtp),
+                "payload-type", G_TYPE_UINT,
+                gst_rtp_buffer_get_payload_type (&rtp),
+                NULL));
+        gst_pad_push_event (peerpad, event);
+      }
+      gst_object_unref (peerpad);
+
+      g_hash_table_insert (rtxdata->ssrc_to_seqnum_offset_map,
+          GUINT_TO_POINTER (ssrc), GUINT_TO_POINTER (seqnum));
+    } else if (seqnum ==
+        GPOINTER_TO_UINT (seqnum_prev) + rtxdata->seqnum_offset) {
+      /* also update previous seqnum in this case */
+      g_hash_table_insert (rtxdata->ssrc_to_seqnum_offset_map,
+          GUINT_TO_POINTER (ssrc), GUINT_TO_POINTER (seqnum));
+    } else {
+      /* receive retransmited packet */
+    }
+
+    gst_rtp_buffer_unmap (&rtp);
+
+    nb_packets =
+        GPOINTER_TO_UINT (g_hash_table_lookup (rtxdata->ssrc_to_nb_packets_map,
+            GUINT_TO_POINTER (ssrc)));
+    g_hash_table_insert (rtxdata->ssrc_to_nb_packets_map,
+        GUINT_TO_POINTER (ssrc), GUINT_TO_POINTER (++nb_packets));
+  }
+
+  return GST_PAD_PROBE_OK;
+}
+
+static void
+reset_rtx_send_data (RTXSendMultipleData * send_rtxdata, gpointer data)
+{
+  send_rtxdata->count = 1;
+  send_rtxdata->nb_packets = 0;
+  send_rtxdata->drop_every_n_packets = *(guint *) data;
+}
+
+/* compute number of all packets sent by all sender */
+static void
+compute_total_packets_sent (RTXSendMultipleData * send_rtxdata, gpointer data)
+{
+  guint *sum = (guint *) data;
+  *sum += send_rtxdata->nb_packets;
+}
+
+/* compute number of all packets received by rtprtxreceive::src pad */
+static void
+compute_total_packets_received (gpointer key, gpointer value, gpointer data)
+{
+  guint *sum = (guint *) data;
+  *sum += GPOINTER_TO_UINT (value);
+}
+
+static void
+start_test_drop_multiple_and_check_results (GstElement * bin,
+    GList * send_rtxdata_list, RTXReceiveMultipleData * receive_rtxdata,
+    guint drop_every_n_packets)
+{
+  GstStateChangeReturn state_res = GST_STATE_CHANGE_FAILURE;
+  GstElement *rtprtxreceive =
+      gst_bin_get_by_name (GST_BIN (bin), "rtprtxreceive");
+  guint sum_all_packets_sent = 0;
+  guint sum_rtx_packets_sent = 0;
+  guint sum_all_packets_received = 0;
+  guint sum_rtx_packets_received = 0;
+  guint sum_rtx_assoc_packets_received = 0;
+  guint sum_rtx_dropped_packets_received = 0;
+  gdouble error_sent_recv = 0;
+  GstIterator *itr_elements = NULL;
+  gboolean done = FALSE;
+  GValue item = { 0 };
+  GstElement *element = NULL;
+  gchar *name = NULL;
+
+  GST_INFO ("starting test");
+
+  g_hash_table_remove_all (receive_rtxdata->ssrc_to_nb_packets_map);
+  g_hash_table_remove_all (receive_rtxdata->ssrc_to_seqnum_offset_map);
+
+  g_list_foreach (send_rtxdata_list, (GFunc) reset_rtx_send_data,
+      &drop_every_n_packets);
+
+  /* run pipeline */
+  state_res = gst_element_set_state (bin, GST_STATE_PLAYING);
+  ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
+
+  state_res = gst_element_get_state (bin, NULL, NULL, GST_CLOCK_TIME_NONE);
+  ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
+
+  GST_INFO ("running main loop");
+  g_main_loop_run (main_loop);
+
+  /* check results */
+  itr_elements = gst_bin_iterate_elements (GST_BIN (bin));
+  done = FALSE;
+  while (!done) {
+    switch (gst_iterator_next (itr_elements, &item)) {
+      case GST_ITERATOR_OK:
+        element = GST_ELEMENT (g_value_get_object (&item));
+        name = gst_element_get_name (element);
+        if (g_str_has_prefix (name, "rtprtxsend") > 0) {
+          guint nb_packets = 0;
+          g_object_get (G_OBJECT (element), "num-rtx-packets", &nb_packets,
+              NULL);
+          sum_rtx_packets_sent += nb_packets;
+        }
+        g_free (name);
+        g_value_reset (&item);
+        break;
+      case GST_ITERATOR_RESYNC:
+        gst_iterator_resync (itr_elements);
+        break;
+      case GST_ITERATOR_ERROR:
+        done = TRUE;
+        break;
+      case GST_ITERATOR_DONE:
+        done = TRUE;
+        break;
+    }
+  }
+  g_value_unset (&item);
+  gst_iterator_free (itr_elements);
+
+  /* compute number of all packets sent by all sender */
+  g_list_foreach (send_rtxdata_list, (GFunc) compute_total_packets_sent,
+      &sum_all_packets_sent);
+
+  /* compute number of all packets received by rtprtxreceive::src pad */
+  g_hash_table_foreach (receive_rtxdata->ssrc_to_nb_packets_map,
+      compute_total_packets_received, (gpointer) & sum_all_packets_received);
+
+  /* check that we sent as many packets as received */
+  /* when eos is received by sources we cannot ensure that every packets
+   * will be received by sinks (maybe queue flush ?)
+   */
+  fail_if (sum_all_packets_sent < sum_all_packets_received);
+
+  /* some packet are not received, I still have to figure out why
+   * but I suspect it comes from pipeline setup/shutdown
+   */
+  if (sum_all_packets_sent != sum_all_packets_received) {
+    error_sent_recv =
+        1 - sum_all_packets_received / (gdouble) sum_all_packets_sent;
+    fail_if (error_sent_recv > 0.30);
+    /* it should be 0% */
+  }
+
+  /* retrieve number of retransmit packets received by rtprtxreceive */
+  g_object_get (G_OBJECT (rtprtxreceive), "num-rtx-packets",
+      &sum_rtx_packets_received, NULL);
+
+  /* some of rtx packet are not received because the receiver avoids
+   * collision (= requests that have the same seqnum)
+   */
+  fail_if (sum_rtx_packets_sent < sum_rtx_packets_received);
+  g_object_get (G_OBJECT (rtprtxreceive), "num-rtx-assoc-packets",
+      &sum_rtx_assoc_packets_received, NULL);
+  sum_rtx_dropped_packets_received =
+      sum_rtx_packets_received - sum_rtx_assoc_packets_received;
+  fail_unless_equals_int (sum_rtx_packets_sent,
+      sum_rtx_assoc_packets_received + sum_rtx_dropped_packets_received);
+
+  gst_object_unref (rtprtxreceive);
+  state_res = gst_element_set_state (bin, GST_STATE_NULL);
+  ck_assert_int_ne (state_res, GST_STATE_CHANGE_FAILURE);
+}
+
+static void
+free_rtx_send_data (gpointer data)
+{
+  g_slice_free (RTXSendMultipleData, data);
+}
+
+/* This test build the pipeline funnel name=funnel
+ * videotestsrc ! rtpvrawpay ! rtprtxsend ! queue ! funnel.
+ * videotestsrc ! rtpvrawpay ! rtprtxsend ! queue ! funnel.
+ * N
+ * funnel. ! rtprtxreceive ! fakesink
+ * and drop some buffer just after each rtprtxsend
+ * Then it checks that every dropped packet has been re-sent and it checks
+ * that not too much requests has been sent.
+ */
+GST_START_TEST (test_drop_multiple_sender)
+{
+  GstElement *bin, *funnel, *rtprtxreceive, *sink;
+  GstBus *bus;
+  gboolean res;
+  GstPad *srcpad;
+  guint drop_every_n_packets = 0;
+  GList *send_rtxdata_list = NULL;
+  RTXReceiveMultipleData receive_rtxdata;
+
+  GST_INFO ("preparing test");
+
+  receive_rtxdata.ssrc_to_nb_packets_map =
+      g_hash_table_new (g_direct_hash, g_direct_equal);
+  receive_rtxdata.ssrc_to_seqnum_offset_map =
+      g_hash_table_new (g_direct_hash, g_direct_equal);
+  receive_rtxdata.seqnum_offset = 1;
+
+  /* build pipeline */
+  bin = gst_pipeline_new ("pipeline");
+  bus = gst_element_get_bus (bin);
+  gst_bus_add_signal_watch_full (bus, G_PRIORITY_HIGH);
+
+  funnel = gst_element_factory_make ("funnel", "funnel");
+  rtprtxreceive = gst_element_factory_make ("rtprtxreceive", "rtprtxreceive");
+  sink = gst_element_factory_make ("fakesink", "sink");
+  g_object_set (sink, "sync", TRUE, NULL);
+  g_object_set (sink, "qos", FALSE, NULL);
+  gst_bin_add_many (GST_BIN (bin), funnel, rtprtxreceive, sink, NULL);
+
+  nb_sources = 0;
+  g_mutex_init (&lock_eos);
+
+  send_rtxdata_list =
+      g_list_append (send_rtxdata_list, add_sender (bin, "videotestsrc",
+          "rtpvrawpay", 96, 121));
+  send_rtxdata_list =
+      g_list_append (send_rtxdata_list, add_sender (bin, "videotestsrc",
+          "rtpvrawpay", 97, 122));
+  send_rtxdata_list =
+      g_list_append (send_rtxdata_list, add_sender (bin, "videotestsrc",
+          "rtpvrawpay", 98, 123));
+  send_rtxdata_list =
+      g_list_append (send_rtxdata_list, add_sender (bin, "videotestsrc",
+          "rtpvrawpay", 99, 124));
+
+  res = gst_element_link (funnel, rtprtxreceive);
+  fail_unless (res == TRUE, NULL);
+  res = gst_element_link (rtprtxreceive, sink);
+  fail_unless (res == TRUE, NULL);
+
+  srcpad = gst_element_get_static_pad (rtprtxreceive, "src");
+  gst_pad_add_probe (srcpad,
+      (GST_PAD_PROBE_TYPE_BUFFER | GST_PAD_PROBE_TYPE_PUSH),
+      (GstPadProbeCallback) rtprtxreceive_srcpad_probe_multiple,
+      &receive_rtxdata, NULL);
+  gst_object_unref (srcpad);
+
+  main_loop = g_main_loop_new (NULL, FALSE);
+  g_signal_connect (bus, "message::error",
+      (GCallback) message_received_multiple, bin);
+  g_signal_connect (bus, "message::warning",
+      (GCallback) message_received_multiple, bin);
+  g_signal_connect (bus, "message::eos", (GCallback) message_received_multiple,
+      bin);
+
+  for (drop_every_n_packets = 2; drop_every_n_packets < 10;
+      drop_every_n_packets++) {
+    g_object_set (rtprtxreceive, "rtx-payload-types", "121:122:123:124", NULL);
+    nb_eos = 0;
+    start_test_drop_multiple_and_check_results (bin, send_rtxdata_list,
+        &receive_rtxdata, drop_every_n_packets);
+  }
+
+  /* cleanup */
+  g_main_loop_unref (main_loop);
+
+  g_list_free_full (send_rtxdata_list, free_rtx_send_data);
+  g_hash_table_destroy (receive_rtxdata.ssrc_to_nb_packets_map);
+  g_hash_table_destroy (receive_rtxdata.ssrc_to_seqnum_offset_map);
+
+  gst_bus_remove_signal_watch (bus);
+  gst_object_unref (bus);
+  gst_object_unref (bin);
+
+  g_mutex_clear (&lock_eos);
+}
+
+GST_END_TEST;
+
 static Suite *
 rtprtx_suite (void)
 {
@@ -575,6 +1070,7 @@ rtprtx_suite (void)
 
   tcase_add_test (tc_chain, test_push_forward_seq);
   tcase_add_test (tc_chain, test_drop_one_sender);
+  tcase_add_test (tc_chain, test_drop_multiple_sender);
 
   return s;
 }