diff --git a/quic/quartc/test/quartc_bidi_test.cc b/quic/quartc/test/quartc_bidi_test.cc
index db9972c..7761a80 100644
--- a/quic/quartc/test/quartc_bidi_test.cc
+++ b/quic/quartc/test/quartc_bidi_test.cc
@@ -11,8 +11,8 @@
 #include "net/third_party/quiche/src/quic/platform/api/quic_test.h"
 #include "net/third_party/quiche/src/quic/quartc/simulated_packet_transport.h"
 #include "net/third_party/quiche/src/quic/quartc/test/bidi_test_runner.h"
+#include "net/third_party/quiche/src/quic/quartc/test/random_delay_link.h"
 #include "net/third_party/quiche/src/quic/quartc/test/random_packet_filter.h"
-#include "net/third_party/quiche/src/quic/test_tools/simulator/link.h"
 #include "net/third_party/quiche/src/quic/test_tools/simulator/simulator.h"
 
 namespace quic {
@@ -37,7 +37,7 @@
         &simulator_, "client_filter", client_transport_.get());
     server_filter_ = QuicMakeUnique<simulator::RandomPacketFilter>(
         &simulator_, "server_filter", server_transport_.get());
-    client_server_link_ = QuicMakeUnique<simulator::SymmetricLink>(
+    client_server_link_ = QuicMakeUnique<simulator::SymmetricRandomDelayLink>(
         client_filter_.get(), server_filter_.get(), bandwidth,
         propagation_delay);
     client_filter_->set_loss_percent(loss_percent);
@@ -50,7 +50,7 @@
   std::unique_ptr<simulator::SimulatedQuartcPacketTransport> server_transport_;
   std::unique_ptr<simulator::RandomPacketFilter> client_filter_;
   std::unique_ptr<simulator::RandomPacketFilter> server_filter_;
-  std::unique_ptr<simulator::SymmetricLink> client_server_link_;
+  std::unique_ptr<simulator::SymmetricRandomDelayLink> client_server_link_;
 };
 
 TEST_F(QuartcBidiTest, Basic300kbps200ms) {
@@ -71,6 +71,17 @@
   EXPECT_TRUE(runner.RunTest(QuicTime::Delta::FromSeconds(30)));
 }
 
+TEST_F(QuartcBidiTest, 300kbps200ms25msRandom2PercentLoss) {
+  CreateTransports(QuicBandwidth::FromKBitsPerSecond(300),
+                   QuicTime::Delta::FromMilliseconds(200),
+                   10 * kDefaultMaxPacketSize, /*loss_percent=*/2);
+  client_server_link_->set_median_random_delay(
+      QuicTime::Delta::FromMilliseconds(25));
+  BidiTestRunner runner(&simulator_, client_transport_.get(),
+                        server_transport_.get());
+  EXPECT_TRUE(runner.RunTest(QuicTime::Delta::FromSeconds(30)));
+}
+
 }  // namespace
 }  // namespace test
 }  // namespace quic
diff --git a/quic/quartc/test/random_delay_link.cc b/quic/quartc/test/random_delay_link.cc
new file mode 100644
index 0000000..397a564
--- /dev/null
+++ b/quic/quartc/test/random_delay_link.cc
@@ -0,0 +1,84 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#include "net/third_party/quiche/src/quic/quartc/test/random_delay_link.h"
+
+#include <cmath>
+#include <cstdint>
+
+#include "net/third_party/quiche/src/quic/platform/api/quic_str_cat.h"
+#include "net/third_party/quiche/src/quic/test_tools/simulator/link.h"
+#include "net/third_party/quiche/src/quic/test_tools/simulator/port.h"
+#include "net/third_party/quiche/src/quic/test_tools/simulator/simulator.h"
+
+namespace quic {
+namespace simulator {
+namespace {
+
+// Number of buckets used to define an exponential distribution.
+constexpr int64_t kNumBuckets = 2l << 32;
+
+}  // namespace
+
+RandomDelayLink::RandomDelayLink(Simulator* simulator,
+                                 std::string name,
+                                 UnconstrainedPortInterface* sink,
+                                 QuicBandwidth bandwidth,
+                                 QuicTime::Delta propagation_delay)
+    : OneWayLink(simulator, name, sink, bandwidth, propagation_delay),
+      median_random_delay_(QuicTime::Delta::Zero()) {}
+
+RandomDelayLink::~RandomDelayLink() {}
+
+QuicTime::Delta RandomDelayLink::GetRandomDelay(QuicTime::Delta transfer_time) {
+  // Computes a random delay following an exponential distribution, with median
+  // value |median_random_delay_|.  Choose a uniform random value between 1 and
+  // kNumBuckets, convert this to an exponential, then scale it such that a
+  // random value from the middle of the distribution (0.5) corresponds to
+  // |median_random_delay_|.
+  return std::log(
+             static_cast<double>(
+                 simulator_->GetRandomGenerator()->RandUint64() % kNumBuckets +
+                 1) /
+             kNumBuckets) /
+         std::log(0.5) * median_random_delay_;
+}
+
+SymmetricRandomDelayLink::SymmetricRandomDelayLink(
+    Simulator* simulator,
+    std::string name,
+    UnconstrainedPortInterface* sink_a,
+    UnconstrainedPortInterface* sink_b,
+    QuicBandwidth bandwidth,
+    QuicTime::Delta propagation_delay)
+    : a_to_b_link_(simulator,
+                   QuicStringPrintf("%s (A-to-B)", name.c_str()),
+                   sink_b,
+                   bandwidth,
+                   propagation_delay),
+      b_to_a_link_(simulator,
+                   QuicStringPrintf("%s (B-to-A)", name.c_str()),
+                   sink_a,
+                   bandwidth,
+                   propagation_delay) {}
+
+SymmetricRandomDelayLink::SymmetricRandomDelayLink(
+    Endpoint* endpoint_a,
+    Endpoint* endpoint_b,
+    QuicBandwidth bandwidth,
+    QuicTime::Delta propagation_delay)
+    : SymmetricRandomDelayLink(endpoint_a->simulator(),
+                               QuicStringPrintf("Link [%s]<->[%s]",
+                                                endpoint_a->name().c_str(),
+                                                endpoint_b->name().c_str()),
+                               endpoint_a->GetRxPort(),
+                               endpoint_b->GetRxPort(),
+                               bandwidth,
+                               propagation_delay) {
+  endpoint_a->SetTxPort(&a_to_b_link_);
+  endpoint_b->SetTxPort(&b_to_a_link_);
+}
+
+}  // namespace simulator
+}  // namespace quic
diff --git a/quic/quartc/test/random_delay_link.h b/quic/quartc/test/random_delay_link.h
new file mode 100644
index 0000000..45f978e
--- /dev/null
+++ b/quic/quartc/test/random_delay_link.h
@@ -0,0 +1,78 @@
+// Copyright (c) 2019 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#ifndef QUICHE_QUIC_QUARTC_TEST_RANDOM_DELAY_LINK_H_
+#define QUICHE_QUIC_QUARTC_TEST_RANDOM_DELAY_LINK_H_
+
+#include "net/third_party/quiche/src/quic/core/crypto/quic_random.h"
+#include "net/third_party/quiche/src/quic/core/quic_bandwidth.h"
+#include "net/third_party/quiche/src/quic/core/quic_time.h"
+#include "net/third_party/quiche/src/quic/test_tools/simulator/link.h"
+#include "net/third_party/quiche/src/quic/test_tools/simulator/port.h"
+#include "net/third_party/quiche/src/quic/test_tools/simulator/simulator.h"
+
+namespace quic {
+namespace simulator {
+
+// A reliable simplex link between two endpoints with constrained bandwidth.  A
+// random delay is added to each packet.  The random values are chosen
+// separately for each packet, following an exponential distribution.
+class RandomDelayLink : public OneWayLink {
+ public:
+  RandomDelayLink(Simulator* simulator,
+                  std::string name,
+                  UnconstrainedPortInterface* sink,
+                  QuicBandwidth bandwidth,
+                  QuicTime::Delta propagation_delay);
+  RandomDelayLink(const RandomDelayLink&) = delete;
+  RandomDelayLink& operator=(const RandomDelayLink&) = delete;
+  ~RandomDelayLink() override;
+
+  // Sets the median value of the random delay introduced by this link.  Random
+  // delays are chosen according to an exponential distribution, clipped and
+  // scaled to reach this as a median value.
+  inline void set_median_random_delay(QuicTime::Delta delta) {
+    median_random_delay_ = delta;
+  }
+
+ protected:
+  QuicTime::Delta GetRandomDelay(QuicTime::Delta transfer_time) override;
+
+ private:
+  QuicTime::Delta median_random_delay_;
+};
+
+// A full-duplex link between two endpoints, functionally equivalent to two
+// RandomDelayLink objects tied together.
+class SymmetricRandomDelayLink {
+ public:
+  SymmetricRandomDelayLink(Simulator* simulator,
+                           std::string name,
+                           UnconstrainedPortInterface* sink_a,
+                           UnconstrainedPortInterface* sink_b,
+                           QuicBandwidth bandwidth,
+                           QuicTime::Delta propagation_delay);
+  SymmetricRandomDelayLink(Endpoint* endpoint_a,
+                           Endpoint* endpoint_b,
+                           QuicBandwidth bandwidth,
+                           QuicTime::Delta propagation_delay);
+  SymmetricRandomDelayLink(const SymmetricRandomDelayLink&) = delete;
+  SymmetricRandomDelayLink& operator=(const SymmetricRandomDelayLink&) = delete;
+
+  inline QuicBandwidth bandwidth() { return a_to_b_link_.bandwidth(); }
+
+  inline void set_median_random_delay(QuicTime::Delta delay) {
+    a_to_b_link_.set_median_random_delay(delay);
+    b_to_a_link_.set_median_random_delay(delay);
+  }
+
+ private:
+  RandomDelayLink a_to_b_link_;
+  RandomDelayLink b_to_a_link_;
+};
+
+}  // namespace simulator
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_QUARTC_TEST_RANDOM_DELAY_LINK_H_