diff --git a/quic/quartc/test/bidi_test_runner.cc b/quic/quartc/test/bidi_test_runner.cc
new file mode 100644
index 0000000..ebd6d33
--- /dev/null
+++ b/quic/quartc/test/bidi_test_runner.cc
@@ -0,0 +1,170 @@
+// 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/bidi_test_runner.h"
+
+#include "net/third_party/quiche/src/quic/quartc/test/quartc_peer.h"
+
+namespace quic {
+namespace test {
+
+namespace {
+
+bool ContainsSequenceNumbers(const std::vector<ReceivedMessage>& messages,
+                             IdToSequenceNumberMap id_to_sequence_number) {
+  for (const auto& message : messages) {
+    auto it = id_to_sequence_number.find(message.frame.source_id);
+    if (it != id_to_sequence_number.end() &&
+        it->second == message.frame.sequence_number) {
+      id_to_sequence_number.erase(it);
+    }
+  }
+  return id_to_sequence_number.empty();
+}
+
+void LogResults(const std::vector<ReceivedMessage>& messages) {
+  QuicTime::Delta max_delay = QuicTime::Delta::Zero();
+  QuicTime::Delta total_delay = QuicTime::Delta::Zero();
+  QuicByteCount total_throughput = 0;
+  for (const auto& message : messages) {
+    QuicTime::Delta one_way_delay =
+        message.receive_time - message.frame.send_time;
+    QUIC_VLOG(1) << "Frame details: source_id=" << message.frame.source_id
+                 << ", sequence_number=" << message.frame.sequence_number
+                 << ", one_way_delay (ms)=" << one_way_delay.ToMilliseconds();
+    max_delay = std::max(max_delay, one_way_delay);
+    total_delay = total_delay + one_way_delay;
+    total_throughput += message.frame.size;
+  }
+  QuicBandwidth total_bandwidth = QuicBandwidth::FromBytesAndTimeDelta(
+      total_throughput,
+      messages.back().receive_time - messages.front().receive_time);
+  QUIC_LOG(INFO) << "Summary:\n  max_delay (ms)=" << max_delay.ToMilliseconds()
+                 << "\n  average_delay (ms)="
+                 << total_delay.ToMilliseconds() / messages.size()
+                 << "\n  total_throughput (bytes)=" << total_throughput
+                 << "\n  total_bandwidth (bps)="
+                 << total_bandwidth.ToBitsPerSecond();
+}
+
+}  // namespace
+
+BidiTestRunner::BidiTestRunner(simulator::Simulator* simulator,
+                               QuartcPacketTransport* client_transport,
+                               QuartcPacketTransport* server_transport)
+    : simulator_(simulator),
+      client_transport_(client_transport),
+      server_transport_(server_transport) {
+  // Set up default data source configs.
+  // Emulates an audio source with a 20 ms ptime.
+  QuartcDataSource::Config audio;
+  audio.id = 1;
+  audio.frame_interval = QuicTime::Delta::FromMilliseconds(20);
+  audio.min_bandwidth = QuicBandwidth::FromKBitsPerSecond(8);
+  audio.max_bandwidth = QuicBandwidth::FromKBitsPerSecond(64);
+
+  // Emulates a video source at 30 fps.
+  QuartcDataSource::Config video;
+  video.id = 2;
+  video.frame_interval = QuicTime::Delta::FromMicroseconds(33333);
+  video.min_bandwidth = QuicBandwidth::FromKBitsPerSecond(25);
+  video.max_bandwidth = QuicBandwidth::FromKBitsPerSecond(5000);
+
+  // Note: by placing audio first, it takes priority in bandwidth allocations.
+  client_configs_.push_back(audio);
+  client_configs_.push_back(video);
+  server_configs_.push_back(audio);
+  server_configs_.push_back(video);
+}
+
+BidiTestRunner::~BidiTestRunner() {
+  // Note that peers must be deleted before endpoints.  Peers close the
+  // connection when deleted.
+  client_peer_.reset();
+  server_peer_.reset();
+}
+
+bool BidiTestRunner::RunTest(QuicTime::Delta test_duration) {
+  client_peer_ = QuicMakeUnique<QuartcPeer>(
+      simulator_->GetClock(), simulator_->GetAlarmFactory(),
+      simulator_->GetRandomGenerator(), client_configs_);
+  server_peer_ = QuicMakeUnique<QuartcPeer>(
+      simulator_->GetClock(), simulator_->GetAlarmFactory(),
+      simulator_->GetRandomGenerator(), server_configs_);
+
+  QuartcEndpoint::Delegate* server_delegate = server_peer_.get();
+  if (server_interceptor_) {
+    server_interceptor_->SetDelegate(server_delegate);
+    server_delegate = server_interceptor_;
+  }
+  server_endpoint_ = QuicMakeUnique<QuartcServerEndpoint>(
+      simulator_->GetAlarmFactory(), simulator_->GetClock(), server_delegate,
+      QuartcSessionConfig());
+
+  QuartcEndpoint::Delegate* client_delegate = client_peer_.get();
+  if (client_interceptor_) {
+    client_interceptor_->SetDelegate(client_delegate);
+    client_delegate = client_interceptor_;
+  }
+  client_endpoint_ = QuicMakeUnique<QuartcClientEndpoint>(
+      simulator_->GetAlarmFactory(), simulator_->GetClock(), client_delegate,
+      QuartcSessionConfig(), server_endpoint_->server_crypto_config());
+
+  QuicTime start_time = simulator_->GetClock()->Now();
+  server_endpoint_->Connect(server_transport_);
+  client_endpoint_->Connect(client_transport_);
+
+  // Measure connect latency.
+  if (!simulator_->RunUntil([this] { return client_peer_->Enabled(); })) {
+    return false;
+  }
+  QuicTime client_connected = simulator_->GetClock()->Now();
+  QuicTime::Delta client_connect_latency = client_connected - start_time;
+
+  if (!simulator_->RunUntil([this] { return server_peer_->Enabled(); })) {
+    return false;
+  }
+  QuicTime server_connected = simulator_->GetClock()->Now();
+  QuicTime::Delta server_connect_latency = server_connected - start_time;
+
+  QUIC_LOG(INFO) << "Connect latencies (ms): client=" << client_connect_latency
+                 << ", server=" << server_connect_latency;
+
+  // Run the test.
+  simulator_->RunFor(test_duration);
+
+  // Disable sending and drain.
+  // Note that draining by waiting for the last sequence number sent may be
+  // flaky if packet loss is enabled.  However, simulator-based tests don't
+  // currently have any loss.
+  server_peer_->SetEnabled(false);
+  client_peer_->SetEnabled(false);
+
+  IdToSequenceNumberMap sent_by_server = server_peer_->GetLastSequenceNumbers();
+  if (!simulator_->RunUntil([this, &sent_by_server] {
+        return ContainsSequenceNumbers(client_peer_->received_messages(),
+                                       sent_by_server);
+      })) {
+    return false;
+  }
+
+  IdToSequenceNumberMap sent_by_client = client_peer_->GetLastSequenceNumbers();
+  if (!simulator_->RunUntil([this, &sent_by_client] {
+        return ContainsSequenceNumbers(server_peer_->received_messages(),
+                                       sent_by_client);
+      })) {
+    return false;
+  }
+
+  // Compute results.
+  QUIC_LOG(INFO) << "Printing client->server results:";
+  LogResults(server_peer_->received_messages());
+
+  QUIC_LOG(INFO) << "Printing server->client results:";
+  LogResults(client_peer_->received_messages());
+  return true;
+}
+
+}  // namespace test
+}  // namespace quic
diff --git a/quic/quartc/test/bidi_test_runner.h b/quic/quartc/test/bidi_test_runner.h
new file mode 100644
index 0000000..b76695a
--- /dev/null
+++ b/quic/quartc/test/bidi_test_runner.h
@@ -0,0 +1,99 @@
+// 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_BIDI_TEST_RUNNER_H_
+#define QUICHE_QUIC_QUARTC_TEST_BIDI_TEST_RUNNER_H_
+
+#include "net/third_party/quiche/src/quic/core/quic_time.h"
+#include "net/third_party/quiche/src/quic/quartc/quartc_endpoint.h"
+#include "net/third_party/quiche/src/quic/quartc/quartc_packet_writer.h"
+#include "net/third_party/quiche/src/quic/quartc/test/quartc_data_source.h"
+#include "net/third_party/quiche/src/quic/quartc/test/quartc_peer.h"
+#include "net/third_party/quiche/src/quic/test_tools/simulator/simulator.h"
+
+namespace quic {
+namespace test {
+
+// Interface for a component that intercepts endpoint callbacks before
+// forwarding them to another delegate.
+class QuartcEndpointInterceptor : public QuartcEndpoint::Delegate {
+ public:
+  ~QuartcEndpointInterceptor() override = default;
+
+  // Passes the test's endpoint delegate to this interceptor.  The interceptor
+  // must forward all callbacks to this delegate as soon as it finishes handling
+  // them.
+  virtual void SetDelegate(QuartcEndpoint::Delegate* delegate) = 0;
+};
+
+// Runner for bidirectional media flow tests.
+//
+// BidiTestRunner allows an external fixture to set up transports, then executes
+// a test.  During the test, it sets up two QuartcPeers, connects them through
+// the transports, and sends data in both directions for a specified duration.
+// It then stops sending, waits for any pending messages to finish transmission,
+// and then computes and logs a few basic metrics.
+//
+// For now, the runner computes the maximum and average one-way delay, the total
+// throughput (in bytes) and the average bandwidth (in bits per second).  It
+// logs these to the test's text logs.
+//
+// By default, the BidiTestRunner emulates one video stream and one audio stream
+// in each direction.  The audio stream runs with a 20 ms ptime, between 8 and
+// 64 kbps.  The video stream runs at 30 fps, between 25 kbps and 5 mbps.
+// Individual tests can overwrite the configs.
+//
+// BidiTestRunner provides a way for the test to register an "interceptor" on
+// each endpoint.  This allows a test to reconfigure that endpoint's session
+// prior to beginning the test.  For example, interceptors may be used to attach
+// debug visitors or change the congestion controller.
+class BidiTestRunner {
+ public:
+  // TODO(b/130540842): Make this compatible with non-simulator execution.
+  BidiTestRunner(simulator::Simulator* simulator,
+                 QuartcPacketTransport* client_transport,
+                 QuartcPacketTransport* server_transport);
+
+  virtual ~BidiTestRunner();
+
+  void set_client_configs(std::vector<QuartcDataSource::Config> configs) {
+    client_configs_ = std::move(configs);
+  }
+
+  void set_server_configs(std::vector<QuartcDataSource::Config> configs) {
+    server_configs_ = std::move(configs);
+  }
+
+  void set_client_interceptor(QuartcEndpointInterceptor* interceptor) {
+    client_interceptor_ = interceptor;
+  }
+
+  void set_server_interceptor(QuartcEndpointInterceptor* interceptor) {
+    server_interceptor_ = interceptor;
+  }
+
+  virtual bool RunTest(QuicTime::Delta test_duration);
+
+ private:
+  simulator::Simulator* simulator_;
+  QuartcPacketTransport* client_transport_;
+  QuartcPacketTransport* server_transport_;
+
+  std::vector<QuartcDataSource::Config> client_configs_;
+  std::vector<QuartcDataSource::Config> server_configs_;
+
+  QuartcEndpointInterceptor* client_interceptor_ = nullptr;
+  QuartcEndpointInterceptor* server_interceptor_ = nullptr;
+
+  std::unique_ptr<QuartcServerEndpoint> server_endpoint_;
+  std::unique_ptr<QuartcClientEndpoint> client_endpoint_;
+
+  std::unique_ptr<QuartcPeer> client_peer_;
+  std::unique_ptr<QuartcPeer> server_peer_;
+};
+
+}  // namespace test
+}  // namespace quic
+
+#endif  // QUICHE_QUIC_QUARTC_TEST_BIDI_TEST_RUNNER_H_
diff --git a/quic/quartc/test/quartc_bidi_test.cc b/quic/quartc/test/quartc_bidi_test.cc
new file mode 100644
index 0000000..5c0e234
--- /dev/null
+++ b/quic/quartc/test/quartc_bidi_test.cc
@@ -0,0 +1,57 @@
+// 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 "testing/gmock/include/gmock/gmock.h"
+#include "testing/gtest/include/gtest/gtest.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/core/quic_types.h"
+#include "net/third_party/quiche/src/quic/platform/api/quic_ptr_util.h"
+#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/test_tools/simulator/link.h"
+#include "net/third_party/quiche/src/quic/test_tools/simulator/simulator.h"
+
+namespace quic {
+namespace test {
+namespace {
+
+class QuartcBidiTest : public QuicTest {
+ protected:
+  QuartcBidiTest() {}
+
+  void CreateTransports(QuicBandwidth bandwidth,
+                        QuicTime::Delta propagation_delay,
+                        QuicByteCount queue_length) {
+    client_transport_ =
+        QuicMakeUnique<simulator::SimulatedQuartcPacketTransport>(
+            &simulator_, "client_transport", "server_transport", queue_length);
+    server_transport_ =
+        QuicMakeUnique<simulator::SimulatedQuartcPacketTransport>(
+            &simulator_, "server_transport", "client_transport", queue_length);
+    client_server_link_ = QuicMakeUnique<simulator::SymmetricLink>(
+        client_transport_.get(), server_transport_.get(), bandwidth,
+        propagation_delay);
+  }
+
+  simulator::Simulator simulator_;
+
+  std::unique_ptr<simulator::SimulatedQuartcPacketTransport> client_transport_;
+  std::unique_ptr<simulator::SimulatedQuartcPacketTransport> server_transport_;
+  std::unique_ptr<simulator::SymmetricLink> client_server_link_;
+};
+
+TEST_F(QuartcBidiTest, Basic300kbps200ms) {
+  CreateTransports(QuicBandwidth::FromKBitsPerSecond(300),
+                   QuicTime::Delta::FromMilliseconds(200),
+                   10 * kDefaultMaxPacketSize);
+  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/quartc_peer.cc b/quic/quartc/test/quartc_peer.cc
index 32425c7..036ba03 100644
--- a/quic/quartc/test/quartc_peer.cc
+++ b/quic/quartc/test/quartc_peer.cc
@@ -31,9 +31,9 @@
   }
 }
 
-std::map<int32_t, int64_t> QuartcPeer::GetLastSequenceNumbers() const {
+IdToSequenceNumberMap QuartcPeer::GetLastSequenceNumbers() const {
   DCHECK_GE(configs_.size(), data_sources_.size());
-  std::map<int32_t, int64_t> out;
+  IdToSequenceNumberMap out;
   for (int i = 0; i < data_sources_.size(); ++i) {
     out[configs_[i].id] = data_sources_[i]->sequence_number();
   }
diff --git a/quic/quartc/test/quartc_peer.h b/quic/quartc/test/quartc_peer.h
index 32b29be..68cb9ee 100644
--- a/quic/quartc/test/quartc_peer.h
+++ b/quic/quartc/test/quartc_peer.h
@@ -23,6 +23,9 @@
 namespace quic {
 namespace test {
 
+// Map of source id to sequence number.
+using IdToSequenceNumberMap = std::map<int32_t, int64_t>;
+
 // ParsedQuartcDataFrame with a receive_time.
 struct ReceivedMessage {
   ParsedQuartcDataFrame frame;
@@ -65,7 +68,7 @@
 
   // Returns a map of source id to the sequence number of the last frame
   // produced by that source.
-  std::map<int32_t, int64_t> GetLastSequenceNumbers() const;
+  IdToSequenceNumberMap GetLastSequenceNumbers() const;
 
   // QuartcEndpoint::Delegate overrides.
   void OnSessionCreated(QuartcSession* session) override;