Add m-esr52 at 52.6.0

21 files changed, 10675 insertions, 0 deletions

diff --git a/media/mtransport/test/TestSyncRunnable.cpp b/media/mtransport/test/TestSyncRunnable.cpp
new file mode 100644
index 000000000..02c7d5120
--- /dev/null
+++ b/media/mtransport/test/TestSyncRunnable.cpp
@@ -0,0 +1,61 @@
+/* -*- Mode: C++; tab-width: 12; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this
+ * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include "nsThreadUtils.h"
+#include "mozilla/SyncRunnable.h"
+
+#include "gtest/gtest.h"
+
+using namespace mozilla;
+
+nsIThread *gThread = nullptr;
+
+class TestRunnable : public Runnable {
+public:
+  TestRunnable() : ran_(false) {}
+
+  NS_IMETHOD Run() override
+  {
+    ran_ = true;
+
+    return NS_OK;
+  }
+
+  bool ran() const { return ran_; }
+
+private:
+  bool ran_;
+};
+
+class TestSyncRunnable : public ::testing::Test {
+public:
+  static void SetUpTestCase()
+  {
+    nsresult rv = NS_NewNamedThread("thread", &gThread);
+    ASSERT_TRUE(NS_SUCCEEDED(rv));
+  }
+
+  static void TearDownTestCase()
+  {
+    if (gThread)
+      gThread->Shutdown();
+  }
+};
+
+TEST_F(TestSyncRunnable, TestDispatch)
+{
+  RefPtr<TestRunnable> r(new TestRunnable());
+  RefPtr<SyncRunnable> s(new SyncRunnable(r));
+  s->DispatchToThread(gThread);
+
+  ASSERT_TRUE(r->ran());
+}
+
+TEST_F(TestSyncRunnable, TestDispatchStatic)
+{
+  RefPtr<TestRunnable> r(new TestRunnable());
+  SyncRunnable::DispatchToThread(gThread, r);
+  ASSERT_TRUE(r->ran());
+}
diff --git a/media/mtransport/test/buffered_stun_socket_unittest.cpp b/media/mtransport/test/buffered_stun_socket_unittest.cpp
new file mode 100644
index 000000000..32565215c
--- /dev/null
+++ b/media/mtransport/test/buffered_stun_socket_unittest.cpp
@@ -0,0 +1,296 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: ekr@rtfm.com
+
+#include <iostream>
+
+#include "nspr.h"
+#include "nss.h"
+#include "ssl.h"
+
+extern "C" {
+#include "nr_api.h"
+#include "nr_socket.h"
+#include "nr_socket_buffered_stun.h"
+#include "transport_addr.h"
+#include "stun.h"
+}
+
+#include "databuffer.h"
+#include "dummysocket.h"
+
+#include "nr_socket_prsock.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+using namespace mozilla;
+
+static uint8_t kStunMessage[] = {
+  0x00, 0x01, 0x00, 0x08, 0x21, 0x12, 0xa4, 0x42,
+  0x9b, 0x90, 0xbe, 0x2c, 0xae, 0x1a, 0x0c, 0xa8,
+  0xa0, 0xd6, 0x8b, 0x08, 0x80, 0x28, 0x00, 0x04,
+  0xdb, 0x35, 0x5f, 0xaa
+};
+static size_t kStunMessageLen = sizeof(kStunMessage);
+
+class BufferedStunSocketTest : public MtransportTest {
+ public:
+  BufferedStunSocketTest()
+      : MtransportTest(),
+        dummy_(nullptr),
+        test_socket_(nullptr) { }
+
+  ~BufferedStunSocketTest() {
+    nr_socket_destroy(&test_socket_);
+  }
+
+  void SetUp() {
+    MtransportTest::SetUp();
+
+    RefPtr<DummySocket> dummy(new DummySocket());
+
+    int r = nr_socket_buffered_stun_create(
+        dummy->get_nr_socket(),
+        kStunMessageLen,
+        TURN_TCP_FRAMING,
+        &test_socket_);
+    ASSERT_EQ(0, r);
+    dummy_ = dummy.forget();  // Now owned by test_socket_.
+
+    r = nr_str_port_to_transport_addr(
+        (char *)"192.0.2.133", 3333, IPPROTO_TCP, &remote_addr_);
+    ASSERT_EQ(0, r);
+
+    r = nr_socket_connect(test_socket_,
+                          &remote_addr_);
+    ASSERT_EQ(0, r);
+  }
+
+  nr_socket *socket() { return test_socket_; }
+
+ protected:
+  RefPtr<DummySocket> dummy_;
+  nr_socket *test_socket_;
+  nr_transport_addr remote_addr_;
+};
+
+
+TEST_F(BufferedStunSocketTest, TestCreate) {
+}
+
+TEST_F(BufferedStunSocketTest, TestSendTo) {
+  int r = nr_socket_sendto(test_socket_,
+                           kStunMessage,
+                           kStunMessageLen,
+                           0, &remote_addr_);
+  ASSERT_EQ(0, r);
+
+  dummy_->CheckWriteBuffer(kStunMessage, kStunMessageLen);
+}
+
+TEST_F(BufferedStunSocketTest, TestSendToBuffered) {
+  dummy_->SetWritable(0);
+
+  int r = nr_socket_sendto(test_socket_,
+                           kStunMessage,
+                           kStunMessageLen,
+                           0, &remote_addr_);
+  ASSERT_EQ(0, r);
+
+  dummy_->CheckWriteBuffer(nullptr, 0);
+
+  dummy_->SetWritable(kStunMessageLen);
+  dummy_->FireWritableCb();
+  dummy_->CheckWriteBuffer(kStunMessage, kStunMessageLen);
+}
+
+TEST_F(BufferedStunSocketTest, TestSendFullThenDrain) {
+  dummy_->SetWritable(0);
+
+  for (;;) {
+    int r = nr_socket_sendto(test_socket_,
+                             kStunMessage,
+                             kStunMessageLen,
+                             0, &remote_addr_);
+    if (r == R_WOULDBLOCK)
+      break;
+
+    ASSERT_EQ(0, r);
+  }
+
+  // Nothing was written.
+  dummy_->CheckWriteBuffer(nullptr, 0);
+
+  // Now flush.
+  dummy_->SetWritable(kStunMessageLen);
+  dummy_->FireWritableCb();
+  dummy_->ClearWriteBuffer();
+
+  // Verify we can write something.
+  int r = nr_socket_sendto(test_socket_,
+                             kStunMessage,
+                             kStunMessageLen,
+                             0, &remote_addr_);
+  ASSERT_EQ(0, r);
+
+  // And that it appears.
+  dummy_->CheckWriteBuffer(kStunMessage, kStunMessageLen);
+}
+
+TEST_F(BufferedStunSocketTest, TestSendToPartialBuffered) {
+  dummy_->SetWritable(10);
+
+  int r = nr_socket_sendto(test_socket_,
+                           kStunMessage,
+                           kStunMessageLen,
+                           0, &remote_addr_);
+  ASSERT_EQ(0, r);
+
+  dummy_->CheckWriteBuffer(kStunMessage, 10);
+  dummy_->ClearWriteBuffer();
+
+  dummy_->SetWritable(kStunMessageLen);
+  dummy_->FireWritableCb();
+  dummy_->CheckWriteBuffer(kStunMessage + 10, kStunMessageLen - 10);
+}
+
+TEST_F(BufferedStunSocketTest, TestSendToReject) {
+  dummy_->SetWritable(0);
+
+  int r = nr_socket_sendto(test_socket_,
+                           kStunMessage,
+                           kStunMessageLen,
+                           0, &remote_addr_);
+  ASSERT_EQ(0, r);
+
+  dummy_->CheckWriteBuffer(nullptr, 0);
+
+  r = nr_socket_sendto(test_socket_,
+                       kStunMessage,
+                       kStunMessageLen,
+                       0, &remote_addr_);
+  ASSERT_EQ(R_WOULDBLOCK, r);
+
+  dummy_->CheckWriteBuffer(nullptr, 0);
+}
+
+TEST_F(BufferedStunSocketTest, TestSendToWrongAddr) {
+  nr_transport_addr addr;
+
+  int r = nr_str_port_to_transport_addr(
+      (char *)"192.0.2.134", 3333, IPPROTO_TCP, &addr);
+  ASSERT_EQ(0, r);
+
+  r = nr_socket_sendto(test_socket_,
+                       kStunMessage,
+                       kStunMessageLen,
+                       0, &addr);
+  ASSERT_EQ(R_BAD_DATA, r);
+}
+
+TEST_F(BufferedStunSocketTest, TestReceiveRecvFrom) {
+  dummy_->SetReadBuffer(kStunMessage, kStunMessageLen);
+
+  unsigned char tmp[2048];
+  size_t len;
+  nr_transport_addr addr;
+
+  int r = nr_socket_recvfrom(test_socket_,
+                             tmp, sizeof(tmp), &len, 0,
+                             &addr);
+  ASSERT_EQ(0, r);
+  ASSERT_EQ(kStunMessageLen, len);
+  ASSERT_EQ(0, memcmp(kStunMessage, tmp, kStunMessageLen));
+  ASSERT_EQ(0, nr_transport_addr_cmp(&addr, &remote_addr_,
+                                     NR_TRANSPORT_ADDR_CMP_MODE_ALL));
+}
+
+TEST_F(BufferedStunSocketTest, TestReceiveRecvFromPartial) {
+  dummy_->SetReadBuffer(kStunMessage, 15);
+
+  unsigned char tmp[2048];
+  size_t len;
+  nr_transport_addr addr;
+
+  int r = nr_socket_recvfrom(test_socket_,
+                             tmp, sizeof(tmp), &len, 0,
+                             &addr);
+  ASSERT_EQ(R_WOULDBLOCK, r);
+
+
+  dummy_->SetReadBuffer(kStunMessage + 15, kStunMessageLen - 15);
+
+  r = nr_socket_recvfrom(test_socket_,
+                         tmp, sizeof(tmp), &len, 0,
+                         &addr);
+  ASSERT_EQ(0, r);
+  ASSERT_EQ(kStunMessageLen, len);
+  ASSERT_EQ(0, memcmp(kStunMessage, tmp, kStunMessageLen));
+  ASSERT_EQ(0, nr_transport_addr_cmp(&addr, &remote_addr_,
+                                     NR_TRANSPORT_ADDR_CMP_MODE_ALL));
+
+  r = nr_socket_recvfrom(test_socket_,
+                         tmp, sizeof(tmp), &len, 0,
+                         &addr);
+  ASSERT_EQ(R_WOULDBLOCK, r);
+}
+
+
+TEST_F(BufferedStunSocketTest, TestReceiveRecvFromGarbage) {
+  uint8_t garbage[50];
+  memset(garbage, 0xff, sizeof(garbage));
+
+  dummy_->SetReadBuffer(garbage, sizeof(garbage));
+
+  unsigned char tmp[2048];
+  size_t len;
+  nr_transport_addr addr;
+  int r = nr_socket_recvfrom(test_socket_,
+                             tmp, sizeof(tmp), &len, 0,
+                             &addr);
+  ASSERT_EQ(R_BAD_DATA, r);
+
+  r = nr_socket_recvfrom(test_socket_,
+                         tmp, sizeof(tmp), &len, 0,
+                         &addr);
+  ASSERT_EQ(R_FAILED, r);
+}
+
+TEST_F(BufferedStunSocketTest, TestReceiveRecvFromTooShort) {
+  dummy_->SetReadBuffer(kStunMessage, kStunMessageLen);
+
+  unsigned char tmp[2048];
+  size_t len;
+  nr_transport_addr addr;
+
+  int r = nr_socket_recvfrom(test_socket_,
+                             tmp, kStunMessageLen - 1, &len, 0,
+                             &addr);
+  ASSERT_EQ(R_BAD_ARGS, r);
+}
+
+TEST_F(BufferedStunSocketTest, TestReceiveRecvFromReallyLong) {
+  uint8_t garbage[4096];
+  memset(garbage, 0xff, sizeof(garbage));
+  memcpy(garbage, kStunMessage, kStunMessageLen);
+  nr_stun_message_header *hdr = reinterpret_cast<nr_stun_message_header *>
+      (garbage);
+  hdr->length = htons(3000);
+
+  dummy_->SetReadBuffer(garbage, sizeof(garbage));
+
+  unsigned char tmp[4096];
+  size_t len;
+  nr_transport_addr addr;
+
+  int r = nr_socket_recvfrom(test_socket_,
+                             tmp, kStunMessageLen - 1, &len, 0,
+                             &addr);
+  ASSERT_EQ(R_BAD_DATA, r);
+}
diff --git a/media/mtransport/test/dummysocket.h b/media/mtransport/test/dummysocket.h
new file mode 100644
index 000000000..a5d138940
--- /dev/null
+++ b/media/mtransport/test/dummysocket.h
@@ -0,0 +1,233 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original authors: ekr@rtfm.com; ryan@tokbox.com
+
+#ifndef MTRANSPORT_DUMMY_SOCKET_H_
+#define MTRANSPORT_DUMMY_SOCKET_H_
+
+#include "nr_socket_prsock.h"
+
+extern "C" {
+#include "transport_addr.h"
+}
+
+#include "databuffer.h"
+#include "mozilla/UniquePtr.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+namespace mozilla {
+
+static UniquePtr<DataBuffer> merge(UniquePtr<DataBuffer> a, UniquePtr<DataBuffer> b) {
+  if (a && a->len() && b && b->len()) {
+    UniquePtr<DataBuffer> merged(new DataBuffer());
+    merged->Allocate(a->len() + b->len());
+
+    memcpy(merged->data(), a->data(), a->len());
+    memcpy(merged->data() + a->len(), b->data(), b->len());
+
+    return merged;
+  }
+
+  if (a && a->len()) {
+    return a;
+  }
+
+  if (b && b->len()) {
+    return b;
+  }
+
+  return nullptr;
+}
+
+class DummySocket : public NrSocketBase {
+ public:
+  DummySocket()
+      : writable_(UINT_MAX),
+        write_buffer_(nullptr),
+        readable_(UINT_MAX),
+        read_buffer_(nullptr),
+        cb_(nullptr),
+        cb_arg_(nullptr),
+        self_(nullptr) {}
+
+  // the nr_socket APIs
+  virtual int create(nr_transport_addr *addr) {
+    return 0;
+  }
+
+  virtual int sendto(const void *msg, size_t len,
+                     int flags, nr_transport_addr *to) {
+    MOZ_CRASH();
+    return 0;
+  }
+
+  virtual int recvfrom(void * buf, size_t maxlen,
+                       size_t *len, int flags,
+                       nr_transport_addr *from) {
+    MOZ_CRASH();
+    return 0;
+  }
+
+  virtual int getaddr(nr_transport_addr *addrp) {
+    MOZ_CRASH();
+    return 0;
+  }
+
+  virtual void close() {
+  }
+
+  virtual int connect(nr_transport_addr *addr) {
+    nr_transport_addr_copy(&connect_addr_, addr);
+    return 0;
+  }
+
+  virtual int listen(int backlog) {
+    return 0;
+  }
+
+  virtual int accept(nr_transport_addr *addrp, nr_socket **sockp) {
+    return 0;
+  }
+
+
+  virtual int write(const void *msg, size_t len, size_t *written) {
+    size_t to_write = std::min(len, writable_);
+
+    if (to_write) {
+      UniquePtr<DataBuffer> msgbuf(new DataBuffer(static_cast<const uint8_t *>(msg), to_write));
+      write_buffer_ = merge(Move(write_buffer_), Move(msgbuf));
+    }
+
+    *written = to_write;
+
+    return 0;
+  }
+
+  virtual int read(void* buf, size_t maxlen, size_t *len) {
+    if (!read_buffer_.get()) {
+      return R_WOULDBLOCK;
+    }
+
+    size_t to_read = std::min(read_buffer_->len(),
+                              std::min(maxlen, readable_));
+
+    memcpy(buf, read_buffer_->data(), to_read);
+    *len = to_read;
+
+    if (to_read < read_buffer_->len()) {
+      read_buffer_.reset(new DataBuffer(read_buffer_->data() + to_read,
+                                    read_buffer_->len() - to_read));
+    } else {
+      read_buffer_.reset();
+    }
+
+    return 0;
+  }
+
+  // Implementations of the async_event APIs.
+  // These are no-ops because we handle scheduling manually
+  // for test purposes.
+  virtual int async_wait(int how, NR_async_cb cb, void *cb_arg,
+                         char *function, int line) {
+    EXPECT_EQ(nullptr, cb_);
+    cb_ = cb;
+    cb_arg_ = cb_arg;
+
+    return 0;
+  }
+
+  virtual int cancel(int how) {
+    cb_ = nullptr;
+    cb_arg_ = nullptr;
+
+    return 0;
+  }
+
+
+  // Read/Manipulate the current state.
+  void CheckWriteBuffer(const uint8_t *data, size_t len) {
+    if (!len) {
+      EXPECT_EQ(nullptr, write_buffer_.get());
+    } else {
+      EXPECT_NE(nullptr, write_buffer_.get());
+      ASSERT_EQ(len, write_buffer_->len());
+      ASSERT_EQ(0, memcmp(data, write_buffer_->data(), len));
+    }
+  }
+
+  void ClearWriteBuffer() {
+    write_buffer_.reset();
+  }
+
+  void SetWritable(size_t val) {
+    writable_ = val;
+  }
+
+  void FireWritableCb() {
+    NR_async_cb cb = cb_;
+    void *cb_arg = cb_arg_;
+
+    cb_ = nullptr;
+    cb_arg_ = nullptr;
+
+    cb(this, NR_ASYNC_WAIT_WRITE, cb_arg);
+  }
+
+  void SetReadBuffer(const uint8_t *data, size_t len) {
+    EXPECT_EQ(nullptr, write_buffer_.get());
+    read_buffer_.reset(new DataBuffer(data, len));
+  }
+
+  void ClearReadBuffer() {
+    read_buffer_.reset();
+  }
+
+  void SetReadable(size_t val) {
+    readable_ = val;
+  }
+
+  nr_socket *get_nr_socket() {
+    if (!self_) {
+      int r = nr_socket_create_int(this, vtbl(), &self_);
+      AddRef();
+      if (r)
+        return nullptr;
+    }
+
+    return self_;
+  }
+
+  nr_transport_addr *get_connect_addr() {
+    return &connect_addr_;
+  }
+
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(DummySocket);
+
+ private:
+  ~DummySocket() {}
+
+  DISALLOW_COPY_ASSIGN(DummySocket);
+
+  size_t writable_;  // Amount we allow someone to write.
+  UniquePtr<DataBuffer> write_buffer_;
+  size_t readable_;   // Amount we allow someone to read.
+  UniquePtr<DataBuffer> read_buffer_;
+
+  NR_async_cb cb_;
+  void *cb_arg_;
+  nr_socket *self_;
+
+  nr_transport_addr connect_addr_;
+};
+
+} //namespace mozilla
+
+#endif
+
diff --git a/media/mtransport/test/gtest_ringbuffer_dumper.h b/media/mtransport/test/gtest_ringbuffer_dumper.h
new file mode 100644
index 000000000..81eddbb2f
--- /dev/null
+++ b/media/mtransport/test/gtest_ringbuffer_dumper.h
@@ -0,0 +1,83 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: bcampen@mozilla.com
+
+#ifndef gtest_ringbuffer_dumper_h__
+#define gtest_ringbuffer_dumper_h__
+
+#include "mozilla/SyncRunnable.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+
+#include "mtransport_test_utils.h"
+#include "runnable_utils.h"
+#include "rlogconnector.h"
+
+using mozilla::RLogConnector;
+using mozilla::WrapRunnable;
+
+namespace test {
+class RingbufferDumper : public ::testing::EmptyTestEventListener {
+  public:
+    explicit RingbufferDumper(MtransportTestUtils* test_utils) :
+      test_utils_(test_utils)
+    {}
+
+    void ClearRingBuffer_s() {
+      RLogConnector::CreateInstance();
+      // Set limit to zero to clear the ringbuffer
+      RLogConnector::GetInstance()->SetLogLimit(0);
+      RLogConnector::GetInstance()->SetLogLimit(UINT32_MAX);
+    }
+
+    void DestroyRingBuffer_s() {
+      RLogConnector::DestroyInstance();
+    }
+
+    void DumpRingBuffer_s() {
+      std::deque<std::string> logs;
+      // Get an unlimited number of log lines, with no filter
+      RLogConnector::GetInstance()->GetAny(0, &logs);
+      for (auto l = logs.begin(); l != logs.end(); ++l) {
+        std::cout << *l << std::endl;
+      }
+      ClearRingBuffer_s();
+    }
+
+    virtual void OnTestStart(const ::testing::TestInfo& testInfo) {
+      mozilla::SyncRunnable::DispatchToThread(
+          test_utils_->sts_target(),
+          WrapRunnable(this, &RingbufferDumper::ClearRingBuffer_s));
+    }
+
+    virtual void OnTestEnd(const ::testing::TestInfo& testInfo) {
+      mozilla::SyncRunnable::DispatchToThread(
+          test_utils_->sts_target(),
+          WrapRunnable(this, &RingbufferDumper::DestroyRingBuffer_s));
+    }
+
+    // Called after a failed assertion or a SUCCEED() invocation.
+    virtual void OnTestPartResult(const ::testing::TestPartResult& testResult) {
+      if (testResult.failed()) {
+        // Dump (and empty) the RLogConnector
+        mozilla::SyncRunnable::DispatchToThread(
+            test_utils_->sts_target(),
+            WrapRunnable(this, &RingbufferDumper::DumpRingBuffer_s));
+      }
+    }
+
+  private:
+    MtransportTestUtils *test_utils_;
+};
+
+} // namespace test
+
+#endif // gtest_ringbuffer_dumper_h__
+
+
+
diff --git a/media/mtransport/test/gtest_utils.h b/media/mtransport/test/gtest_utils.h
new file mode 100644
index 000000000..263a3838c
--- /dev/null
+++ b/media/mtransport/test/gtest_utils.h
@@ -0,0 +1,203 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Utilities to wrap gtest, based on libjingle's gunit
+
+// Some sections of this code are under the following license:
+
+/*
+ * libjingle
+ * Copyright 2004--2008, Google Inc.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ *  1. Redistributions of source code must retain the above copyright notice,
+ *     this list of conditions and the following disclaimer.
+ *  2. Redistributions in binary form must reproduce the above copyright notice,
+ *     this list of conditions and the following disclaimer in the documentation
+ *     and/or other materials provided with the distribution.
+ *  3. The name of the author may not be used to endorse or promote products
+ *     derived from this software without specific prior written permission.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS OR IMPLIED
+ * WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO
+ * EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+ * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS;
+ * OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
+ * WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
+ * OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF
+ * ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+
+// Original author: ekr@rtfm.com
+#ifndef gtest_utils__h__
+#define gtest_utils__h__
+
+#include <iostream>
+
+#include "nspr.h"
+#include "prinrval.h"
+#include "prthread.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+
+#include "gtest_ringbuffer_dumper.h"
+#include "mtransport_test_utils.h"
+#include "nss.h"
+#include "ssl.h"
+
+extern "C" {
+#include "registry.h"
+#include "transport_addr.h"
+}
+
+// Wait up to timeout seconds for expression to be true
+#define WAIT(expression, timeout) \
+  do { \
+    for (PRIntervalTime start = PR_IntervalNow(); !(expression) && \
+           ! ((PR_IntervalNow() - start) > PR_MillisecondsToInterval(timeout));) { \
+      PR_Sleep(10); \
+    } \
+  } while(0)
+
+// Same as GTEST_WAIT, but stores the result in res. Used when
+// you also want the result of expression but wish to avoid
+// double evaluation.
+#define WAIT_(expression, timeout, res) \
+  do { \
+    for (PRIntervalTime start = PR_IntervalNow(); !(res = (expression)) && \
+           ! ((PR_IntervalNow() - start) > PR_MillisecondsToInterval(timeout));) { \
+      PR_Sleep(10); \
+    } \
+  } while(0)
+
+#define ASSERT_TRUE_WAIT(expression, timeout) \
+  do { \
+    bool res; \
+    WAIT_(expression, timeout, res); \
+    ASSERT_TRUE(res); \
+  } while(0)
+
+#define EXPECT_TRUE_WAIT(expression, timeout) \
+  do { \
+    bool res; \
+    WAIT_(expression, timeout, res); \
+    EXPECT_TRUE(res); \
+  } while(0)
+
+#define ASSERT_EQ_WAIT(expected, actual, timeout) \
+  do { \
+    WAIT(expected == actual, timeout); \
+    ASSERT_EQ(expected, actual); \
+  } while(0)
+
+using test::RingbufferDumper;
+
+class MtransportTest : public ::testing::Test {
+public:
+  MtransportTest()
+    : test_utils_(nullptr)
+    , dumper_(nullptr)
+  {
+  }
+
+  void SetUp() override {
+    test_utils_ = new MtransportTestUtils();
+    NSS_NoDB_Init(nullptr);
+    NSS_SetDomesticPolicy();
+
+    NR_reg_init(NR_REG_MODE_LOCAL);
+
+    // Attempt to load env vars used by tests.
+    GetEnvironment("TURN_SERVER_ADDRESS", turn_server_);
+    GetEnvironment("TURN_SERVER_USER", turn_user_);
+    GetEnvironment("TURN_SERVER_PASSWORD", turn_password_);
+    GetEnvironment("STUN_SERVER_ADDRESS", stun_server_address_);
+    GetEnvironment("STUN_SERVER_HOSTNAME", stun_server_hostname_);
+
+    std::string disable_non_local;
+    GetEnvironment("MOZ_DISABLE_NONLOCAL_CONNECTIONS", disable_non_local);
+    std::string upload_dir;
+    GetEnvironment("MOZ_UPLOAD_DIR", upload_dir);
+
+    if ((!disable_non_local.empty() && disable_non_local != "0") ||
+        !upload_dir.empty()) {
+      // We're assuming that MOZ_UPLOAD_DIR is only set on tbpl;
+      // MOZ_DISABLE_NONLOCAL_CONNECTIONS probably should be set when running the
+      // cpp unit-tests, but is not presently.
+      stun_server_address_ = "";
+      stun_server_hostname_ = "";
+      turn_server_ = "";
+    }
+
+    // Some tests are flaky and need to check if they're supposed to run.
+    webrtc_enabled_ = CheckEnvironmentFlag("MOZ_WEBRTC_TESTS");
+
+    ::testing::TestEventListeners& listeners =
+        ::testing::UnitTest::GetInstance()->listeners();
+
+    dumper_ = new RingbufferDumper(test_utils_);
+    listeners.Append(dumper_);
+  }
+
+  void TearDown() override {
+    ::testing::UnitTest::GetInstance()->listeners().Release(dumper_);
+    delete dumper_;
+    delete test_utils_;
+  }
+
+  void GetEnvironment(const char* aVar, std::string& out) {
+    char* value = getenv(aVar);
+    if (value) {
+      out = value;
+    }
+  }
+
+  bool CheckEnvironmentFlag(const char* aVar) {
+    std::string value;
+    GetEnvironment(aVar, value);
+    return value == "1";
+  }
+
+  bool WarnIfTurnNotConfigured() const {
+    bool configured =
+        !turn_server_.empty() &&
+        !turn_user_.empty() &&
+        !turn_password_.empty();
+
+    if (configured) {
+      nr_transport_addr addr;
+      if (nr_str_port_to_transport_addr(turn_server_.c_str(), 3478,
+                                        IPPROTO_UDP, &addr)) {
+        printf("Invalid TURN_SERVER_ADDRESS \"%s\". Only IP numbers supported.\n",
+               turn_server_.c_str());
+        configured = false;
+      }
+    } else {
+      printf(
+        "Set TURN_SERVER_ADDRESS, TURN_SERVER_USER, and TURN_SERVER_PASSWORD\n"
+        "environment variables to run this test\n");
+    }
+
+    return !configured;
+  }
+
+  MtransportTestUtils* test_utils_;
+  RingbufferDumper* dumper_;
+
+  std::string turn_server_;
+  std::string turn_user_;
+  std::string turn_password_;
+  std::string stun_server_address_;
+  std::string stun_server_hostname_;
+
+  bool webrtc_enabled_;
+};
+#endif
diff --git a/media/mtransport/test/ice_unittest.cpp b/media/mtransport/test/ice_unittest.cpp
new file mode 100644
index 000000000..0b3216353
--- /dev/null
+++ b/media/mtransport/test/ice_unittest.cpp
@@ -0,0 +1,3934 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: ekr@rtfm.com
+
+#include <algorithm>
+#include <deque>
+#include <iostream>
+#include <limits>
+#include <map>
+#include <string>
+#include <vector>
+
+#include "sigslot.h"
+
+#include "logging.h"
+#include "nspr.h"
+#include "nss.h"
+#include "ssl.h"
+
+#include "mozilla/Preferences.h"
+#include "nsThreadUtils.h"
+#include "nsXPCOM.h"
+
+#include "nricectxhandler.h"
+#include "nricemediastream.h"
+#include "nriceresolverfake.h"
+#include "nriceresolver.h"
+#include "nrinterfaceprioritizer.h"
+#include "gtest_ringbuffer_dumper.h"
+#include "rlogconnector.h"
+#include "runnable_utils.h"
+#include "stunserver.h"
+#include "nr_socket_prsock.h"
+#include "test_nr_socket.h"
+#include "ice_ctx.h"
+#include "stun_socket_filter.h"
+#include "mozilla/net/DNS.h"
+
+#include "ice_ctx.h"
+#include "ice_peer_ctx.h"
+#include "ice_media_stream.h"
+
+extern "C" {
+#include "async_timer.h"
+#include "r_data.h"
+#include "util.h"
+#include "r_time.h"
+}
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+
+using namespace mozilla;
+
+static unsigned int kDefaultTimeout = 7000;
+
+//TODO(nils@mozilla.com): This should get replaced with some non-external
+//solution like discussed in bug 860775.
+const std::string kDefaultStunServerHostname(
+    (char *)"global.stun.twilio.com");
+const std::string kBogusStunServerHostname(
+    (char *)"stun-server-nonexistent.invalid");
+const uint16_t kDefaultStunServerPort=3478;
+const std::string kBogusIceCandidate(
+    (char *)"candidate:0 2 UDP 2113601790 192.168.178.20 50769 typ");
+
+const std::string kUnreachableHostIceCandidate(
+    (char *)"candidate:0 1 UDP 2113601790 192.168.178.20 50769 typ host");
+
+namespace {
+
+// DNS resolution helper code
+static std::string
+Resolve(const std::string& fqdn, int address_family)
+{
+  struct addrinfo hints;
+  memset(&hints, 0, sizeof(hints));
+  hints.ai_family = address_family;
+  hints.ai_protocol = IPPROTO_UDP;
+  struct addrinfo *res;
+  int err = getaddrinfo(fqdn.c_str(), nullptr, &hints, &res);
+  if (err) {
+    std::cerr << "Error in getaddrinfo: " << err << std::endl;
+    return "";
+  }
+
+  char str_addr[64] = {0};
+  switch (res->ai_family) {
+    case AF_INET:
+      inet_ntop(
+          AF_INET,
+          &reinterpret_cast<struct sockaddr_in*>(res->ai_addr)->sin_addr,
+          str_addr,
+          sizeof(str_addr));
+      break;
+    case AF_INET6:
+      inet_ntop(
+          AF_INET6,
+          &reinterpret_cast<struct sockaddr_in6*>(res->ai_addr)->sin6_addr,
+          str_addr,
+          sizeof(str_addr));
+      break;
+    default:
+      std::cerr << "Got unexpected address family in DNS lookup: "
+                << res->ai_family << std::endl;
+      freeaddrinfo(res);
+      return "";
+  }
+
+  if (!strlen(str_addr)) {
+    std::cerr << "inet_ntop failed" << std::endl;
+  }
+
+  freeaddrinfo(res);
+  return str_addr;
+}
+
+class StunTest : public MtransportTest {
+public:
+  StunTest() : MtransportTest() {
+    stun_server_hostname_ = kDefaultStunServerHostname;
+  }
+
+  void SetUp() override {
+    MtransportTest::SetUp();
+
+    // If only a STUN server FQDN was provided, look up its IP address for the
+    // address-only tests.
+    if (stun_server_address_.empty() && !stun_server_hostname_.empty()) {
+      stun_server_address_ = Resolve(stun_server_hostname_, AF_INET);
+    }
+
+    // Make sure NrIceCtx is in a testable state.
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableNM(&NrIceCtx::internal_DeinitializeGlobal),
+        NS_DISPATCH_SYNC);
+
+    // NB: NrIceCtx::internal_DeinitializeGlobal destroys the RLogConnector
+    // singleton.
+    RLogConnector::CreateInstance();
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableNM(&TestStunServer::GetInstance, AF_INET),
+                       NS_DISPATCH_SYNC);
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableNM(&TestStunServer::GetInstance, AF_INET6),
+                       NS_DISPATCH_SYNC);
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableNM(&TestStunTcpServer::GetInstance, AF_INET),
+                       NS_DISPATCH_SYNC);
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableNM(&TestStunTcpServer::GetInstance, AF_INET6),
+                       NS_DISPATCH_SYNC);
+  }
+
+  void TearDown() override {
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableNM(&NrIceCtx::internal_DeinitializeGlobal),
+        NS_DISPATCH_SYNC);
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableNM(&TestStunServer::ShutdownInstance), NS_DISPATCH_SYNC);
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableNM(&TestStunTcpServer::ShutdownInstance), NS_DISPATCH_SYNC);
+
+    RLogConnector::DestroyInstance();
+
+    MtransportTest::TearDown();
+  }
+};
+
+enum TrickleMode { TRICKLE_NONE, TRICKLE_SIMULATE, TRICKLE_REAL };
+
+enum ConsentStatus { CONSENT_FRESH, CONSENT_STALE, CONSENT_EXPIRED};
+
+const unsigned int ICE_TEST_PEER_OFFERER = (1 << 0);
+const unsigned int ICE_TEST_PEER_ALLOW_LOOPBACK = (1 << 1);
+const unsigned int ICE_TEST_PEER_ENABLED_TCP = (1 << 2);
+const unsigned int ICE_TEST_PEER_ALLOW_LINK_LOCAL = (1 << 3);
+
+typedef std::string (*CandidateFilter)(const std::string& candidate);
+
+std::vector<std::string> split(const std::string &s, char delim) {
+  std::vector<std::string> elems;
+  std::stringstream ss(s);
+  std::string item;
+  while (std::getline(ss, item, delim)) {
+    elems.push_back(item);
+  }
+  return elems;
+}
+
+static std::string IsSrflxCandidate(const std::string& candidate) {
+  std::vector<std::string> tokens = split(candidate, ' ');
+  if ((tokens.at(6) == "typ") && (tokens.at(7) == "srflx")) {
+    return candidate;
+  }
+  return std::string();
+}
+
+static std::string IsRelayCandidate(const std::string& candidate) {
+  if (candidate.find("typ relay") != std::string::npos) {
+    return candidate;
+  }
+  return std::string();
+}
+
+static std::string IsTcpCandidate(const std::string& candidate) {
+  if (candidate.find("TCP") != std::string::npos) {
+    return candidate;
+  }
+  return std::string();
+}
+
+static std::string IsTcpSoCandidate(const std::string& candidate) {
+  if (candidate.find("tcptype so") != std::string::npos) {
+      return candidate;
+    }
+  return std::string();
+}
+
+static std::string IsLoopbackCandidate(const std::string& candidate) {
+  if (candidate.find("127.0.0.") != std::string::npos) {
+    return candidate;
+  }
+  return std::string();
+}
+
+static std::string IsIpv4Candidate(const std::string& candidate) {
+  std::vector<std::string> tokens = split(candidate, ' ');
+  if (tokens.at(4).find(":") == std::string::npos) {
+    return candidate;
+  }
+  return std::string();
+}
+
+static std::string SabotageHostCandidateAndDropReflexive(
+    const std::string& candidate) {
+  if (candidate.find("typ srflx") != std::string::npos) {
+    return std::string();
+  }
+
+  if (candidate.find("typ host") != std::string::npos) {
+    return kUnreachableHostIceCandidate;
+  }
+
+  return candidate;
+}
+
+bool ContainsSucceededPair(const std::vector<NrIceCandidatePair>& pairs) {
+  for (size_t i = 0; i < pairs.size(); ++i) {
+    if (pairs[i].state == NrIceCandidatePair::STATE_SUCCEEDED) {
+      return true;
+    }
+  }
+  return false;
+}
+
+// Note: Does not correspond to any notion of prioritization; this is just
+// so we can use stl containers/algorithms that need a comparator
+bool operator<(const NrIceCandidate& lhs,
+               const NrIceCandidate& rhs) {
+  if (lhs.cand_addr.host == rhs.cand_addr.host) {
+    if (lhs.cand_addr.port == rhs.cand_addr.port) {
+      if (lhs.cand_addr.transport == rhs.cand_addr.transport) {
+        if (lhs.type == rhs.type) {
+          return lhs.tcp_type < rhs.tcp_type;
+        }
+        return lhs.type < rhs.type;
+      }
+      return lhs.cand_addr.transport < rhs.cand_addr.transport;
+    }
+    return lhs.cand_addr.port < rhs.cand_addr.port;
+  }
+  return lhs.cand_addr.host < rhs.cand_addr.host;
+}
+
+bool operator==(const NrIceCandidate& lhs,
+                const NrIceCandidate& rhs) {
+  return !((lhs < rhs) || (rhs < lhs));
+}
+
+class IceCandidatePairCompare {
+  public:
+    bool operator()(const NrIceCandidatePair& lhs,
+                    const NrIceCandidatePair& rhs) const {
+      if (lhs.priority == rhs.priority) {
+        if (lhs.local == rhs.local) {
+          if (lhs.remote == rhs.remote) {
+            return lhs.codeword < rhs.codeword;
+          }
+          return lhs.remote < rhs.remote;
+        }
+        return lhs.local < rhs.local;
+      }
+      return lhs.priority < rhs.priority;
+    }
+};
+
+class IceTestPeer;
+
+class SchedulableTrickleCandidate {
+  public:
+    SchedulableTrickleCandidate(IceTestPeer *peer,
+                                size_t stream,
+                                const std::string &candidate,
+                                MtransportTestUtils* utils) :
+      peer_(peer),
+      stream_(stream),
+      candidate_(candidate),
+      timer_handle_(nullptr),
+      test_utils_(utils) {
+    }
+
+    ~SchedulableTrickleCandidate() {
+      if (timer_handle_)
+        NR_async_timer_cancel(timer_handle_);
+    }
+
+    void Schedule(unsigned int ms) {
+      test_utils_->sts_target()->Dispatch(
+          WrapRunnable(this, &SchedulableTrickleCandidate::Schedule_s, ms),
+          NS_DISPATCH_SYNC);
+    }
+
+    void Schedule_s(unsigned int ms) {
+      MOZ_ASSERT(!timer_handle_);
+      NR_ASYNC_TIMER_SET(ms, Trickle_cb, this, &timer_handle_);
+    }
+
+    static void Trickle_cb(NR_SOCKET s, int how, void *cb_arg) {
+      static_cast<SchedulableTrickleCandidate*>(cb_arg)->Trickle();
+    }
+
+    void Trickle();
+
+    std::string& Candidate() {
+      return candidate_;
+    }
+
+    const std::string& Candidate() const {
+      return candidate_;
+    }
+
+    size_t Stream() const {
+      return stream_;
+    }
+
+    bool IsHost() const {
+      return candidate_.find("typ host") != std::string::npos;
+    }
+
+    bool IsReflexive() const {
+      return candidate_.find("typ srflx") != std::string::npos;
+    }
+
+    bool IsRelay() const {
+      return candidate_.find("typ relay") != std::string::npos;
+    }
+
+  private:
+    IceTestPeer *peer_;
+    size_t stream_;
+    std::string candidate_;
+    void *timer_handle_;
+    MtransportTestUtils* test_utils_;
+
+    DISALLOW_COPY_ASSIGN(SchedulableTrickleCandidate);
+};
+
+class IceTestPeer : public sigslot::has_slots<> {
+ public:
+  // TODO(ekr@rtfm.com): Convert to flags when NrIceCtx::Create() does.
+  // Bug 1193437.
+  IceTestPeer(const std::string& name, MtransportTestUtils* utils,
+              bool offerer,
+              bool allow_loopback = false, bool enable_tcp = true,
+              bool allow_link_local = false,
+              NrIceCtx::Policy ice_policy = NrIceCtx::ICE_POLICY_ALL) :
+      name_(name),
+      ice_ctx_(NrIceCtxHandler::Create(name, offerer, allow_loopback,
+                                       enable_tcp, allow_link_local,
+                                       ice_policy)),
+      candidates_(),
+      shutting_down_(false),
+      gathering_complete_(false),
+      ready_ct_(0),
+      ice_connected_(false),
+      ice_failed_(false),
+      ice_reached_checking_(false),
+      received_(0),
+      sent_(0),
+      fake_resolver_(),
+      dns_resolver_(new NrIceResolver()),
+      remote_(nullptr),
+      candidate_filter_(nullptr),
+      expected_local_type_(NrIceCandidate::ICE_HOST),
+      expected_local_transport_(kNrIceTransportUdp),
+      expected_remote_type_(NrIceCandidate::ICE_HOST),
+      trickle_mode_(TRICKLE_NONE),
+      trickled_(0),
+      simulate_ice_lite_(false),
+      nat_(new TestNat),
+      test_utils_(utils) {
+    ice_ctx_->ctx()->SignalGatheringStateChange.connect(
+        this,
+        &IceTestPeer::GatheringStateChange);
+    ice_ctx_->ctx()->SignalConnectionStateChange.connect(
+        this,
+        &IceTestPeer::ConnectionStateChange);
+
+    consent_timestamp_.tv_sec = 0;
+    consent_timestamp_.tv_usec = 0;
+    int r = ice_ctx_->ctx()->SetNat(nat_);
+    (void)r;
+    MOZ_ASSERT(!r);
+  }
+
+  ~IceTestPeer() {
+    test_utils_->sts_target()->Dispatch(WrapRunnable(this,
+                                                    &IceTestPeer::Shutdown),
+        NS_DISPATCH_SYNC);
+
+    // Give the ICE destruction callback time to fire before
+    // we destroy the resolver.
+    PR_Sleep(1000);
+  }
+
+  void AddStream_s(int components) {
+    char name[100];
+    snprintf(name, sizeof(name), "%s:stream%d", name_.c_str(),
+             (int)ice_ctx_->ctx()->GetStreamCount());
+
+    RefPtr<NrIceMediaStream> stream =
+        ice_ctx_->CreateStream(static_cast<char *>(name), components);
+    ice_ctx_->ctx()->SetStream(ice_ctx_->ctx()->GetStreamCount(), stream);
+
+    ASSERT_TRUE(stream);
+    stream->SignalCandidate.connect(this, &IceTestPeer::CandidateInitialized);
+    stream->SignalReady.connect(this, &IceTestPeer::StreamReady);
+    stream->SignalFailed.connect(this, &IceTestPeer::StreamFailed);
+    stream->SignalPacketReceived.connect(this, &IceTestPeer::PacketReceived);
+  }
+
+  void AddStream(int components)
+  {
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(this, &IceTestPeer::AddStream_s, components),
+        NS_DISPATCH_SYNC);
+  }
+
+  void RemoveStream_s(size_t index) {
+    ice_ctx_->ctx()->SetStream(index, nullptr);
+  }
+
+  void RemoveStream(size_t index) {
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(this, &IceTestPeer::RemoveStream_s, index),
+        NS_DISPATCH_SYNC);
+  }
+
+  void SetStunServer(const std::string addr, uint16_t port,
+                     const char* transport = kNrIceTransportUdp) {
+    if (addr.empty()) {
+      // Happens when MOZ_DISABLE_NONLOCAL_CONNECTIONS is set
+      return;
+    }
+
+    std::vector<NrIceStunServer> stun_servers;
+    UniquePtr<NrIceStunServer> server(NrIceStunServer::Create(
+        addr, port, transport));
+    stun_servers.push_back(*server);
+    SetStunServers(stun_servers);
+  }
+
+  void SetStunServers(const std::vector<NrIceStunServer> &servers) {
+    ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetStunServers(servers)));
+  }
+
+  void UseTestStunServer() {
+    SetStunServer(TestStunServer::GetInstance(AF_INET)->addr(),
+                  TestStunServer::GetInstance(AF_INET)->port());
+  }
+
+  void SetTurnServer(const std::string addr, uint16_t port,
+                     const std::string username,
+                     const std::string password,
+                     const char* transport) {
+    std::vector<unsigned char> password_vec(password.begin(), password.end());
+    SetTurnServer(addr, port, username, password_vec, transport);
+  }
+
+
+  void SetTurnServer(const std::string addr, uint16_t port,
+                     const std::string username,
+                     const std::vector<unsigned char> password,
+                     const char* transport) {
+    std::vector<NrIceTurnServer> turn_servers;
+    UniquePtr<NrIceTurnServer> server(NrIceTurnServer::Create(
+        addr, port, username, password, transport));
+    turn_servers.push_back(*server);
+    ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetTurnServers(turn_servers)));
+  }
+
+  void SetTurnServers(const std::vector<NrIceTurnServer> servers) {
+    ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetTurnServers(servers)));
+  }
+
+  void SetFakeResolver(const std::string& ip,
+                       const std::string& fqdn) {
+    ASSERT_TRUE(NS_SUCCEEDED(dns_resolver_->Init()));
+    if (!ip.empty() && !fqdn.empty()) {
+      PRNetAddr addr;
+      PRStatus status = PR_StringToNetAddr(ip.c_str(), &addr);
+      addr.inet.port = kDefaultStunServerPort;
+      ASSERT_EQ(PR_SUCCESS, status);
+      fake_resolver_.SetAddr(fqdn, addr);
+    }
+    ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetResolver(
+        fake_resolver_.AllocateResolver())));
+  }
+
+  void SetDNSResolver() {
+    ASSERT_TRUE(NS_SUCCEEDED(dns_resolver_->Init()));
+    ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetResolver(
+        dns_resolver_->AllocateResolver())));
+  }
+
+  void Gather(bool default_route_only = false) {
+    nsresult res;
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableRet(&res,
+                        ice_ctx_->ctx(),
+                        &NrIceCtx::StartGathering,
+                        default_route_only,
+                        false),
+        NS_DISPATCH_SYNC);
+
+    ASSERT_TRUE(NS_SUCCEEDED(res));
+  }
+
+  void UseNat() {
+    nat_->enabled_ = true;
+  }
+
+  void SetTimerDivider(int div) {
+    ice_ctx_->ctx()->internal_SetTimerAccelarator(div);
+  }
+
+  void SetStunResponseDelay(uint32_t delay) {
+    nat_->delay_stun_resp_ms_ = delay;
+  }
+
+  void SetFilteringType(TestNat::NatBehavior type) {
+    MOZ_ASSERT(!nat_->has_port_mappings());
+    nat_->filtering_type_ = type;
+  }
+
+  void SetMappingType(TestNat::NatBehavior type) {
+    MOZ_ASSERT(!nat_->has_port_mappings());
+    nat_->mapping_type_ = type;
+  }
+
+  void SetBlockUdp(bool block) {
+    MOZ_ASSERT(!nat_->has_port_mappings());
+    nat_->block_udp_ = block;
+  }
+
+  void SetBlockStun(bool block) {
+    nat_->block_stun_ = block;
+  }
+
+  // Get various pieces of state
+  std::vector<std::string> GetGlobalAttributes() {
+    std::vector<std::string> attrs(ice_ctx_->ctx()->GetGlobalAttributes());
+    if (simulate_ice_lite_) {
+      attrs.push_back("ice-lite");
+    }
+    return attrs;
+  }
+
+  std::vector<std::string> GetCandidates(size_t stream) {
+    std::vector<std::string> v;
+
+    RUN_ON_THREAD(
+        test_utils_->sts_target(),
+        WrapRunnableRet(&v, this, &IceTestPeer::GetCandidates_s, stream));
+
+    return v;
+  }
+
+  std::string FilterCandidate(const std::string& candidate) {
+    if (candidate_filter_) {
+      return candidate_filter_(candidate);
+    }
+    return candidate;
+  }
+
+  std::vector<std::string> GetCandidates_s(size_t stream) {
+    std::vector<std::string> candidates;
+
+    if (stream >= ice_ctx_->ctx()->GetStreamCount() ||
+        !ice_ctx_->ctx()->GetStream(stream)) {
+      EXPECT_TRUE(false) << "No such stream " << stream;
+      return candidates;
+    }
+
+    std::vector<std::string> candidates_in =
+      ice_ctx_->ctx()->GetStream(stream)->GetCandidates();
+
+    for (size_t i=0; i < candidates_in.size(); i++) {
+      std::string candidate(FilterCandidate(candidates_in[i]));
+      if (!candidate.empty()) {
+        std::cerr << name_ << " Returning candidate: "
+                           << candidate << std::endl;
+        candidates.push_back(candidate);
+      }
+    }
+
+    return candidates;
+  }
+
+  void SetExpectedTypes(NrIceCandidate::Type local,
+                        NrIceCandidate::Type remote,
+                        std::string local_transport = kNrIceTransportUdp) {
+    expected_local_type_ = local;
+    expected_local_transport_ = local_transport;
+    expected_remote_type_ = remote;
+  }
+
+  void SetExpectedRemoteCandidateAddr(const std::string& addr) {
+    expected_remote_addr_ = addr;
+  }
+
+  int GetCandidatesPrivateIpv4Range(size_t stream) {
+    std::vector<std::string> candidates = GetCandidates(stream);
+
+    int host_net = 0;
+    for (auto c : candidates) {
+      if (c.find("typ host") != std::string::npos) {
+        nr_transport_addr addr;
+        std::vector<std::string> tokens = split(c, ' ');
+        int r = nr_str_port_to_transport_addr(tokens.at(4).c_str(), 0, IPPROTO_UDP, &addr);
+        MOZ_ASSERT(!r);
+        if (!r && (addr.ip_version == NR_IPV4)) {
+          int n = nr_transport_addr_get_private_addr_range(&addr);
+          if (n) {
+            if (host_net) {
+              // TODO: add support for multiple private interfaces
+              std::cerr << "This test doesn't support multiple private interfaces";
+              return -1;
+            }
+            host_net = n;
+          }
+        }
+      }
+    }
+    return host_net;
+  }
+
+  bool gathering_complete() { return gathering_complete_; }
+  int ready_ct() { return ready_ct_; }
+  bool is_ready_s(size_t stream) {
+    RefPtr<NrIceMediaStream> media_stream = ice_ctx_->ctx()->GetStream(stream);
+    if (!media_stream) {
+      EXPECT_TRUE(false) << "No such stream " << stream;
+      return false;
+    }
+    return media_stream->state() == NrIceMediaStream::ICE_OPEN;
+  }
+  bool is_ready(size_t stream)
+  {
+    bool result;
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableRet(&result, this, &IceTestPeer::is_ready_s, stream),
+        NS_DISPATCH_SYNC);
+    return result;
+  }
+  bool ice_connected() { return ice_connected_; }
+  bool ice_failed() { return ice_failed_; }
+  bool ice_reached_checking() { return ice_reached_checking_; }
+  size_t received() { return received_; }
+  size_t sent() { return sent_; }
+
+
+  void RestartIce() {
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(this,
+                     &IceTestPeer::RestartIce_s,
+                     ice_ctx_->CreateCtx()),
+        NS_DISPATCH_SYNC);
+  }
+
+
+  void RestartIce_s(RefPtr<NrIceCtx> new_ctx) {
+    ice_ctx_->BeginIceRestart(new_ctx);
+
+    // set signals for the newly restarted ctx
+    ice_ctx_->ctx()->SignalGatheringStateChange.connect(
+        this,
+        &IceTestPeer::GatheringStateChange);
+    ice_ctx_->ctx()->SignalConnectionStateChange.connect(
+        this,
+        &IceTestPeer::ConnectionStateChange);
+
+    // take care of some local bookkeeping
+    ready_ct_ = 0;
+    gathering_complete_ = false;
+    ice_connected_ = false;
+    ice_failed_ = false;
+    ice_reached_checking_ = false;
+    remote_ = nullptr;
+  }
+
+
+  void FinalizeIceRestart() {
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(this, &IceTestPeer::FinalizeIceRestart_s),
+        NS_DISPATCH_SYNC);
+  }
+
+
+  void FinalizeIceRestart_s() {
+    ice_ctx_->FinalizeIceRestart();
+  }
+
+
+  void RollbackIceRestart() {
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(this, &IceTestPeer::RollbackIceRestart_s),
+        NS_DISPATCH_SYNC);
+  }
+
+
+  void RollbackIceRestart_s() {
+    ice_ctx_->RollbackIceRestart();
+  }
+
+
+  // Start connecting to another peer
+  void Connect_s(IceTestPeer *remote, TrickleMode trickle_mode,
+                 bool start = true) {
+    nsresult res;
+
+    remote_ = remote;
+
+    trickle_mode_ = trickle_mode;
+    ice_connected_ = false;
+    ice_failed_ = false;
+    ice_reached_checking_ = false;
+    res = ice_ctx_->ctx()->ParseGlobalAttributes(remote->GetGlobalAttributes());
+    ASSERT_TRUE(NS_SUCCEEDED(res));
+
+    if (trickle_mode == TRICKLE_NONE ||
+        trickle_mode == TRICKLE_REAL) {
+      for (size_t i=0; i<ice_ctx_->ctx()->GetStreamCount(); ++i) {
+        RefPtr<NrIceMediaStream> aStream = ice_ctx_->ctx()->GetStream(i);
+        if (!aStream || aStream->HasParsedAttributes()) {
+          continue;
+        }
+        std::vector<std::string> candidates =
+            remote->GetCandidates(i);
+
+        for (size_t j=0; j<candidates.size(); ++j) {
+          std::cerr << name_ << " Adding remote candidate: " + candidates[j] << std::endl;
+        }
+        res = aStream->ParseAttributes(candidates);
+        ASSERT_TRUE(NS_SUCCEEDED(res));
+      }
+    } else {
+      // Parse empty attributes and then trickle them out later
+      for (size_t i=0; i<ice_ctx_->ctx()->GetStreamCount(); ++i) {
+        RefPtr<NrIceMediaStream> aStream = ice_ctx_->ctx()->GetStream(i);
+        if (!aStream || aStream->HasParsedAttributes()) {
+          continue;
+        }
+        std::vector<std::string> empty_attrs;
+        std::cout << "Calling ParseAttributes on stream " << i << std::endl;
+        res = aStream->ParseAttributes(empty_attrs);
+        ASSERT_TRUE(NS_SUCCEEDED(res));
+      }
+    }
+
+    if (start) {
+      // Now start checks
+      res = ice_ctx_->ctx()->StartChecks();
+      ASSERT_TRUE(NS_SUCCEEDED(res));
+    }
+  }
+
+  void Connect(IceTestPeer *remote, TrickleMode trickle_mode,
+               bool start = true) {
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(
+            this, &IceTestPeer::Connect_s, remote, trickle_mode, start),
+        NS_DISPATCH_SYNC);
+  }
+
+  void SimulateTrickle(size_t stream) {
+    std::cerr << name_ << " Doing trickle for stream " << stream << std::endl;
+    // If we are in trickle deferred mode, now trickle in the candidates
+    // for |stream|
+
+    // We should be safe here since stream changes happen on STS thread.
+    ASSERT_GT(remote_->ice_ctx_->ctx()->GetStreamCount(), stream);
+    ASSERT_TRUE(remote_->ice_ctx_->ctx()->GetStream(stream).get());
+
+    std::vector<SchedulableTrickleCandidate*>& candidates =
+      ControlTrickle(stream);
+
+    for (auto i = candidates.begin(); i != candidates.end(); ++i) {
+      (*i)->Schedule(0);
+    }
+  }
+
+  // Allows test case to completely control when/if candidates are trickled
+  // (test could also do things like insert extra trickle candidates, or
+  // change existing ones, or insert duplicates, really anything is fair game)
+  std::vector<SchedulableTrickleCandidate*>& ControlTrickle(size_t stream) {
+    std::cerr << "Doing controlled trickle for stream " << stream << std::endl;
+
+    std::vector<std::string> candidates =
+      remote_->GetCandidates(stream);
+
+    for (size_t j=0; j<candidates.size(); j++) {
+      controlled_trickle_candidates_[stream].push_back(
+          new SchedulableTrickleCandidate(
+              this, stream, candidates[j], test_utils_));
+    }
+
+    return controlled_trickle_candidates_[stream];
+  }
+
+  nsresult TrickleCandidate_s(const std::string &candidate, size_t stream) {
+    if (!ice_ctx_->ctx()->GetStream(stream)) {
+      // stream might have gone away before the trickle timer popped
+      return NS_OK;
+    }
+    return ice_ctx_->ctx()->GetStream(stream)->ParseTrickleCandidate(candidate);
+  }
+
+  void DumpCandidate(std::string which, const NrIceCandidate& cand) {
+    std::string type;
+    std::string tcp_type;
+
+    std::string addr;
+    int port;
+
+    if (which.find("Remote") != std::string::npos) {
+      addr = cand.cand_addr.host;
+      port = cand.cand_addr.port;
+    }
+    else {
+      addr = cand.local_addr.host;
+      port = cand.local_addr.port;
+    }
+    switch(cand.type) {
+      case NrIceCandidate::ICE_HOST:
+        type = "host";
+        break;
+      case NrIceCandidate::ICE_SERVER_REFLEXIVE:
+        type = "srflx";
+        break;
+      case NrIceCandidate::ICE_PEER_REFLEXIVE:
+        type = "prflx";
+        break;
+      case NrIceCandidate::ICE_RELAYED:
+        type = "relay";
+        if (which.find("Local") != std::string::npos) {
+          type += "(" + cand.local_addr.transport + ")";
+        }
+        break;
+      default:
+        FAIL();
+    };
+
+    switch(cand.tcp_type) {
+      case NrIceCandidate::ICE_NONE:
+        break;
+      case NrIceCandidate::ICE_ACTIVE:
+        tcp_type = " tcptype=active";
+        break;
+      case NrIceCandidate::ICE_PASSIVE:
+        tcp_type = " tcptype=passive";
+        break;
+      case NrIceCandidate::ICE_SO:
+        tcp_type = " tcptype=so";
+        break;
+      default:
+        FAIL();
+    };
+
+
+    std::cerr << which
+              << " --> "
+              << type
+              << " "
+              << addr
+              << ":"
+              << port
+              << "/"
+              << cand.cand_addr.transport
+              << tcp_type
+              << " codeword="
+              << cand.codeword
+              << std::endl;
+  }
+
+  void DumpAndCheckActiveCandidates_s() {
+    std::cerr << name_ << " Active candidates:" << std::endl;
+    for (size_t i=0; i < ice_ctx_->ctx()->GetStreamCount(); ++i) {
+      if (!ice_ctx_->ctx()->GetStream(i)) {
+        continue;
+      }
+
+      for (size_t j=0; j < ice_ctx_->ctx()->GetStream(i)->components(); ++j) {
+        std::cerr << name_ << " Stream " << i
+                           << " component " << j+1 << std::endl;
+
+        UniquePtr<NrIceCandidate> local;
+        UniquePtr<NrIceCandidate> remote;
+
+        nsresult res = ice_ctx_->ctx()->GetStream(i)->GetActivePair(j+1,
+                                                                    &local,
+                                                                    &remote);
+        if (res == NS_ERROR_NOT_AVAILABLE) {
+          std::cerr << "Component unpaired or disabled." << std::endl;
+        } else {
+          ASSERT_TRUE(NS_SUCCEEDED(res));
+          DumpCandidate("Local  ", *local);
+          /* Depending on timing, and the whims of the network
+           * stack/configuration we're running on top of, prflx is always a
+           * possibility. */
+          if (expected_local_type_ == NrIceCandidate::ICE_HOST) {
+            ASSERT_NE(NrIceCandidate::ICE_SERVER_REFLEXIVE, local->type);
+            ASSERT_NE(NrIceCandidate::ICE_RELAYED, local->type);
+          } else {
+            ASSERT_EQ(expected_local_type_, local->type);
+          }
+          ASSERT_EQ(expected_local_transport_, local->local_addr.transport);
+          DumpCandidate("Remote ", *remote);
+          /* Depending on timing, and the whims of the network
+           * stack/configuration we're running on top of, prflx is always a
+           * possibility. */
+          if (expected_remote_type_ == NrIceCandidate::ICE_HOST) {
+            ASSERT_NE(NrIceCandidate::ICE_SERVER_REFLEXIVE, remote->type);
+            ASSERT_NE(NrIceCandidate::ICE_RELAYED, remote->type);
+          } else {
+            ASSERT_EQ(expected_remote_type_, remote->type);
+          }
+          if (!expected_remote_addr_.empty()) {
+            ASSERT_EQ(expected_remote_addr_, remote->cand_addr.host);
+          }
+        }
+      }
+    }
+  }
+
+  void DumpAndCheckActiveCandidates() {
+    test_utils_->sts_target()->Dispatch(
+      WrapRunnable(this, &IceTestPeer::DumpAndCheckActiveCandidates_s),
+      NS_DISPATCH_SYNC);
+  }
+
+  void Close() {
+    test_utils_->sts_target()->Dispatch(
+      WrapRunnable(ice_ctx_->ctx(), &NrIceCtx::destroy_peer_ctx),
+      NS_DISPATCH_SYNC);
+  }
+
+  void Shutdown() {
+    std::cerr << name_ << " Shutdown" << std::endl;
+    shutting_down_ = true;
+    for (auto s = controlled_trickle_candidates_.begin();
+         s != controlled_trickle_candidates_.end();
+         ++s) {
+      for (auto cand = s->second.begin(); cand != s->second.end(); ++cand) {
+        delete *cand;
+      }
+    }
+
+    ice_ctx_ = nullptr;
+
+    if (remote_) {
+      remote_->UnsetRemote();
+      remote_ = nullptr;
+    }
+  }
+
+  void UnsetRemote()
+  {
+    remote_ = nullptr;
+  }
+
+  void StartChecks() {
+    nsresult res;
+
+    // Now start checks
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableRet(&res, ice_ctx_->ctx(), &NrIceCtx::StartChecks),
+        NS_DISPATCH_SYNC);
+    ASSERT_TRUE(NS_SUCCEEDED(res));
+  }
+
+  // Handle events
+  void GatheringStateChange(NrIceCtx* ctx,
+                            NrIceCtx::GatheringState state) {
+    if (shutting_down_) {
+      return;
+    }
+    if (state != NrIceCtx::ICE_CTX_GATHER_COMPLETE) {
+      return;
+    }
+
+    std::cerr << name_ << " Gathering complete" << std::endl;
+    gathering_complete_ = true;
+
+    std::cerr << name_ << " CANDIDATES:" << std::endl;
+    for (size_t i=0; i<ice_ctx_->ctx()->GetStreamCount(); ++i) {
+      std::cerr << "Stream " << name_ << std::endl;
+
+      if (!ice_ctx_->ctx()->GetStream(i)) {
+        std::cerr << "DISABLED" << std::endl;
+        continue;
+      }
+
+      std::vector<std::string> candidates =
+          ice_ctx_->ctx()->GetStream(i)->GetCandidates();
+
+      for(size_t j=0; j<candidates.size(); ++j) {
+        std::cerr << candidates[j] << std::endl;
+      }
+    }
+    std::cerr << std::endl;
+
+  }
+
+  void CandidateInitialized(NrIceMediaStream *stream, const std::string &raw_candidate) {
+    std::string candidate(FilterCandidate(raw_candidate));
+    if (candidate.empty()) {
+      return;
+    }
+    std::cerr << "Candidate for stream " << stream->name() << " initialized: "
+      << candidate << std::endl;
+    candidates_[stream->name()].push_back(candidate);
+
+    // If we are connected, then try to trickle to the other side.
+    if (remote_ && remote_->remote_ && (trickle_mode_ != TRICKLE_SIMULATE)) {
+      // first, find the index of the stream we've been given so
+      // we can get the corresponding stream on the remote side
+      for (size_t i=0; i<ice_ctx_->ctx()->GetStreamCount(); ++i) {
+        if (ice_ctx_->ctx()->GetStream(i) == stream) {
+          RefPtr<NrIceCtx> ctx = remote_->ice_ctx_->ctx();
+          ASSERT_GT(ctx->GetStreamCount(), i);
+          nsresult res = ctx->GetStream(i)->ParseTrickleCandidate(candidate);
+          ASSERT_TRUE(NS_SUCCEEDED(res));
+          ++trickled_;
+          return;
+        }
+      }
+      ADD_FAILURE() << "No matching stream found for " << stream;
+    }
+  }
+
+  nsresult GetCandidatePairs_s(size_t stream_index,
+                               std::vector<NrIceCandidatePair>* pairs)
+  {
+    MOZ_ASSERT(pairs);
+    if (stream_index >= ice_ctx_->ctx()->GetStreamCount() ||
+        !ice_ctx_->ctx()->GetStream(stream_index)) {
+      // Is there a better error for "no such index"?
+      ADD_FAILURE() << "No such media stream index: " << stream_index;
+      return NS_ERROR_INVALID_ARG;
+    }
+
+    return ice_ctx_->ctx()->GetStream(stream_index)->GetCandidatePairs(pairs);
+  }
+
+  nsresult GetCandidatePairs(size_t stream_index,
+                             std::vector<NrIceCandidatePair>* pairs) {
+    nsresult v;
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableRet(&v, this,
+                        &IceTestPeer::GetCandidatePairs_s,
+                        stream_index,
+                        pairs),
+        NS_DISPATCH_SYNC);
+    return v;
+  }
+
+  void DumpCandidatePair(const NrIceCandidatePair& pair) {
+      std::cerr << std::endl;
+      DumpCandidate("Local", pair.local);
+      DumpCandidate("Remote", pair.remote);
+      std::cerr << "state = " << pair.state
+                << " priority = " << pair.priority
+                << " nominated = " << pair.nominated
+                << " selected = " << pair.selected
+                << " codeword = " << pair.codeword << std::endl;
+  }
+
+  void DumpCandidatePairs_s(NrIceMediaStream *stream) {
+    std::vector<NrIceCandidatePair> pairs;
+    nsresult res = stream->GetCandidatePairs(&pairs);
+    ASSERT_TRUE(NS_SUCCEEDED(res));
+
+    std::cerr << "Begin list of candidate pairs [" << std::endl;
+
+    for (std::vector<NrIceCandidatePair>::iterator p = pairs.begin();
+         p != pairs.end(); ++p) {
+      DumpCandidatePair(*p);
+    }
+    std::cerr << "]" << std::endl;
+  }
+
+  void DumpCandidatePairs_s() {
+    std::cerr << "Dumping candidate pairs for all streams [" << std::endl;
+    for (size_t s = 0; s < ice_ctx_->ctx()->GetStreamCount(); ++s) {
+      if (!ice_ctx_->ctx()->GetStream(s)) {
+        continue;
+      }
+      DumpCandidatePairs_s(ice_ctx_->ctx()->GetStream(s).get());
+    }
+    std::cerr << "]" << std::endl;
+  }
+
+  bool CandidatePairsPriorityDescending(const std::vector<NrIceCandidatePair>&
+                                        pairs) {
+    // Verify that priority is descending
+    uint64_t priority = std::numeric_limits<uint64_t>::max();
+
+    for (size_t p = 0; p < pairs.size(); ++p) {
+      if (priority < pairs[p].priority) {
+        std::cerr << "Priority increased in subsequent pairs:" << std::endl;
+        DumpCandidatePair(pairs[p-1]);
+        DumpCandidatePair(pairs[p]);
+        return false;
+      } else if (priority == pairs[p].priority) {
+        if (!IceCandidatePairCompare()(pairs[p], pairs[p-1]) &&
+            !IceCandidatePairCompare()(pairs[p-1], pairs[p])) {
+          std::cerr << "Ignoring identical pair from trigger check" << std::endl;
+        } else {
+          std::cerr << "Duplicate priority in subseqent pairs:" << std::endl;
+          DumpCandidatePair(pairs[p-1]);
+          DumpCandidatePair(pairs[p]);
+          return false;
+        }
+      }
+      priority = pairs[p].priority;
+    }
+    return true;
+  }
+
+  void UpdateAndValidateCandidatePairs(size_t stream_index,
+                                       std::vector<NrIceCandidatePair>*
+                                       new_pairs) {
+    std::vector<NrIceCandidatePair> old_pairs = *new_pairs;
+    GetCandidatePairs(stream_index, new_pairs);
+    ASSERT_TRUE(CandidatePairsPriorityDescending(*new_pairs)) << "New list of "
+            "candidate pairs is either not sorted in priority order, or has "
+            "duplicate priorities.";
+    ASSERT_TRUE(CandidatePairsPriorityDescending(old_pairs)) << "Old list of "
+            "candidate pairs is either not sorted in priority order, or has "
+            "duplicate priorities. This indicates some bug in the test case.";
+    std::vector<NrIceCandidatePair> added_pairs;
+    std::vector<NrIceCandidatePair> removed_pairs;
+
+    // set_difference computes the set of elements that are present in the
+    // first set, but not the second
+    // NrIceCandidatePair::operator< compares based on the priority, local
+    // candidate, and remote candidate in that order. This means this will
+    // catch cases where the priority has remained the same, but one of the
+    // candidates has changed.
+    std::set_difference((*new_pairs).begin(),
+                        (*new_pairs).end(),
+                        old_pairs.begin(),
+                        old_pairs.end(),
+                        std::inserter(added_pairs, added_pairs.begin()),
+                        IceCandidatePairCompare());
+
+    std::set_difference(old_pairs.begin(),
+                        old_pairs.end(),
+                        (*new_pairs).begin(),
+                        (*new_pairs).end(),
+                        std::inserter(removed_pairs, removed_pairs.begin()),
+                        IceCandidatePairCompare());
+
+    for (std::vector<NrIceCandidatePair>::iterator a = added_pairs.begin();
+         a != added_pairs.end(); ++a) {
+        std::cerr << "Found new candidate pair." << std::endl;
+        DumpCandidatePair(*a);
+    }
+
+    for (std::vector<NrIceCandidatePair>::iterator r = removed_pairs.begin();
+         r != removed_pairs.end(); ++r) {
+        std::cerr << "Pre-existing candidate pair is now missing:" << std::endl;
+        DumpCandidatePair(*r);
+    }
+
+    ASSERT_TRUE(removed_pairs.empty()) << "At least one candidate pair has "
+                                          "gone missing.";
+  }
+
+  void StreamReady(NrIceMediaStream *stream) {
+    ++ready_ct_;
+    std::cerr << name_ << " Stream ready for " << stream->name()
+                       << " ct=" << ready_ct_ << std::endl;
+    DumpCandidatePairs_s(stream);
+  }
+  void StreamFailed(NrIceMediaStream *stream) {
+    std::cerr << name_ << " Stream failed for " << stream->name()
+                       << " ct=" << ready_ct_ << std::endl;
+    DumpCandidatePairs_s(stream);
+  }
+
+  void ConnectionStateChange(NrIceCtx* ctx,
+                             NrIceCtx::ConnectionState state) {
+    (void)ctx;
+    switch (state) {
+      case NrIceCtx::ICE_CTX_INIT:
+        break;
+      case NrIceCtx::ICE_CTX_CHECKING:
+        std::cerr << name_ << " ICE reached checking" << std::endl;
+        ice_reached_checking_ = true;
+        break;
+      case NrIceCtx::ICE_CTX_CONNECTED:
+        std::cerr << name_ << " ICE connected" << std::endl;
+        ice_connected_ = true;
+        break;
+      case NrIceCtx::ICE_CTX_COMPLETED:
+        std::cerr << name_ << " ICE completed" << std::endl;
+        break;
+      case NrIceCtx::ICE_CTX_FAILED:
+        std::cerr << name_ << " ICE failed" << std::endl;
+        ice_failed_ = true;
+        break;
+      case NrIceCtx::ICE_CTX_DISCONNECTED:
+        std::cerr << name_ << " ICE disconnected" << std::endl;
+        ice_connected_ = false;
+        break;
+      default:
+        MOZ_CRASH();
+    }
+  }
+
+  void PacketReceived(NrIceMediaStream *stream, int component, const unsigned char *data,
+                      int len) {
+    std::cerr << name_ << ": received " << len << " bytes" << std::endl;
+    ++received_;
+  }
+
+  void SendPacket(int stream, int component, const unsigned char *data,
+                  int len) {
+    RefPtr<NrIceMediaStream> media_stream = ice_ctx_->ctx()->GetStream(stream);
+    if (!media_stream) {
+      ADD_FAILURE() << "No such stream " << stream;
+      return;
+    }
+
+    ASSERT_TRUE(NS_SUCCEEDED(media_stream->SendPacket(component, data, len)));
+
+    ++sent_;
+    std::cerr << name_ << ": sent " << len << " bytes" << std::endl;
+  }
+
+  void SendFailure(int stream, int component) {
+    RefPtr<NrIceMediaStream> media_stream = ice_ctx_->ctx()->GetStream(stream);
+    if (!media_stream) {
+      ADD_FAILURE() << "No such stream " << stream;
+      return;
+    }
+
+    const std::string d("FAIL");
+    ASSERT_TRUE(NS_FAILED(media_stream->SendPacket(component,
+      reinterpret_cast<const unsigned char *>(d.c_str()), d.length())));
+
+    std::cerr << name_ << ": send failed as expected" << std::endl;
+  }
+
+  void SetCandidateFilter(CandidateFilter filter) {
+    candidate_filter_ = filter;
+  }
+
+  void ParseCandidate_s(size_t i, const std::string& candidate) {
+    ASSERT_TRUE(ice_ctx_->ctx()->GetStream(i).get()) << "No such stream " << i;
+
+    std::vector<std::string> attributes;
+
+    attributes.push_back(candidate);
+    ice_ctx_->ctx()->GetStream(i)->ParseAttributes(attributes);
+  }
+
+  void ParseCandidate(size_t i, const std::string& candidate)
+  {
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(this,
+                        &IceTestPeer::ParseCandidate_s,
+                        i,
+                        candidate),
+        NS_DISPATCH_SYNC);
+  }
+
+  void DisableComponent_s(size_t stream, int component_id) {
+    ASSERT_LT(stream, ice_ctx_->ctx()->GetStreamCount());
+    ASSERT_TRUE(ice_ctx_->ctx()->GetStream(stream).get()) << "No such stream "
+                                                          << stream;
+    nsresult res =
+      ice_ctx_->ctx()->GetStream(stream)->DisableComponent(component_id);
+    ASSERT_TRUE(NS_SUCCEEDED(res));
+  }
+
+  void DisableComponent(size_t stream, int component_id)
+  {
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(this,
+                        &IceTestPeer::DisableComponent_s,
+                        stream,
+                        component_id),
+        NS_DISPATCH_SYNC);
+  }
+
+  void AssertConsentRefresh_s(size_t stream, int component_id, ConsentStatus status) {
+    ASSERT_LT(stream, ice_ctx_->ctx()->GetStreamCount());
+    ASSERT_TRUE(ice_ctx_->ctx()->GetStream(stream).get()) << "No such stream "
+                                                          << stream;
+    bool can_send;
+    struct timeval timestamp;
+    nsresult res = ice_ctx_->ctx()->GetStream(stream)->
+                    GetConsentStatus(component_id, &can_send, &timestamp);
+    ASSERT_TRUE(NS_SUCCEEDED(res));
+    if (status == CONSENT_EXPIRED) {
+      ASSERT_EQ(can_send, 0);
+    } else {
+      ASSERT_EQ(can_send, 1);
+    }
+    if (consent_timestamp_.tv_sec) {
+      if (status == CONSENT_FRESH) {
+        ASSERT_EQ(r_timeval_cmp(&timestamp, &consent_timestamp_), 1);
+      } else {
+        ASSERT_EQ(r_timeval_cmp(&timestamp, &consent_timestamp_), 0);
+      }
+    }
+    consent_timestamp_.tv_sec = timestamp.tv_sec;
+    consent_timestamp_.tv_usec = timestamp.tv_usec;
+    std::cerr << name_ << ": new consent timestamp = " <<
+      consent_timestamp_.tv_sec << "." << consent_timestamp_.tv_usec <<
+      std::endl;
+  }
+
+  void AssertConsentRefresh(ConsentStatus status) {
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(this,
+                        &IceTestPeer::AssertConsentRefresh_s,
+                        0,
+                        1,
+                        status),
+        NS_DISPATCH_SYNC);
+  }
+
+  int trickled() { return trickled_; }
+
+  void SetControlling(NrIceCtx::Controlling controlling) {
+    nsresult res;
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableRet(&res, ice_ctx_->ctx(),
+                        &NrIceCtx::SetControlling,
+                        controlling),
+        NS_DISPATCH_SYNC);
+    ASSERT_TRUE(NS_SUCCEEDED(res));
+  }
+
+  NrIceCtx::Controlling GetControlling() {
+    return ice_ctx_->ctx()->GetControlling();
+  }
+
+  void SetTiebreaker(uint64_t tiebreaker) {
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(this,
+                     &IceTestPeer::SetTiebreaker_s,
+                     tiebreaker),
+        NS_DISPATCH_SYNC);
+  }
+
+  void SetTiebreaker_s(uint64_t tiebreaker) {
+    ice_ctx_->ctx()->peer()->tiebreaker = tiebreaker;
+  }
+
+  void SimulateIceLite() {
+    simulate_ice_lite_ = true;
+    SetControlling(NrIceCtx::ICE_CONTROLLED);
+  }
+
+  nsresult GetDefaultCandidate(unsigned int stream, NrIceCandidate* cand) {
+    nsresult rv;
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableRet(&rv, this,
+                        &IceTestPeer::GetDefaultCandidate_s,
+                        stream, cand),
+        NS_DISPATCH_SYNC);
+
+    return rv;
+  }
+
+  nsresult GetDefaultCandidate_s(unsigned int stream, NrIceCandidate* cand) {
+    return ice_ctx_->ctx()->GetStream(stream)->GetDefaultCandidate(1, cand);
+  }
+
+ private:
+  std::string name_;
+  RefPtr<NrIceCtxHandler> ice_ctx_;
+  std::map<std::string, std::vector<std::string> > candidates_;
+  // Maps from stream id to list of remote trickle candidates
+  std::map<size_t, std::vector<SchedulableTrickleCandidate*> >
+    controlled_trickle_candidates_;
+  bool shutting_down_;
+  bool gathering_complete_;
+  int ready_ct_;
+  bool ice_connected_;
+  bool ice_failed_;
+  bool ice_reached_checking_;
+  size_t received_;
+  size_t sent_;
+  struct timeval consent_timestamp_;
+  NrIceResolverFake fake_resolver_;
+  RefPtr<NrIceResolver> dns_resolver_;
+  IceTestPeer *remote_;
+  CandidateFilter candidate_filter_;
+  NrIceCandidate::Type expected_local_type_;
+  std::string expected_local_transport_;
+  NrIceCandidate::Type expected_remote_type_;
+  std::string expected_remote_addr_;
+  TrickleMode trickle_mode_;
+  int trickled_;
+  bool simulate_ice_lite_;
+  RefPtr<mozilla::TestNat> nat_;
+  MtransportTestUtils* test_utils_;
+};
+
+void SchedulableTrickleCandidate::Trickle() {
+  timer_handle_ = nullptr;
+  nsresult res = peer_->TrickleCandidate_s(candidate_, stream_);
+  ASSERT_TRUE(NS_SUCCEEDED(res));
+}
+
+class WebRtcIceGatherTest : public StunTest {
+ public:
+  void SetUp() override {
+    StunTest::SetUp();
+
+    Preferences::SetInt("media.peerconnection.ice.tcp_so_sock_count", 3);
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(TestStunServer::GetInstance(AF_INET),
+                     &TestStunServer::Reset),
+        NS_DISPATCH_SYNC);
+    if (TestStunServer::GetInstance(AF_INET6)) {
+      test_utils_->sts_target()->Dispatch(
+          WrapRunnable(TestStunServer::GetInstance(AF_INET6),
+                       &TestStunServer::Reset),
+          NS_DISPATCH_SYNC);
+    }
+  }
+
+  void TearDown() override {
+    peer_ = nullptr;
+    StunTest::TearDown();
+  }
+
+  void EnsurePeer(const unsigned int flags = ICE_TEST_PEER_OFFERER) {
+    if (!peer_) {
+      peer_ = MakeUnique<IceTestPeer>("P1", test_utils_,
+                                      flags & ICE_TEST_PEER_OFFERER,
+                                      flags & ICE_TEST_PEER_ALLOW_LOOPBACK,
+                                      flags & ICE_TEST_PEER_ENABLED_TCP,
+                                      flags & ICE_TEST_PEER_ALLOW_LINK_LOCAL);
+      peer_->AddStream(1);
+    }
+  }
+
+  void Gather(unsigned int waitTime = kDefaultTimeout) {
+    EnsurePeer();
+    peer_->Gather();
+
+    if (waitTime) {
+      WaitForGather(waitTime);
+    }
+  }
+
+  void WaitForGather(unsigned int waitTime = kDefaultTimeout) {
+    ASSERT_TRUE_WAIT(peer_->gathering_complete(), waitTime);
+  }
+
+  void AddStunServerWithResponse(
+      const std::string& fake_addr,
+      uint16_t fake_port,
+      const std::string& fqdn,
+      const std::string& proto,
+      std::vector<NrIceStunServer>* stun_servers) {
+    int family;
+    if (fake_addr.find(':') != std::string::npos) {
+      family = AF_INET6;
+    } else {
+      family = AF_INET;
+    }
+
+    std::string stun_addr;
+    uint16_t stun_port;
+    if (proto == kNrIceTransportUdp) {
+      TestStunServer::GetInstance(family)->SetResponseAddr(fake_addr,
+                                                           fake_port);
+      stun_addr = TestStunServer::GetInstance(family)->addr();
+      stun_port = TestStunServer::GetInstance(family)->port();
+    } else if (proto == kNrIceTransportTcp) {
+      TestStunTcpServer::GetInstance(family)->SetResponseAddr(fake_addr,
+                                                              fake_port);
+      stun_addr = TestStunTcpServer::GetInstance(family)->addr();
+      stun_port = TestStunTcpServer::GetInstance(family)->port();
+    } else {
+      MOZ_CRASH();
+    }
+
+    if (!fqdn.empty()) {
+      peer_->SetFakeResolver(stun_addr, fqdn);
+      stun_addr = fqdn;
+    }
+
+    stun_servers->push_back(*NrIceStunServer::Create(stun_addr,
+                                                     stun_port,
+                                                     proto.c_str()));
+  }
+
+  void UseFakeStunUdpServerWithResponse(
+      const std::string& fake_addr,
+      uint16_t fake_port,
+      const std::string& fqdn = std::string()) {
+    EnsurePeer();
+    std::vector<NrIceStunServer> stun_servers;
+    AddStunServerWithResponse(fake_addr, fake_port, fqdn, "udp", &stun_servers);
+    peer_->SetStunServers(stun_servers);
+  }
+
+  void UseFakeStunTcpServerWithResponse(
+      const std::string& fake_addr,
+      uint16_t fake_port,
+      const std::string& fqdn = std::string()) {
+    EnsurePeer(ICE_TEST_PEER_OFFERER | ICE_TEST_PEER_ENABLED_TCP);
+    std::vector<NrIceStunServer> stun_servers;
+    AddStunServerWithResponse(fake_addr, fake_port, fqdn, "tcp", &stun_servers);
+    peer_->SetStunServers(stun_servers);
+  }
+
+  void UseFakeStunUdpTcpServersWithResponse(
+      const std::string& fake_udp_addr,
+      uint16_t fake_udp_port,
+      const std::string& fake_tcp_addr,
+      uint16_t fake_tcp_port) {
+    EnsurePeer(ICE_TEST_PEER_OFFERER | ICE_TEST_PEER_ENABLED_TCP);
+    std::vector<NrIceStunServer> stun_servers;
+    AddStunServerWithResponse(fake_udp_addr,
+                              fake_udp_port,
+                              "", // no fqdn
+                              "udp",
+                              &stun_servers);
+    AddStunServerWithResponse(fake_tcp_addr,
+                              fake_tcp_port,
+                              "", // no fqdn
+                              "tcp",
+                              &stun_servers);
+
+    peer_->SetStunServers(stun_servers);
+  }
+
+  void UseTestStunServer() {
+    TestStunServer::GetInstance(AF_INET)->Reset();
+    peer_->SetStunServer(TestStunServer::GetInstance(AF_INET)->addr(),
+                         TestStunServer::GetInstance(AF_INET)->port());
+  }
+
+  // NB: Only does substring matching, watch out for stuff like "1.2.3.4"
+  // matching "21.2.3.47". " 1.2.3.4 " should not have false positives.
+  bool StreamHasMatchingCandidate(unsigned int stream,
+                                  const std::string& match,
+                                  const std::string& match2 = "") {
+    std::vector<std::string> candidates = peer_->GetCandidates(stream);
+    for (size_t c = 0; c < candidates.size(); ++c) {
+      if (std::string::npos != candidates[c].find(match)) {
+        if (!match2.length() ||
+            std::string::npos != candidates[c].find(match2)) {
+          return true;
+        }
+      }
+    }
+    return false;
+  }
+
+  void DumpCandidates(unsigned int stream) {
+    std::vector<std::string> candidates = peer_->GetCandidates(stream);
+
+    std::cerr << "Candidates for stream " << stream << "->"
+              << candidates.size() << std::endl;
+
+    for (auto c : candidates) {
+      std::cerr << "Candidate: " << c << std::endl;
+    }
+  }
+
+ protected:
+  mozilla::UniquePtr<IceTestPeer> peer_;
+};
+
+class WebRtcIceConnectTest : public StunTest {
+ public:
+  WebRtcIceConnectTest() :
+    initted_(false),
+    test_stun_server_inited_(false),
+    use_nat_(false),
+    filtering_type_(TestNat::ENDPOINT_INDEPENDENT),
+    mapping_type_(TestNat::ENDPOINT_INDEPENDENT),
+    block_udp_(false) {}
+
+  void SetUp() override {
+    StunTest::SetUp();
+
+    nsresult rv;
+    target_ = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+    ASSERT_TRUE(NS_SUCCEEDED(rv));
+  }
+
+  void TearDown() override {
+    p1_ = nullptr;
+    p2_ = nullptr;
+
+    StunTest::TearDown();
+  }
+
+  void AddStream(int components) {
+    Init(false, false);
+    p1_->AddStream(components);
+    p2_->AddStream(components);
+  }
+
+  void RemoveStream(size_t index) {
+    p1_->RemoveStream(index);
+    p2_->RemoveStream(index);
+  }
+
+  void Init(bool allow_loopback,
+            bool enable_tcp,
+            bool setup_stun_servers = true,
+            NrIceCtx::Policy ice_policy = NrIceCtx::ICE_POLICY_ALL) {
+    if (initted_) {
+      return;
+    }
+
+    p1_ = MakeUnique<IceTestPeer>("P1", test_utils_, true, allow_loopback,
+                                  enable_tcp, false, ice_policy);
+    p2_ = MakeUnique<IceTestPeer>("P2", test_utils_, false, allow_loopback,
+                                  enable_tcp, false, ice_policy);
+    InitPeer(p1_.get(), setup_stun_servers);
+    InitPeer(p2_.get(), setup_stun_servers);
+
+    initted_ = true;
+  }
+
+  void InitPeer(IceTestPeer* peer, bool setup_stun_servers = true) {
+    if (use_nat_) {
+      // If we enable nat simulation, but still use a real STUN server somewhere
+      // on the internet, we will see failures if there is a real NAT in
+      // addition to our simulated one, particularly if it disallows
+      // hairpinning.
+      if (setup_stun_servers) {
+        InitTestStunServer();
+        peer->UseTestStunServer();
+      }
+      peer->UseNat();
+      peer->SetFilteringType(filtering_type_);
+      peer->SetMappingType(mapping_type_);
+      peer->SetBlockUdp(block_udp_);
+    } else if (setup_stun_servers) {
+      std::vector<NrIceStunServer> stun_servers;
+
+      stun_servers.push_back(*NrIceStunServer::Create(stun_server_address_,
+                                                      kDefaultStunServerPort, kNrIceTransportUdp));
+      stun_servers.push_back(*NrIceStunServer::Create(stun_server_address_,
+                                                      kDefaultStunServerPort, kNrIceTransportTcp));
+
+      peer->SetStunServers(stun_servers);
+    }
+  }
+
+  bool Gather(unsigned int waitTime = kDefaultTimeout,
+              bool default_route_only = false) {
+    Init(false, false);
+
+    return GatherCallerAndCallee(p1_.get(),
+                                 p2_.get(),
+                                 waitTime,
+                                 default_route_only);
+  }
+
+  bool GatherCallerAndCallee(IceTestPeer* caller,
+                             IceTestPeer* callee,
+                             unsigned int waitTime = kDefaultTimeout,
+                             bool default_route_only = false) {
+    caller->Gather(default_route_only);
+    callee->Gather(default_route_only);
+
+    if (waitTime) {
+      EXPECT_TRUE_WAIT(caller->gathering_complete(), waitTime);
+      if (!caller->gathering_complete())
+        return false;
+      EXPECT_TRUE_WAIT(callee->gathering_complete(), waitTime);
+      if (!callee->gathering_complete())
+        return false;
+    }
+    return true;
+  }
+
+  void UseNat() {
+    // to be useful, this method should be called before Init
+    ASSERT_FALSE(initted_);
+    use_nat_ = true;
+  }
+
+  void SetFilteringType(TestNat::NatBehavior type) {
+    // to be useful, this method should be called before Init
+    ASSERT_FALSE(initted_);
+    filtering_type_ = type;
+  }
+
+  void SetMappingType(TestNat::NatBehavior type) {
+    // to be useful, this method should be called before Init
+    ASSERT_FALSE(initted_);
+    mapping_type_ = type;
+  }
+
+  void BlockUdp() {
+    // note: |block_udp_| is used only in InitPeer.
+    // Use IceTestPeer::SetBlockUdp to act on the peer directly.
+    block_udp_ = true;
+  }
+
+  void SetupAndCheckConsent() {
+    p1_->SetTimerDivider(10);
+    p2_->SetTimerDivider(10);
+    ASSERT_TRUE(Gather());
+    Connect();
+    p1_->AssertConsentRefresh(CONSENT_FRESH);
+    p2_->AssertConsentRefresh(CONSENT_FRESH);
+    SendReceive();
+  }
+
+  void AssertConsentRefresh(ConsentStatus status = CONSENT_FRESH) {
+    p1_->AssertConsentRefresh(status);
+    p2_->AssertConsentRefresh(status);
+  }
+
+  void InitTestStunServer() {
+    if (test_stun_server_inited_) {
+      return;
+    }
+
+    std::cerr << "Resetting TestStunServer" << std::endl;
+    TestStunServer::GetInstance(AF_INET)->Reset();
+    test_stun_server_inited_ = true;
+  }
+
+  void UseTestStunServer() {
+    InitTestStunServer();
+    p1_->UseTestStunServer();
+    p2_->UseTestStunServer();
+  }
+
+  void SetTurnServer(const std::string addr, uint16_t port,
+                     const std::string username,
+                     const std::string password,
+                     const char* transport = kNrIceTransportUdp) {
+    p1_->SetTurnServer(addr, port, username, password, transport);
+    p2_->SetTurnServer(addr, port, username, password, transport);
+  }
+
+  void SetTurnServers(const std::vector<NrIceTurnServer>& servers) {
+    p1_->SetTurnServers(servers);
+    p2_->SetTurnServers(servers);
+  }
+
+  void SetCandidateFilter(CandidateFilter filter, bool both=true) {
+    p1_->SetCandidateFilter(filter);
+    if (both) {
+      p2_->SetCandidateFilter(filter);
+    }
+  }
+
+  void Connect() {
+    ConnectCallerAndCallee(p1_.get(), p2_.get());
+  }
+
+  void ConnectCallerAndCallee(IceTestPeer* caller, IceTestPeer* callee) {
+    ASSERT_TRUE(caller->ready_ct() == 0);
+    ASSERT_TRUE(caller->ice_connected() == 0);
+    ASSERT_TRUE(caller->ice_reached_checking() == 0);
+    ASSERT_TRUE(callee->ready_ct() == 0);
+    ASSERT_TRUE(callee->ice_connected() == 0);
+    ASSERT_TRUE(callee->ice_reached_checking() == 0);
+
+    // IceTestPeer::Connect grabs attributes from the first arg, and
+    // gives them to |this|, meaning that callee->Connect(caller, ...)
+    // simulates caller sending an offer to callee. Order matters here
+    // because it determines which peer is controlling.
+    callee->Connect(caller, TRICKLE_NONE);
+    caller->Connect(callee, TRICKLE_NONE);
+
+    ASSERT_TRUE_WAIT(caller->ready_ct() == 1 && callee->ready_ct() == 1,
+                     kDefaultTimeout);
+    ASSERT_TRUE_WAIT(caller->ice_connected() && callee->ice_connected(),
+                     kDefaultTimeout);
+
+    ASSERT_TRUE(caller->ice_reached_checking());
+    ASSERT_TRUE(callee->ice_reached_checking());
+
+    caller->DumpAndCheckActiveCandidates();
+    callee->DumpAndCheckActiveCandidates();
+  }
+
+  void SetExpectedTypes(NrIceCandidate::Type local, NrIceCandidate::Type remote,
+                        std::string transport = kNrIceTransportUdp) {
+    p1_->SetExpectedTypes(local, remote, transport);
+    p2_->SetExpectedTypes(local, remote, transport);
+  }
+
+  void SetExpectedTypes(NrIceCandidate::Type local1, NrIceCandidate::Type remote1,
+                        NrIceCandidate::Type local2, NrIceCandidate::Type remote2) {
+    p1_->SetExpectedTypes(local1, remote1);
+    p2_->SetExpectedTypes(local2, remote2);
+  }
+
+  void SetExpectedRemoteCandidateAddr(const std::string& addr) {
+    p1_->SetExpectedRemoteCandidateAddr(addr);
+    p2_->SetExpectedRemoteCandidateAddr(addr);
+  }
+
+  void ConnectP1(TrickleMode mode = TRICKLE_NONE) {
+    p1_->Connect(p2_.get(), mode);
+  }
+
+  void ConnectP2(TrickleMode mode = TRICKLE_NONE) {
+    p2_->Connect(p1_.get(), mode);
+  }
+
+  void WaitForConnectedStreams(int expected_streams = 1) {
+    ASSERT_TRUE_WAIT(p1_->ready_ct() == expected_streams &&
+                     p2_->ready_ct() == expected_streams, kDefaultTimeout);
+    ASSERT_TRUE_WAIT(p1_->ice_connected() && p2_->ice_connected(),
+                     kDefaultTimeout);
+  }
+
+  void AssertCheckingReached() {
+    ASSERT_TRUE(p1_->ice_reached_checking());
+    ASSERT_TRUE(p2_->ice_reached_checking());
+  }
+
+  void WaitForConnected(unsigned int timeout = kDefaultTimeout) {
+    ASSERT_TRUE_WAIT(p1_->ice_connected(), timeout);
+    ASSERT_TRUE_WAIT(p2_->ice_connected(), timeout);
+  }
+
+  void WaitForGather() {
+    ASSERT_TRUE_WAIT(p1_->gathering_complete(), kDefaultTimeout);
+    ASSERT_TRUE_WAIT(p2_->gathering_complete(), kDefaultTimeout);
+  }
+
+  void WaitForDisconnected(unsigned int timeout = kDefaultTimeout) {
+    ASSERT_TRUE(p1_->ice_connected());
+    ASSERT_TRUE(p2_->ice_connected());
+    ASSERT_TRUE_WAIT(p1_->ice_connected() == 0 &&
+                     p2_->ice_connected() == 0,
+                     timeout);
+  }
+
+  void WaitForFailed(unsigned int timeout = kDefaultTimeout) {
+    ASSERT_TRUE_WAIT(p1_->ice_failed() &&
+                     p2_->ice_failed(),
+                     timeout);
+  }
+
+  void ConnectTrickle(TrickleMode trickle = TRICKLE_SIMULATE) {
+    p2_->Connect(p1_.get(), trickle);
+    p1_->Connect(p2_.get(), trickle);
+  }
+
+  void SimulateTrickle(size_t stream) {
+    p1_->SimulateTrickle(stream);
+    p2_->SimulateTrickle(stream);
+    ASSERT_TRUE_WAIT(p1_->is_ready(stream), kDefaultTimeout);
+    ASSERT_TRUE_WAIT(p2_->is_ready(stream), kDefaultTimeout);
+  }
+
+  void SimulateTrickleP1(size_t stream) {
+    p1_->SimulateTrickle(stream);
+  }
+
+  void SimulateTrickleP2(size_t stream) {
+    p2_->SimulateTrickle(stream);
+  }
+
+  void CloseP1() {
+    p1_->Close();
+  }
+
+  void ConnectThenDelete() {
+    p2_->Connect(p1_.get(), TRICKLE_NONE, false);
+    p1_->Connect(p2_.get(), TRICKLE_NONE, true);
+    test_utils_->sts_target()->Dispatch(WrapRunnable(this,
+                                                    &WebRtcIceConnectTest::CloseP1),
+                                       NS_DISPATCH_SYNC);
+    p2_->StartChecks();
+
+    // Wait to see if we crash
+    PR_Sleep(PR_MillisecondsToInterval(kDefaultTimeout));
+  }
+
+  // default is p1_ sending to p2_
+  void SendReceive() {
+    SendReceive(p1_.get(), p2_.get());
+  }
+
+  void SendReceive(IceTestPeer *p1, IceTestPeer *p2,
+                   bool expect_tx_failure = false,
+                   bool expect_rx_failure = false) {
+    size_t previousSent = p1->sent();
+    size_t previousReceived = p2->received();
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(p1,
+                     &IceTestPeer::SendPacket, 0, 1,
+                     reinterpret_cast<const unsigned char *>("TEST"), 4),
+        NS_DISPATCH_SYNC);
+
+    if (expect_tx_failure) {
+      ASSERT_EQ(previousSent, p1->sent());
+    } else {
+      ASSERT_EQ(previousSent+1, p1->sent());
+    }
+    if (expect_rx_failure) {
+      usleep(1000);
+      ASSERT_EQ(previousReceived, p2->received());
+    } else {
+      ASSERT_TRUE_WAIT(p2->received() == previousReceived+1, 1000);
+    }
+  }
+
+  void SendFailure() {
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnable(p1_.get(),
+                     &IceTestPeer::SendFailure, 0, 1),
+        NS_DISPATCH_SYNC);
+  }
+
+ protected:
+  bool initted_;
+  bool test_stun_server_inited_;
+  nsCOMPtr<nsIEventTarget> target_;
+  mozilla::UniquePtr<IceTestPeer> p1_;
+  mozilla::UniquePtr<IceTestPeer> p2_;
+  bool use_nat_;
+  TestNat::NatBehavior filtering_type_;
+  TestNat::NatBehavior mapping_type_;
+  bool block_udp_;
+};
+
+class WebRtcIcePrioritizerTest : public StunTest {
+ public:
+  WebRtcIcePrioritizerTest():
+    prioritizer_(nullptr) {}
+
+  ~WebRtcIcePrioritizerTest() {
+    if (prioritizer_) {
+      nr_interface_prioritizer_destroy(&prioritizer_);
+    }
+  }
+
+  void SetPriorizer(nr_interface_prioritizer *prioritizer) {
+    prioritizer_ = prioritizer;
+  }
+
+  void AddInterface(const std::string& num, int type, int estimated_speed) {
+    std::string str_addr = "10.0.0." + num;
+    std::string ifname = "eth" + num;
+    nr_local_addr local_addr;
+    local_addr.interface.type = type;
+    local_addr.interface.estimated_speed = estimated_speed;
+
+    int r = nr_str_port_to_transport_addr(str_addr.c_str(), 0,
+                                          IPPROTO_UDP, &(local_addr.addr));
+    ASSERT_EQ(0, r);
+    strncpy(local_addr.addr.ifname, ifname.c_str(), MAXIFNAME);
+
+    r = nr_interface_prioritizer_add_interface(prioritizer_, &local_addr);
+    ASSERT_EQ(0, r);
+    r = nr_interface_prioritizer_sort_preference(prioritizer_);
+    ASSERT_EQ(0, r);
+  }
+
+  void HasLowerPreference(const std::string& num1, const std::string& num2) {
+    std::string key1 = "eth" + num1 + ":10.0.0." + num1;
+    std::string key2 = "eth" + num2 + ":10.0.0." + num2;
+    UCHAR pref1, pref2;
+    int r = nr_interface_prioritizer_get_priority(prioritizer_, key1.c_str(), &pref1);
+    ASSERT_EQ(0, r);
+    r = nr_interface_prioritizer_get_priority(prioritizer_, key2.c_str(), &pref2);
+    ASSERT_EQ(0, r);
+    ASSERT_LE(pref1, pref2);
+  }
+
+ private:
+  nr_interface_prioritizer *prioritizer_;
+};
+
+class WebRtcIcePacketFilterTest : public StunTest {
+ public:
+  WebRtcIcePacketFilterTest(): udp_filter_(nullptr),
+                               tcp_filter_(nullptr) {}
+
+  void SetUp() {
+    StunTest::SetUp();
+
+    // Set up enough of the ICE ctx to allow the packet filter to work
+    ice_ctx_ = NrIceCtxHandler::Create("test", true);
+
+    nsCOMPtr<nsISocketFilterHandler> udp_handler =
+      do_GetService(NS_STUN_UDP_SOCKET_FILTER_HANDLER_CONTRACTID);
+    ASSERT_TRUE(udp_handler);
+    udp_handler->NewFilter(getter_AddRefs(udp_filter_));
+
+    nsCOMPtr<nsISocketFilterHandler> tcp_handler =
+      do_GetService(NS_STUN_TCP_SOCKET_FILTER_HANDLER_CONTRACTID);
+    ASSERT_TRUE(tcp_handler);
+    tcp_handler->NewFilter(getter_AddRefs(tcp_filter_));
+  }
+
+  void TearDown() {
+    test_utils_->sts_target()->Dispatch(WrapRunnable(this,
+                                       &WebRtcIcePacketFilterTest::TearDown_s),
+                                       NS_DISPATCH_SYNC);
+    StunTest::TearDown();
+  }
+
+  void TearDown_s() {
+    ice_ctx_ = nullptr;
+  }
+
+  void TestIncoming(const uint8_t* data, uint32_t len,
+                    uint8_t from_addr, int from_port,
+                    bool expected_result) {
+    mozilla::net::NetAddr addr;
+    MakeNetAddr(&addr, from_addr, from_port);
+    bool result;
+    nsresult rv = udp_filter_->FilterPacket(&addr, data, len,
+                                            nsISocketFilter::SF_INCOMING,
+                                            &result);
+    ASSERT_EQ(NS_OK, rv);
+    ASSERT_EQ(expected_result, result);
+  }
+
+  void TestIncomingTcp(const uint8_t* data, uint32_t len,
+                       bool expected_result) {
+    mozilla::net::NetAddr addr;
+    bool result;
+    nsresult rv = tcp_filter_->FilterPacket(&addr, data, len,
+                                            nsISocketFilter::SF_INCOMING,
+                                            &result);
+    ASSERT_EQ(NS_OK, rv);
+    ASSERT_EQ(expected_result, result);
+  }
+
+  void TestIncomingTcpFramed(const uint8_t* data, uint32_t len,
+                             bool expected_result) {
+    mozilla::net::NetAddr addr;
+    bool result;
+    uint8_t* framed_data = new uint8_t[len+2];
+    framed_data[0] = htons(len);
+    memcpy(&framed_data[2], data, len);
+    nsresult rv = tcp_filter_->FilterPacket(&addr, framed_data, len+2,
+                                            nsISocketFilter::SF_INCOMING,
+                                            &result);
+    ASSERT_EQ(NS_OK, rv);
+    ASSERT_EQ(expected_result, result);
+    delete[] framed_data;
+  }
+
+  void TestOutgoing(const uint8_t* data, uint32_t len,
+                    uint8_t to_addr, int to_port,
+                    bool expected_result) {
+    mozilla::net::NetAddr addr;
+    MakeNetAddr(&addr, to_addr, to_port);
+    bool result;
+    nsresult rv = udp_filter_->FilterPacket(&addr, data, len,
+                                            nsISocketFilter::SF_OUTGOING,
+                                            &result);
+    ASSERT_EQ(NS_OK, rv);
+    ASSERT_EQ(expected_result, result);
+  }
+
+  void TestOutgoingTcp(const uint8_t* data, uint32_t len,
+                       bool expected_result) {
+    mozilla::net::NetAddr addr;
+    bool result;
+    nsresult rv = tcp_filter_->FilterPacket(&addr, data, len,
+                                            nsISocketFilter::SF_OUTGOING,
+                                            &result);
+    ASSERT_EQ(NS_OK, rv);
+    ASSERT_EQ(expected_result, result);
+  }
+
+  void TestOutgoingTcpFramed(const uint8_t* data, uint32_t len,
+                             bool expected_result) {
+    mozilla::net::NetAddr addr;
+    bool result;
+    uint8_t* framed_data = new uint8_t[len+2];
+    framed_data[0] = htons(len);
+    memcpy(&framed_data[2], data, len);
+    nsresult rv = tcp_filter_->FilterPacket(&addr, framed_data, len+2,
+                                            nsISocketFilter::SF_OUTGOING,
+                                            &result);
+    ASSERT_EQ(NS_OK, rv);
+    ASSERT_EQ(expected_result, result);
+    delete[] framed_data;
+  }
+
+ private:
+  void MakeNetAddr(mozilla::net::NetAddr* net_addr,
+                   uint8_t last_digit, uint16_t port) {
+    net_addr->inet.family = AF_INET;
+    net_addr->inet.ip = 192 << 24 | 168 << 16 | 1 << 8 | last_digit;
+    net_addr->inet.port = port;
+  }
+
+  nsCOMPtr<nsISocketFilter> udp_filter_;
+  nsCOMPtr<nsISocketFilter> tcp_filter_;
+  RefPtr<NrIceCtxHandler> ice_ctx_;
+};
+}  // end namespace
+
+TEST_F(WebRtcIceGatherTest, TestGatherFakeStunServerHostnameNoResolver) {
+  if (stun_server_hostname_.empty()) {
+    return;
+  }
+
+  EnsurePeer();
+  peer_->SetStunServer(stun_server_hostname_, kDefaultStunServerPort);
+  Gather();
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherFakeStunServerTcpHostnameNoResolver) {
+  if (stun_server_hostname_.empty()) {
+    return;
+  }
+
+  EnsurePeer(ICE_TEST_PEER_OFFERER | ICE_TEST_PEER_ENABLED_TCP);
+  peer_->SetStunServer(stun_server_hostname_, kDefaultStunServerPort,
+    kNrIceTransportTcp);
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " TCP "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherFakeStunServerIpAddress) {
+  if (stun_server_address_.empty()) {
+    return;
+  }
+
+  EnsurePeer();
+  peer_->SetStunServer(stun_server_address_, kDefaultStunServerPort);
+  peer_->SetFakeResolver(stun_server_address_, stun_server_hostname_);
+  Gather();
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherStunServerIpAddressNoHost) {
+  if (stun_server_address_.empty()) {
+    return;
+  }
+
+  peer_ = MakeUnique<IceTestPeer>("P1", test_utils_, true, false, false, false, NrIceCtx::ICE_POLICY_NO_HOST);
+  peer_->AddStream(1);
+  peer_->SetStunServer(stun_server_address_, kDefaultStunServerPort);
+  peer_->SetFakeResolver(stun_server_address_, stun_server_hostname_);
+  Gather();
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, " host "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherFakeStunServerHostname) {
+  if (stun_server_hostname_.empty()) {
+    return;
+  }
+
+  EnsurePeer();
+  peer_->SetStunServer(stun_server_hostname_, kDefaultStunServerPort);
+  peer_->SetFakeResolver(stun_server_address_, stun_server_hostname_);
+  Gather();
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherFakeStunBogusHostname) {
+  EnsurePeer();
+  peer_->SetStunServer(kBogusStunServerHostname, kDefaultStunServerPort);
+  peer_->SetFakeResolver(stun_server_address_, stun_server_hostname_);
+  Gather();
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherDNSStunServerIpAddress) {
+  if (stun_server_address_.empty()) {
+    return;
+  }
+
+  EnsurePeer();
+  peer_->SetStunServer(stun_server_address_, kDefaultStunServerPort);
+  peer_->SetDNSResolver();
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " UDP "));
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "typ srflx raddr"));
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherDNSStunServerIpAddressTcp) {
+  if (stun_server_address_.empty()) {
+    return;
+  }
+
+  EnsurePeer(ICE_TEST_PEER_OFFERER | ICE_TEST_PEER_ENABLED_TCP);
+  peer_->SetStunServer(stun_server_address_, kDefaultStunServerPort,
+    kNrIceTransportTcp);
+  peer_->SetDNSResolver();
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "tcptype passive"));
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, "tcptype passive", " 9 "));
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "tcptype so"));
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, "tcptype so", " 9 "));
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "tcptype active", " 9 "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherDNSStunServerHostname) {
+  if (stun_server_hostname_.empty()) {
+    return;
+  }
+
+  EnsurePeer();
+  peer_->SetStunServer(stun_server_hostname_, kDefaultStunServerPort);
+  peer_->SetDNSResolver();
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " UDP "));
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "typ srflx raddr"));
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherDNSStunServerHostnameTcp) {
+  EnsurePeer(ICE_TEST_PEER_OFFERER | ICE_TEST_PEER_ENABLED_TCP);
+  peer_->SetStunServer(stun_server_hostname_, kDefaultStunServerPort,
+    kNrIceTransportTcp);
+  peer_->SetDNSResolver();
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "tcptype passive"));
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, "tcptype passive", " 9 "));
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "tcptype so"));
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, "tcptype so", " 9 "));
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "tcptype active", " 9 "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherDNSStunServerHostnameBothUdpTcp) {
+  if (stun_server_hostname_.empty()) {
+    return;
+  }
+
+  std::vector<NrIceStunServer> stun_servers;
+
+  EnsurePeer(ICE_TEST_PEER_OFFERER | ICE_TEST_PEER_ENABLED_TCP);
+  stun_servers.push_back(*NrIceStunServer::Create(stun_server_hostname_,
+    kDefaultStunServerPort, kNrIceTransportUdp));
+  stun_servers.push_back(*NrIceStunServer::Create(stun_server_hostname_,
+    kDefaultStunServerPort, kNrIceTransportTcp));
+  peer_->SetStunServers(stun_servers);
+  peer_->SetDNSResolver();
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " UDP "));
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " TCP "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherDNSStunServerIpAddressBothUdpTcp) {
+  if (stun_server_address_.empty()) {
+    return;
+  }
+
+  std::vector<NrIceStunServer> stun_servers;
+
+  EnsurePeer(ICE_TEST_PEER_OFFERER | ICE_TEST_PEER_ENABLED_TCP);
+  stun_servers.push_back(*NrIceStunServer::Create(stun_server_address_,
+    kDefaultStunServerPort, kNrIceTransportUdp));
+  stun_servers.push_back(*NrIceStunServer::Create(stun_server_address_,
+    kDefaultStunServerPort, kNrIceTransportTcp));
+  peer_->SetStunServers(stun_servers);
+  peer_->SetDNSResolver();
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " UDP "));
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " TCP "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherDNSStunBogusHostname) {
+  EnsurePeer();
+  peer_->SetStunServer(kBogusStunServerHostname, kDefaultStunServerPort);
+  peer_->SetDNSResolver();
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " UDP "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherDNSStunBogusHostnameTcp) {
+  EnsurePeer(ICE_TEST_PEER_OFFERER | ICE_TEST_PEER_ENABLED_TCP);
+  peer_->SetStunServer(kBogusStunServerHostname, kDefaultStunServerPort,
+    kNrIceTransportTcp);
+  peer_->SetDNSResolver();
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " TCP "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestDefaultCandidate) {
+  EnsurePeer();
+  peer_->SetStunServer(stun_server_hostname_, kDefaultStunServerPort);
+  Gather();
+  NrIceCandidate default_candidate;
+  ASSERT_TRUE(NS_SUCCEEDED(peer_->GetDefaultCandidate(0, &default_candidate)));
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherTurn) {
+  EnsurePeer();
+  if (turn_server_.empty())
+    return;
+  peer_->SetTurnServer(turn_server_, kDefaultStunServerPort,
+                       turn_user_, turn_password_, kNrIceTransportUdp);
+  Gather();
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherTurnTcp) {
+  EnsurePeer();
+  if (turn_server_.empty())
+    return;
+  peer_->SetTurnServer(turn_server_, kDefaultStunServerPort,
+                       turn_user_, turn_password_, kNrIceTransportTcp);
+  Gather();
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherDisableComponent) {
+  if (stun_server_hostname_.empty()) {
+    return;
+  }
+
+  EnsurePeer();
+  peer_->SetStunServer(stun_server_hostname_, kDefaultStunServerPort);
+  peer_->AddStream(2);
+  peer_->DisableComponent(1, 2);
+  Gather();
+  std::vector<std::string> candidates =
+    peer_->GetCandidates(1);
+
+  for (size_t i=0; i<candidates.size(); ++i) {
+    size_t sp1 = candidates[i].find(' ');
+    ASSERT_EQ(0, candidates[i].compare(sp1+1, 1, "1", 1));
+  }
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherVerifyNoLoopback) {
+  Gather();
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, "127.0.0.1"));
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherAllowLoopback) {
+  // Set up peer with loopback allowed.
+  peer_ = MakeUnique<IceTestPeer>("P1", test_utils_, true, true);
+  peer_->AddStream(1);
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "127.0.0.1"));
+}
+
+TEST_F(WebRtcIceGatherTest, TestGatherTcpDisabled) {
+  // Set up peer with tcp disabled.
+  peer_ = MakeUnique<IceTestPeer>("P1", test_utils_, true, false, false);
+  peer_->AddStream(1);
+  Gather();
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, " TCP "));
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " UDP "));
+}
+
+// Verify that a bogus candidate doesn't cause crashes on the
+// main thread. See bug 856433.
+TEST_F(WebRtcIceGatherTest, TestBogusCandidate) {
+  Gather();
+  peer_->ParseCandidate(0, kBogusIceCandidate);
+}
+
+TEST_F(WebRtcIceGatherTest, VerifyTestStunServer) {
+  UseFakeStunUdpServerWithResponse("192.0.2.133", 3333);
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " 192.0.2.133 3333 "));
+}
+
+TEST_F(WebRtcIceGatherTest, VerifyTestStunTcpServer) {
+  UseFakeStunTcpServerWithResponse("192.0.2.233", 3333);
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " 192.0.2.233 3333 typ srflx",
+    " tcptype "));
+}
+
+TEST_F(WebRtcIceGatherTest, VerifyTestStunServerV6) {
+  if (!TestStunServer::GetInstance(AF_INET6)) {
+    // No V6 addresses
+    return;
+  }
+  UseFakeStunUdpServerWithResponse("beef::", 3333);
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " beef:: 3333 "));
+}
+
+TEST_F(WebRtcIceGatherTest, VerifyTestStunServerFQDN) {
+  UseFakeStunUdpServerWithResponse("192.0.2.133", 3333, "stun.example.com");
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " 192.0.2.133 3333 "));
+}
+
+TEST_F(WebRtcIceGatherTest, VerifyTestStunServerV6FQDN) {
+  if (!TestStunServer::GetInstance(AF_INET6)) {
+    // No V6 addresses
+    return;
+  }
+  UseFakeStunUdpServerWithResponse("beef::", 3333, "stun.example.com");
+  Gather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " beef:: 3333 "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestStunServerReturnsWildcardAddr) {
+  UseFakeStunUdpServerWithResponse("0.0.0.0", 3333);
+  Gather(kDefaultTimeout * 3);
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, " 0.0.0.0 "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestStunServerReturnsWildcardAddrV6) {
+  if (!TestStunServer::GetInstance(AF_INET6)) {
+    // No V6 addresses
+    return;
+  }
+  UseFakeStunUdpServerWithResponse("::", 3333);
+  Gather(kDefaultTimeout * 3);
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, " :: "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestStunServerReturnsPort0) {
+  UseFakeStunUdpServerWithResponse("192.0.2.133", 0);
+  Gather(kDefaultTimeout * 3);
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, " 192.0.2.133 0 "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestStunServerReturnsLoopbackAddr) {
+  UseFakeStunUdpServerWithResponse("127.0.0.133", 3333);
+  Gather(kDefaultTimeout * 3);
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, " 127.0.0.133 "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestStunServerReturnsLoopbackAddrV6) {
+  if (!TestStunServer::GetInstance(AF_INET6)) {
+    // No V6 addresses
+    return;
+  }
+  UseFakeStunUdpServerWithResponse("::1", 3333);
+  Gather(kDefaultTimeout * 3);
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, " ::1 "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestStunServerTrickle) {
+  UseFakeStunUdpServerWithResponse("192.0.2.1", 3333);
+  TestStunServer::GetInstance(AF_INET)->SetDropInitialPackets(3);
+  Gather(0);
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, "192.0.2.1"));
+  WaitForGather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "192.0.2.1"));
+}
+
+// Test no host with our fake STUN server and apparently NATted.
+TEST_F(WebRtcIceGatherTest, TestFakeStunServerNatedNoHost) {
+  peer_ = MakeUnique<IceTestPeer>("P1", test_utils_, true, false, false, false, NrIceCtx::ICE_POLICY_NO_HOST);
+  peer_->AddStream(1);
+  UseFakeStunUdpServerWithResponse("192.0.2.1", 3333);
+  Gather(0);
+  WaitForGather();
+  DumpCandidates(0);
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, "host"));
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "srflx"));
+  NrIceCandidate default_candidate;
+  nsresult rv = peer_->GetDefaultCandidate(0, &default_candidate);
+  if (NS_SUCCEEDED(rv)) {
+    ASSERT_NE(NrIceCandidate::ICE_HOST, default_candidate.type);
+  }
+}
+
+// Test no host with our fake STUN server and apparently non-NATted.
+TEST_F(WebRtcIceGatherTest, TestFakeStunServerNoNatNoHost) {
+  peer_ = MakeUnique<IceTestPeer>("P1", test_utils_, true, false, false, false, NrIceCtx::ICE_POLICY_NO_HOST);
+  peer_->AddStream(1);
+  UseTestStunServer();
+  Gather(0);
+  WaitForGather();
+  DumpCandidates(0);
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, "host"));
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "srflx"));
+}
+
+TEST_F(WebRtcIceGatherTest, TestStunTcpServerTrickle) {
+  UseFakeStunTcpServerWithResponse("192.0.3.1", 3333);
+  TestStunTcpServer::GetInstance(AF_INET)->SetDelay(500);
+  Gather(0);
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, " 192.0.3.1 ", " tcptype "));
+  WaitForGather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " 192.0.3.1 ", " tcptype "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestStunTcpAndUdpServerTrickle) {
+  UseFakeStunUdpTcpServersWithResponse("192.0.2.1", 3333, "192.0.3.1", 3333);
+  TestStunServer::GetInstance(AF_INET)->SetDropInitialPackets(3);
+  TestStunTcpServer::GetInstance(AF_INET)->SetDelay(500);
+  Gather(0);
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, "192.0.2.1", "UDP"));
+  ASSERT_FALSE(StreamHasMatchingCandidate(0, " 192.0.3.1 ", " tcptype "));
+  WaitForGather();
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, "192.0.2.1", "UDP"));
+  ASSERT_TRUE(StreamHasMatchingCandidate(0, " 192.0.3.1 ", " tcptype "));
+}
+
+TEST_F(WebRtcIceGatherTest, TestSetIceControlling) {
+  EnsurePeer();
+  peer_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  NrIceCtx::Controlling controlling = peer_->GetControlling();
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLING, controlling);
+  // SetControlling should only allow setting this once
+  peer_->SetControlling(NrIceCtx::ICE_CONTROLLED);
+  controlling = peer_->GetControlling();
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLING, controlling);
+}
+
+TEST_F(WebRtcIceGatherTest, TestSetIceControlled) {
+  EnsurePeer();
+  peer_->SetControlling(NrIceCtx::ICE_CONTROLLED);
+  NrIceCtx::Controlling controlling = peer_->GetControlling();
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLED, controlling);
+  // SetControlling should only allow setting this once
+  peer_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  controlling = peer_->GetControlling();
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLED, controlling);
+}
+
+TEST_F(WebRtcIceConnectTest, TestGather) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+}
+
+TEST_F(WebRtcIceConnectTest, TestGatherTcp) {
+  Init(false, true);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+}
+
+TEST_F(WebRtcIceConnectTest, TestGatherAutoPrioritize) {
+  Init(false, false);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+}
+
+
+TEST_F(WebRtcIceConnectTest, TestConnect) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  Connect();
+}
+
+
+TEST_F(WebRtcIceConnectTest, TestConnectRestartIce) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  Connect();
+  SendReceive(p1_.get(), p2_.get());
+
+  p2_->RestartIce();
+  ASSERT_FALSE(p2_->gathering_complete());
+
+  // verify p1 and p2 streams are still connected after restarting ice on p2
+  SendReceive(p1_.get(), p2_.get());
+
+  mozilla::UniquePtr<IceTestPeer> p3_;
+  p3_ = MakeUnique<IceTestPeer>("P3", test_utils_, true, false, false, false);
+  InitPeer(p3_.get());
+  p3_->AddStream(1);
+
+  p2_->AddStream(1);
+  ASSERT_TRUE(GatherCallerAndCallee(p2_.get(), p3_.get()));
+  std::cout << "-------------------------------------------------" << std::endl;
+  ConnectCallerAndCallee(p3_.get(), p2_.get());
+  SendReceive(p1_.get(), p2_.get()); // p1 and p2 still connected
+  SendReceive(p3_.get(), p2_.get()); // p3 and p2 are now connected
+
+  p2_->FinalizeIceRestart();
+  SendReceive(p3_.get(), p2_.get()); // p3 and p2 are still connected
+
+  SendReceive(p1_.get(), p2_.get(), false, true); // p1 and p2 not connected
+
+  p3_ = nullptr;
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectRestartIceThenAbort) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  Connect();
+  SendReceive(p1_.get(), p2_.get());
+
+  p2_->RestartIce();
+  ASSERT_FALSE(p2_->gathering_complete());
+
+  // verify p1 and p2 streams are still connected after restarting ice on p2
+  SendReceive(p1_.get(), p2_.get());
+
+  mozilla::UniquePtr<IceTestPeer> p3_;
+  p3_ = MakeUnique<IceTestPeer>("P3", test_utils_, true, false, false, false);
+  InitPeer(p3_.get());
+  p3_->AddStream(1);
+
+  p2_->AddStream(1);
+  ASSERT_TRUE(GatherCallerAndCallee(p2_.get(), p3_.get()));
+  std::cout << "-------------------------------------------------" << std::endl;
+  ConnectCallerAndCallee(p3_.get(), p2_.get());
+  SendReceive(p1_.get(), p2_.get()); // p1 and p2 still connected
+  SendReceive(p3_.get(), p2_.get()); // p3 and p2 are now connected
+
+  p2_->RollbackIceRestart();
+  SendReceive(p1_.get(), p2_.get()); // p1 and p2 are still connected
+
+  SendReceive(p3_.get(), p2_.get(), false, true); // p3 and p2 not connected
+
+  p3_ = nullptr;
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectSetControllingAfterIceRestart) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  // Just for fun lets do this with switched rolls
+  p1_->SetControlling(NrIceCtx::ICE_CONTROLLED);
+  p2_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  Connect();
+  SendReceive(p1_.get(), p2_.get());
+  // Set rolls should not switch by connecting
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLED, p1_->GetControlling());
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLING, p2_->GetControlling());
+
+  p2_->RestartIce();
+  ASSERT_FALSE(p2_->gathering_complete());
+  // ICE restart should allow us to set control role again
+  p2_->SetControlling(NrIceCtx::ICE_CONTROLLED);
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLED, p2_->GetControlling());
+  // But still only allowed to set control role once
+  p2_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLED, p2_->GetControlling());
+
+  mozilla::UniquePtr<IceTestPeer> p3_;
+  p3_ = MakeUnique<IceTestPeer>("P3", test_utils_, true, false, false, false);
+  InitPeer(p3_.get());
+  p3_->AddStream(1);
+  // Set control role for p3 accordingly (w/o role conflict)
+  p3_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLING, p3_->GetControlling());
+
+  p2_->AddStream(1);
+  ASSERT_TRUE(GatherCallerAndCallee(p2_.get(), p3_.get()));
+  std::cout << "-------------------------------------------------" << std::endl;
+  ConnectCallerAndCallee(p3_.get(), p2_.get());
+  // Again connecting should not result in role switch
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLED, p2_->GetControlling());
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLING, p3_->GetControlling());
+
+  p2_->FinalizeIceRestart();
+  // And again we are not allowed to switch roles at this point any more
+  p2_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLED, p2_->GetControlling());
+  p3_->SetControlling(NrIceCtx::ICE_CONTROLLED);
+  ASSERT_EQ(NrIceCtx::ICE_CONTROLLING, p3_->GetControlling());
+
+  p3_ = nullptr;
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTcp) {
+  Init(false, true);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  SetCandidateFilter(IsTcpCandidate);
+  SetExpectedTypes(NrIceCandidate::Type::ICE_HOST,
+    NrIceCandidate::Type::ICE_HOST, kNrIceTransportTcp);
+  Connect();
+}
+
+//TCP SO tests works on localhost only with delay applied:
+//  tc qdisc add dev lo root netem delay 10ms
+TEST_F(WebRtcIceConnectTest, DISABLED_TestConnectTcpSo) {
+  Init(false, true);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  SetCandidateFilter(IsTcpSoCandidate);
+  SetExpectedTypes(NrIceCandidate::Type::ICE_HOST,
+    NrIceCandidate::Type::ICE_HOST, kNrIceTransportTcp);
+  Connect();
+}
+
+// Disabled because this breaks with hairpinning.
+TEST_F(WebRtcIceConnectTest, DISABLED_TestConnectNoHost) {
+  Init(false, false, false, NrIceCtx::ICE_POLICY_NO_HOST);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
+    NrIceCandidate::Type::ICE_SERVER_REFLEXIVE, kNrIceTransportTcp);
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestLoopbackOnlySortOf) {
+  Init(true, false, false);
+  AddStream(1);
+  SetCandidateFilter(IsLoopbackCandidate);
+  ASSERT_TRUE(Gather());
+  SetExpectedRemoteCandidateAddr("127.0.0.1");
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectBothControllingP1Wins) {
+  AddStream(1);
+  p1_->SetTiebreaker(1);
+  p2_->SetTiebreaker(0);
+  ASSERT_TRUE(Gather());
+  p1_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  p2_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectBothControllingP2Wins) {
+  AddStream(1);
+  p1_->SetTiebreaker(0);
+  p2_->SetTiebreaker(1);
+  ASSERT_TRUE(Gather());
+  p1_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  p2_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectIceLiteOfferer) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  p1_->SimulateIceLite();
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestTrickleBothControllingP1Wins) {
+  AddStream(1);
+  p1_->SetTiebreaker(1);
+  p2_->SetTiebreaker(0);
+  ASSERT_TRUE(Gather());
+  p1_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  p2_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  ConnectTrickle();
+  SimulateTrickle(0);
+  WaitForConnected(1000);
+  AssertCheckingReached();
+}
+
+TEST_F(WebRtcIceConnectTest, TestTrickleBothControllingP2Wins) {
+  AddStream(1);
+  p1_->SetTiebreaker(0);
+  p2_->SetTiebreaker(1);
+  ASSERT_TRUE(Gather());
+  p1_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  p2_->SetControlling(NrIceCtx::ICE_CONTROLLING);
+  ConnectTrickle();
+  SimulateTrickle(0);
+  WaitForConnected(1000);
+  AssertCheckingReached();
+}
+
+TEST_F(WebRtcIceConnectTest, TestTrickleIceLiteOfferer) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  p1_->SimulateIceLite();
+  ConnectTrickle();
+  SimulateTrickle(0);
+  WaitForConnected(1000);
+  AssertCheckingReached();
+}
+
+TEST_F(WebRtcIceConnectTest, TestGatherFullCone) {
+  UseNat();
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+}
+
+TEST_F(WebRtcIceConnectTest, TestGatherFullConeAutoPrioritize) {
+  UseNat();
+  Init(true, false);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+}
+
+
+TEST_F(WebRtcIceConnectTest, TestConnectFullCone) {
+  UseNat();
+  AddStream(1);
+  SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
+                   NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
+  ASSERT_TRUE(Gather());
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectNoNatNoHost) {
+  Init(false, false, false, NrIceCtx::ICE_POLICY_NO_HOST);
+  AddStream(1);
+  UseTestStunServer();
+  // Because we are connecting from our host candidate to the
+  // other side's apparent srflx (which is also their host)
+  // we see a host/srflx pair.
+  SetExpectedTypes(NrIceCandidate::Type::ICE_HOST,
+                   NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
+  ASSERT_TRUE(Gather());
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectFullConeNoHost) {
+  UseNat();
+  Init(false, false, false, NrIceCtx::ICE_POLICY_NO_HOST);
+  AddStream(1);
+  UseTestStunServer();
+  SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
+                   NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
+  ASSERT_TRUE(Gather());
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestGatherAddressRestrictedCone) {
+  UseNat();
+  SetFilteringType(TestNat::ADDRESS_DEPENDENT);
+  SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectAddressRestrictedCone) {
+  UseNat();
+  SetFilteringType(TestNat::ADDRESS_DEPENDENT);
+  SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
+  AddStream(1);
+  SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
+                   NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
+  ASSERT_TRUE(Gather());
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestGatherPortRestrictedCone) {
+  UseNat();
+  SetFilteringType(TestNat::PORT_DEPENDENT);
+  SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectPortRestrictedCone) {
+  UseNat();
+  SetFilteringType(TestNat::PORT_DEPENDENT);
+  SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
+  AddStream(1);
+  SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
+                   NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
+  ASSERT_TRUE(Gather());
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestGatherSymmetricNat) {
+  UseNat();
+  SetFilteringType(TestNat::PORT_DEPENDENT);
+  SetMappingType(TestNat::PORT_DEPENDENT);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectSymmetricNat) {
+  if (turn_server_.empty())
+    return;
+
+  UseNat();
+  SetFilteringType(TestNat::PORT_DEPENDENT);
+  SetMappingType(TestNat::PORT_DEPENDENT);
+  AddStream(1);
+  p1_->SetExpectedTypes(NrIceCandidate::Type::ICE_RELAYED,
+                        NrIceCandidate::Type::ICE_RELAYED);
+  p2_->SetExpectedTypes(NrIceCandidate::Type::ICE_RELAYED,
+                        NrIceCandidate::Type::ICE_RELAYED);
+  SetTurnServer(turn_server_, kDefaultStunServerPort,
+                turn_user_, turn_password_);
+  ASSERT_TRUE(Gather());
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectSymmetricNatAndNoNat) {
+  p1_ = MakeUnique<IceTestPeer>("P1", test_utils_, true, false, false);
+  p1_->UseNat();
+  p1_->SetFilteringType(TestNat::PORT_DEPENDENT);
+  p1_->SetMappingType(TestNat::PORT_DEPENDENT);
+
+  p2_ = MakeUnique<IceTestPeer>("P2", test_utils_, false, false, false);
+  initted_ = true;
+
+  AddStream(1);
+  p1_->SetExpectedTypes(NrIceCandidate::Type::ICE_PEER_REFLEXIVE,
+                        NrIceCandidate::Type::ICE_HOST);
+  p2_->SetExpectedTypes(NrIceCandidate::Type::ICE_HOST,
+                        NrIceCandidate::Type::ICE_PEER_REFLEXIVE);
+  ASSERT_TRUE(Gather());
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestGatherNatBlocksUDP) {
+  if (turn_server_.empty())
+    return;
+
+  UseNat();
+  BlockUdp();
+  AddStream(1);
+  std::vector<NrIceTurnServer> turn_servers;
+  std::vector<unsigned char> password_vec(turn_password_.begin(),
+                                          turn_password_.end());
+  turn_servers.push_back(
+      *NrIceTurnServer::Create(turn_server_, kDefaultStunServerPort,
+                               turn_user_, password_vec, kNrIceTransportTcp));
+  turn_servers.push_back(
+      *NrIceTurnServer::Create(turn_server_, kDefaultStunServerPort,
+                               turn_user_, password_vec, kNrIceTransportUdp));
+  SetTurnServers(turn_servers);
+  // We have to wait for the UDP-based stuff to time out.
+  ASSERT_TRUE(Gather(kDefaultTimeout * 3));
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectNatBlocksUDP) {
+  if (turn_server_.empty())
+    return;
+
+  UseNat();
+  BlockUdp();
+  AddStream(1);
+  std::vector<NrIceTurnServer> turn_servers;
+  std::vector<unsigned char> password_vec(turn_password_.begin(),
+                                          turn_password_.end());
+  turn_servers.push_back(
+      *NrIceTurnServer::Create(turn_server_, kDefaultStunServerPort,
+                               turn_user_, password_vec, kNrIceTransportTcp));
+  turn_servers.push_back(
+      *NrIceTurnServer::Create(turn_server_, kDefaultStunServerPort,
+                               turn_user_, password_vec, kNrIceTransportUdp));
+  SetTurnServers(turn_servers);
+  p1_->SetExpectedTypes(NrIceCandidate::Type::ICE_RELAYED,
+                        NrIceCandidate::Type::ICE_RELAYED,
+                        kNrIceTransportTcp);
+  p2_->SetExpectedTypes(NrIceCandidate::Type::ICE_RELAYED,
+                        NrIceCandidate::Type::ICE_RELAYED,
+                        kNrIceTransportTcp);
+  ASSERT_TRUE(Gather(kDefaultTimeout * 3));
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTwoComponents) {
+  AddStream(2);
+  ASSERT_TRUE(Gather());
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTwoComponentsDisableSecond) {
+  AddStream(2);
+  ASSERT_TRUE(Gather());
+  p1_->DisableComponent(0, 2);
+  p2_->DisableComponent(0, 2);
+  Connect();
+}
+
+
+TEST_F(WebRtcIceConnectTest, TestConnectP2ThenP1) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectP2();
+  PR_Sleep(1000);
+  ConnectP1();
+  WaitForConnectedStreams();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectP2ThenP1Trickle) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectP2();
+  PR_Sleep(1000);
+  ConnectP1(TRICKLE_SIMULATE);
+  SimulateTrickleP1(0);
+  WaitForConnectedStreams();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectP2ThenP1TrickleTwoComponents) {
+  AddStream(1);
+  AddStream(2);
+  ASSERT_TRUE(Gather());
+  ConnectP2();
+  PR_Sleep(1000);
+  ConnectP1(TRICKLE_SIMULATE);
+  SimulateTrickleP1(0);
+  std::cerr << "Sleeping between trickle streams" << std::endl;
+  PR_Sleep(1000);  // Give this some time to settle but not complete
+                   // all of ICE.
+  SimulateTrickleP1(1);
+  WaitForConnectedStreams(2);
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectAutoPrioritize) {
+  Init(false, false);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTrickleOneStreamOneComponent) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  SimulateTrickle(0);
+  WaitForConnected(1000);
+  AssertCheckingReached();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTrickleTwoStreamsOneComponent) {
+  AddStream(1);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  SimulateTrickle(0);
+  SimulateTrickle(1);
+  WaitForConnected(1000);
+  AssertCheckingReached();
+}
+
+void RealisticTrickleDelay(
+    std::vector<SchedulableTrickleCandidate*>& candidates) {
+  for (size_t i = 0; i < candidates.size(); ++i) {
+    SchedulableTrickleCandidate* cand = candidates[i];
+    if (cand->IsHost()) {
+      cand->Schedule(i*10);
+    } else if (cand->IsReflexive()) {
+      cand->Schedule(i*10 + 100);
+    } else if (cand->IsRelay()) {
+      cand->Schedule(i*10 + 200);
+    }
+  }
+}
+
+void DelayRelayCandidates(
+    std::vector<SchedulableTrickleCandidate*>& candidates,
+    unsigned int ms) {
+  for (auto i = candidates.begin(); i != candidates.end(); ++i) {
+    if ((*i)->IsRelay()) {
+      (*i)->Schedule(ms);
+    } else {
+      (*i)->Schedule(0);
+    }
+  }
+}
+
+void AddNonPairableCandidates(
+    std::vector<SchedulableTrickleCandidate*>& candidates,
+    IceTestPeer *peer, size_t stream, int net_type,
+    MtransportTestUtils* test_utils_) {
+  for (int i=1; i<5; i++) {
+    if (net_type == i)
+      continue;
+    switch (i) {
+      case 1:
+        candidates.push_back(new SchedulableTrickleCandidate(peer, stream,
+                   "candidate:0 1 UDP 2113601790 10.0.0.1 12345 typ host",
+                   test_utils_));
+        break;
+      case 2:
+        candidates.push_back(new SchedulableTrickleCandidate(peer, stream,
+                   "candidate:0 1 UDP 2113601791 172.16.1.1 12345 typ host",
+                   test_utils_));
+        break;
+      case 3:
+        candidates.push_back(new SchedulableTrickleCandidate(peer, stream,
+                   "candidate:0 1 UDP 2113601792 192.168.0.1 12345 typ host",
+                   test_utils_));
+        break;
+      case 4:
+        candidates.push_back(new SchedulableTrickleCandidate(peer, stream,
+                   "candidate:0 1 UDP 2113601793 100.64.1.1 12345 typ host",
+                   test_utils_));
+        break;
+      default:
+        UNIMPLEMENTED;
+    }
+  }
+
+  for (auto i = candidates.rbegin(); i != candidates.rend(); ++i) {
+    std::cerr << "Scheduling candidate: " << (*i)->Candidate().c_str() << std::endl;
+    (*i)->Schedule(0);
+  }
+}
+
+void DropTrickleCandidates(
+    std::vector<SchedulableTrickleCandidate*>& candidates) {
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTrickleAddStreamDuringICE) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  RealisticTrickleDelay(p1_->ControlTrickle(0));
+  RealisticTrickleDelay(p2_->ControlTrickle(0));
+  AddStream(1);
+  RealisticTrickleDelay(p1_->ControlTrickle(1));
+  RealisticTrickleDelay(p2_->ControlTrickle(1));
+  WaitForConnected(1000);
+  AssertCheckingReached();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTrickleAddStreamAfterICE) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  RealisticTrickleDelay(p1_->ControlTrickle(0));
+  RealisticTrickleDelay(p2_->ControlTrickle(0));
+  WaitForConnected(1000);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  RealisticTrickleDelay(p1_->ControlTrickle(1));
+  RealisticTrickleDelay(p2_->ControlTrickle(1));
+  WaitForConnected(1000);
+  AssertCheckingReached();
+}
+
+TEST_F(WebRtcIceConnectTest, RemoveStream) {
+  AddStream(1);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  RealisticTrickleDelay(p1_->ControlTrickle(0));
+  RealisticTrickleDelay(p2_->ControlTrickle(0));
+  RealisticTrickleDelay(p1_->ControlTrickle(1));
+  RealisticTrickleDelay(p2_->ControlTrickle(1));
+  WaitForConnected(1000);
+
+  RemoveStream(0);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+}
+
+TEST_F(WebRtcIceConnectTest, P1NoTrickle) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  DropTrickleCandidates(p1_->ControlTrickle(0));
+  RealisticTrickleDelay(p2_->ControlTrickle(0));
+  WaitForConnected(1000);
+}
+
+TEST_F(WebRtcIceConnectTest, P2NoTrickle) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  RealisticTrickleDelay(p1_->ControlTrickle(0));
+  DropTrickleCandidates(p2_->ControlTrickle(0));
+  WaitForConnected(1000);
+}
+
+TEST_F(WebRtcIceConnectTest, RemoveAndAddStream) {
+  AddStream(1);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  RealisticTrickleDelay(p1_->ControlTrickle(0));
+  RealisticTrickleDelay(p2_->ControlTrickle(0));
+  RealisticTrickleDelay(p1_->ControlTrickle(1));
+  RealisticTrickleDelay(p2_->ControlTrickle(1));
+  WaitForConnected(1000);
+
+  RemoveStream(0);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  RealisticTrickleDelay(p1_->ControlTrickle(2));
+  RealisticTrickleDelay(p2_->ControlTrickle(2));
+  WaitForConnected(1000);
+}
+
+TEST_F(WebRtcIceConnectTest, RemoveStreamBeforeGather) {
+  AddStream(1);
+  AddStream(1);
+  ASSERT_TRUE(Gather(0));
+  RemoveStream(0);
+  WaitForGather();
+  ConnectTrickle();
+  RealisticTrickleDelay(p1_->ControlTrickle(1));
+  RealisticTrickleDelay(p2_->ControlTrickle(1));
+  WaitForConnected(1000);
+}
+
+TEST_F(WebRtcIceConnectTest, RemoveStreamDuringGather) {
+  AddStream(1);
+  AddStream(1);
+  RemoveStream(0);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  RealisticTrickleDelay(p1_->ControlTrickle(1));
+  RealisticTrickleDelay(p2_->ControlTrickle(1));
+  WaitForConnected(1000);
+}
+
+TEST_F(WebRtcIceConnectTest, RemoveStreamDuringConnect) {
+  AddStream(1);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  RealisticTrickleDelay(p1_->ControlTrickle(0));
+  RealisticTrickleDelay(p2_->ControlTrickle(0));
+  RealisticTrickleDelay(p1_->ControlTrickle(1));
+  RealisticTrickleDelay(p2_->ControlTrickle(1));
+  RemoveStream(0);
+  WaitForConnected(1000);
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectRealTrickleOneStreamOneComponent) {
+  AddStream(1);
+  AddStream(1);
+  ASSERT_TRUE(Gather(0));
+  ConnectTrickle(TRICKLE_REAL);
+  WaitForConnected();
+  WaitForGather();  // ICE can complete before we finish gathering.
+  AssertCheckingReached();
+}
+
+TEST_F(WebRtcIceConnectTest, TestSendReceive) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  Connect();
+  SendReceive();
+}
+
+TEST_F(WebRtcIceConnectTest, TestSendReceiveTcp) {
+  Init(false, true);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  SetCandidateFilter(IsTcpCandidate);
+  SetExpectedTypes(NrIceCandidate::Type::ICE_HOST,
+    NrIceCandidate::Type::ICE_HOST, kNrIceTransportTcp);
+  Connect();
+  SendReceive();
+}
+
+//TCP SO tests works on localhost only with delay applied:
+//  tc qdisc add dev lo root netem delay 10ms
+TEST_F(WebRtcIceConnectTest, DISABLED_TestSendReceiveTcpSo) {
+  Init(false, true);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  SetCandidateFilter(IsTcpSoCandidate);
+  SetExpectedTypes(NrIceCandidate::Type::ICE_HOST,
+    NrIceCandidate::Type::ICE_HOST, kNrIceTransportTcp);
+  Connect();
+  SendReceive();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConsent) {
+  AddStream(1);
+  SetupAndCheckConsent();
+  PR_Sleep(1500);
+  AssertConsentRefresh();
+  SendReceive();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConsentTcp) {
+  Init(false, true);
+  AddStream(1);
+  SetCandidateFilter(IsTcpCandidate);
+  SetExpectedTypes(NrIceCandidate::Type::ICE_HOST,
+    NrIceCandidate::Type::ICE_HOST, kNrIceTransportTcp);
+  SetupAndCheckConsent();
+  PR_Sleep(1500);
+  AssertConsentRefresh();
+  SendReceive();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConsentIntermittent) {
+  AddStream(1);
+  SetupAndCheckConsent();
+  p1_->SetBlockStun(true);
+  p2_->SetBlockStun(true);
+  WaitForDisconnected();
+  AssertConsentRefresh(CONSENT_STALE);
+  SendReceive();
+  p1_->SetBlockStun(false);
+  p2_->SetBlockStun(false);
+  WaitForConnected();
+  AssertConsentRefresh();
+  SendReceive();
+  p1_->SetBlockStun(true);
+  p2_->SetBlockStun(true);
+  WaitForDisconnected();
+  AssertConsentRefresh(CONSENT_STALE);
+  SendReceive();
+  p1_->SetBlockStun(false);
+  p2_->SetBlockStun(false);
+  WaitForConnected();
+  AssertConsentRefresh();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConsentTimeout) {
+  AddStream(1);
+  SetupAndCheckConsent();
+  p1_->SetBlockStun(true);
+  p2_->SetBlockStun(true);
+  WaitForDisconnected();
+  AssertConsentRefresh(CONSENT_STALE);
+  SendReceive();
+  WaitForFailed();
+  AssertConsentRefresh(CONSENT_EXPIRED);
+  SendFailure();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConsentDelayed) {
+  AddStream(1);
+  SetupAndCheckConsent();
+  /* Note: We don't have a list of STUN transaction IDs of the previously timed
+           out consent requests. Thus responses after sending the next consent
+           request are ignored. */
+  p1_->SetStunResponseDelay(300);
+  p2_->SetStunResponseDelay(300);
+  PR_Sleep(1000);
+  AssertConsentRefresh();
+  SendReceive();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTurn) {
+  if (turn_server_.empty())
+    return;
+
+  AddStream(1);
+  SetTurnServer(turn_server_, kDefaultStunServerPort,
+                turn_user_, turn_password_);
+  ASSERT_TRUE(Gather());
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTurnWithDelay) {
+  if (turn_server_.empty())
+    return;
+
+  AddStream(1);
+  SetTurnServer(turn_server_, kDefaultStunServerPort,
+                turn_user_, turn_password_);
+  SetCandidateFilter(SabotageHostCandidateAndDropReflexive);
+  p1_->Gather();
+  PR_Sleep(500);
+  p2_->Gather();
+  ConnectTrickle(TRICKLE_REAL);
+  WaitForGather();
+  WaitForConnectedStreams();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTurnWithNormalTrickleDelay) {
+  if (turn_server_.empty())
+    return;
+
+  AddStream(1);
+  SetTurnServer(turn_server_, kDefaultStunServerPort,
+                turn_user_, turn_password_);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  RealisticTrickleDelay(p1_->ControlTrickle(0));
+  RealisticTrickleDelay(p2_->ControlTrickle(0));
+
+  WaitForConnected();
+  AssertCheckingReached();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTurnWithNormalTrickleDelayOneSided) {
+  if (turn_server_.empty())
+    return;
+
+  AddStream(1);
+  SetTurnServer(turn_server_, kDefaultStunServerPort,
+                turn_user_, turn_password_);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  RealisticTrickleDelay(p1_->ControlTrickle(0));
+  p2_->SimulateTrickle(0);
+
+  WaitForConnected();
+  AssertCheckingReached();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTurnWithLargeTrickleDelay) {
+  if (turn_server_.empty())
+    return;
+
+  AddStream(1);
+  SetTurnServer(turn_server_, kDefaultStunServerPort,
+                turn_user_, turn_password_);
+  SetCandidateFilter(SabotageHostCandidateAndDropReflexive);
+  ASSERT_TRUE(Gather());
+  ConnectTrickle();
+  // Trickle host candidates immediately, but delay relay candidates
+  DelayRelayCandidates(p1_->ControlTrickle(0), 3700);
+  DelayRelayCandidates(p2_->ControlTrickle(0), 3700);
+
+  WaitForConnected();
+  AssertCheckingReached();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTurnTcp) {
+  if (turn_server_.empty())
+    return;
+
+  AddStream(1);
+  SetTurnServer(turn_server_, kDefaultStunServerPort,
+                turn_user_, turn_password_, kNrIceTransportTcp);
+  ASSERT_TRUE(Gather());
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTurnOnly) {
+  if (turn_server_.empty())
+    return;
+
+  AddStream(1);
+  SetTurnServer(turn_server_, kDefaultStunServerPort,
+                turn_user_, turn_password_);
+  ASSERT_TRUE(Gather());
+  SetCandidateFilter(IsRelayCandidate);
+  SetExpectedTypes(NrIceCandidate::Type::ICE_RELAYED,
+                   NrIceCandidate::Type::ICE_RELAYED);
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectTurnTcpOnly) {
+  if (turn_server_.empty())
+    return;
+
+  AddStream(1);
+  SetTurnServer(turn_server_, kDefaultStunServerPort,
+                turn_user_, turn_password_, kNrIceTransportTcp);
+  ASSERT_TRUE(Gather());
+  SetCandidateFilter(IsRelayCandidate);
+  SetExpectedTypes(NrIceCandidate::Type::ICE_RELAYED,
+                   NrIceCandidate::Type::ICE_RELAYED,
+                   kNrIceTransportTcp);
+  Connect();
+}
+
+TEST_F(WebRtcIceConnectTest, TestSendReceiveTurnOnly) {
+  if (turn_server_.empty())
+    return;
+
+  AddStream(1);
+  SetTurnServer(turn_server_, kDefaultStunServerPort,
+                turn_user_, turn_password_);
+  ASSERT_TRUE(Gather());
+  SetCandidateFilter(IsRelayCandidate);
+  SetExpectedTypes(NrIceCandidate::Type::ICE_RELAYED,
+                   NrIceCandidate::Type::ICE_RELAYED);
+  Connect();
+  SendReceive();
+}
+
+TEST_F(WebRtcIceConnectTest, TestSendReceiveTurnTcpOnly) {
+  if (turn_server_.empty())
+    return;
+
+  AddStream(1);
+  SetTurnServer(turn_server_, kDefaultStunServerPort,
+                turn_user_, turn_password_, kNrIceTransportTcp);
+  ASSERT_TRUE(Gather());
+  SetCandidateFilter(IsRelayCandidate);
+  SetExpectedTypes(NrIceCandidate::Type::ICE_RELAYED,
+                   NrIceCandidate::Type::ICE_RELAYED,
+                   kNrIceTransportTcp);
+  Connect();
+  SendReceive();
+}
+
+TEST_F(WebRtcIceConnectTest, TestSendReceiveTurnBothOnly) {
+  if (turn_server_.empty())
+    return;
+
+  AddStream(1);
+  std::vector<NrIceTurnServer> turn_servers;
+  std::vector<unsigned char> password_vec(turn_password_.begin(),
+                                          turn_password_.end());
+  turn_servers.push_back(*NrIceTurnServer::Create(
+                           turn_server_, kDefaultStunServerPort,
+                           turn_user_, password_vec, kNrIceTransportTcp));
+  turn_servers.push_back(*NrIceTurnServer::Create(
+                           turn_server_, kDefaultStunServerPort,
+                           turn_user_, password_vec, kNrIceTransportUdp));
+  SetTurnServers(turn_servers);
+  ASSERT_TRUE(Gather());
+  SetCandidateFilter(IsRelayCandidate);
+  // UDP is preferred.
+  SetExpectedTypes(NrIceCandidate::Type::ICE_RELAYED,
+                   NrIceCandidate::Type::ICE_RELAYED,
+                   kNrIceTransportUdp);
+  Connect();
+  SendReceive();
+}
+
+TEST_F(WebRtcIceConnectTest, TestConnectShutdownOneSide) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  ConnectThenDelete();
+}
+
+TEST_F(WebRtcIceConnectTest, TestPollCandPairsBeforeConnect) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+
+  std::vector<NrIceCandidatePair> pairs;
+  nsresult res = p1_->GetCandidatePairs(0, &pairs);
+  // There should be no candidate pairs prior to calling Connect()
+  ASSERT_EQ(NS_OK, res);
+  ASSERT_EQ(0U, pairs.size());
+
+  res = p2_->GetCandidatePairs(0, &pairs);
+  ASSERT_EQ(NS_OK, res);
+  ASSERT_EQ(0U, pairs.size());
+}
+
+TEST_F(WebRtcIceConnectTest, TestPollCandPairsAfterConnect) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  Connect();
+
+  std::vector<NrIceCandidatePair> pairs;
+  nsresult r = p1_->GetCandidatePairs(0, &pairs);
+  ASSERT_EQ(NS_OK, r);
+  // How detailed of a check do we want to do here? If the turn server is
+  // functioning, we'll get at least two pairs, but this is probably not
+  // something we should assume.
+  ASSERT_NE(0U, pairs.size());
+  ASSERT_TRUE(p1_->CandidatePairsPriorityDescending(pairs));
+  ASSERT_TRUE(ContainsSucceededPair(pairs));
+  pairs.clear();
+
+  r = p2_->GetCandidatePairs(0, &pairs);
+  ASSERT_EQ(NS_OK, r);
+  ASSERT_NE(0U, pairs.size());
+  ASSERT_TRUE(p2_->CandidatePairsPriorityDescending(pairs));
+  ASSERT_TRUE(ContainsSucceededPair(pairs));
+}
+
+// TODO Bug 1259842 - disabled until we find a better way to handle two
+// candidates from different RFC1918 ranges
+TEST_F(WebRtcIceConnectTest, DISABLED_TestHostCandPairingFilter) {
+  Init(false, false, false);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  SetCandidateFilter(IsIpv4Candidate);
+
+  int host_net = p1_->GetCandidatesPrivateIpv4Range(0);
+  if (host_net <= 0) {
+    // TODO bug 1226838: make this work with multiple private IPs
+    FAIL() << "This test needs exactly one private IPv4 host candidate to work" << std::endl;
+  }
+
+  ConnectTrickle();
+  AddNonPairableCandidates(p1_->ControlTrickle(0), p1_.get(), 0, host_net, test_utils_);
+  AddNonPairableCandidates(p2_->ControlTrickle(0), p2_.get(), 0, host_net, test_utils_);
+
+  std::vector<NrIceCandidatePair> pairs;
+  p1_->GetCandidatePairs(0, &pairs);
+  for (auto p : pairs) {
+    std::cerr << "Verifying pair:" << std::endl;
+    p1_->DumpCandidatePair(p);
+    nr_transport_addr addr;
+    nr_str_port_to_transport_addr(p.local.local_addr.host.c_str(), 0, IPPROTO_UDP, &addr);
+    ASSERT_TRUE(nr_transport_addr_get_private_addr_range(&addr) == host_net);
+    nr_str_port_to_transport_addr(p.remote.cand_addr.host.c_str(), 0, IPPROTO_UDP, &addr);
+    ASSERT_TRUE(nr_transport_addr_get_private_addr_range(&addr) == host_net);
+  }
+}
+
+// TODO Bug 1226838 - See Comment 2 - this test can't work as written
+TEST_F(WebRtcIceConnectTest, DISABLED_TestSrflxCandPairingFilter) {
+  if (stun_server_address_.empty()) {
+    return;
+  }
+
+  Init(false, false, false);
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+  SetCandidateFilter(IsSrflxCandidate);
+
+  if (p1_->GetCandidatesPrivateIpv4Range(0) <= 0) {
+    // TODO bug 1226838: make this work with public IP addresses
+    std::cerr << "Don't run this test at IETF meetings!" << std::endl;
+    FAIL() << "This test needs one private IPv4 host candidate to work" << std::endl;
+  }
+
+  ConnectTrickle();
+  SimulateTrickleP1(0);
+  SimulateTrickleP2(0);
+
+  std::vector<NrIceCandidatePair> pairs;
+  p1_->GetCandidatePairs(0, &pairs);
+  for (auto p : pairs) {
+    std::cerr << "Verifying P1 pair:" << std::endl;
+    p1_->DumpCandidatePair(p);
+    nr_transport_addr addr;
+    nr_str_port_to_transport_addr(p.local.local_addr.host.c_str(), 0, IPPROTO_UDP, &addr);
+    ASSERT_TRUE(nr_transport_addr_get_private_addr_range(&addr) != 0);
+    nr_str_port_to_transport_addr(p.remote.cand_addr.host.c_str(), 0, IPPROTO_UDP, &addr);
+    ASSERT_TRUE(nr_transport_addr_get_private_addr_range(&addr) == 0);
+  }
+  p2_->GetCandidatePairs(0, &pairs);
+  for (auto p : pairs) {
+    std::cerr << "Verifying P2 pair:" << std::endl;
+    p2_->DumpCandidatePair(p);
+    nr_transport_addr addr;
+    nr_str_port_to_transport_addr(p.local.local_addr.host.c_str(), 0, IPPROTO_UDP, &addr);
+    ASSERT_TRUE(nr_transport_addr_get_private_addr_range(&addr) != 0);
+    nr_str_port_to_transport_addr(p.remote.cand_addr.host.c_str(), 0, IPPROTO_UDP, &addr);
+    ASSERT_TRUE(nr_transport_addr_get_private_addr_range(&addr) == 0);
+  }
+}
+
+TEST_F(WebRtcIceConnectTest, TestPollCandPairsDuringConnect) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+
+  p2_->Connect(p1_.get(), TRICKLE_NONE, false);
+  p1_->Connect(p2_.get(), TRICKLE_NONE, false);
+
+  std::vector<NrIceCandidatePair> pairs1;
+  std::vector<NrIceCandidatePair> pairs2;
+
+  p1_->StartChecks();
+  p1_->UpdateAndValidateCandidatePairs(0, &pairs1);
+  p2_->UpdateAndValidateCandidatePairs(0, &pairs2);
+
+  p2_->StartChecks();
+  p1_->UpdateAndValidateCandidatePairs(0, &pairs1);
+  p2_->UpdateAndValidateCandidatePairs(0, &pairs2);
+
+  WaitForConnectedStreams();
+  p1_->UpdateAndValidateCandidatePairs(0, &pairs1);
+  p2_->UpdateAndValidateCandidatePairs(0, &pairs2);
+  ASSERT_TRUE(ContainsSucceededPair(pairs1));
+  ASSERT_TRUE(ContainsSucceededPair(pairs2));
+}
+
+TEST_F(WebRtcIceConnectTest, TestRLogConnector) {
+  AddStream(1);
+  ASSERT_TRUE(Gather());
+
+  p2_->Connect(p1_.get(), TRICKLE_NONE, false);
+  p1_->Connect(p2_.get(), TRICKLE_NONE, false);
+
+  std::vector<NrIceCandidatePair> pairs1;
+  std::vector<NrIceCandidatePair> pairs2;
+
+  p1_->StartChecks();
+  p1_->UpdateAndValidateCandidatePairs(0, &pairs1);
+  p2_->UpdateAndValidateCandidatePairs(0, &pairs2);
+
+  p2_->StartChecks();
+  p1_->UpdateAndValidateCandidatePairs(0, &pairs1);
+  p2_->UpdateAndValidateCandidatePairs(0, &pairs2);
+
+  WaitForConnectedStreams();
+  p1_->UpdateAndValidateCandidatePairs(0, &pairs1);
+  p2_->UpdateAndValidateCandidatePairs(0, &pairs2);
+  ASSERT_TRUE(ContainsSucceededPair(pairs1));
+  ASSERT_TRUE(ContainsSucceededPair(pairs2));
+
+  for (auto p = pairs1.begin(); p != pairs1.end(); ++p) {
+    std::deque<std::string> logs;
+    std::string substring("CAND-PAIR(");
+    substring += p->codeword;
+    RLogConnector::GetInstance()->Filter(substring, 0, &logs);
+    ASSERT_NE(0U, logs.size());
+  }
+
+  for (auto p = pairs2.begin(); p != pairs2.end(); ++p) {
+    std::deque<std::string> logs;
+    std::string substring("CAND-PAIR(");
+    substring += p->codeword;
+    RLogConnector::GetInstance()->Filter(substring, 0, &logs);
+    ASSERT_NE(0U, logs.size());
+  }
+}
+
+TEST_F(WebRtcIcePrioritizerTest, TestPrioritizer) {
+  SetPriorizer(::mozilla::CreateInterfacePrioritizer());
+
+  AddInterface("0", NR_INTERFACE_TYPE_VPN, 100); // unknown vpn
+  AddInterface("1", NR_INTERFACE_TYPE_VPN | NR_INTERFACE_TYPE_WIRED, 100); // wired vpn
+  AddInterface("2", NR_INTERFACE_TYPE_VPN | NR_INTERFACE_TYPE_WIFI, 100); // wifi vpn
+  AddInterface("3", NR_INTERFACE_TYPE_VPN | NR_INTERFACE_TYPE_MOBILE, 100); // wifi vpn
+  AddInterface("4", NR_INTERFACE_TYPE_WIRED, 1000); // wired, high speed
+  AddInterface("5", NR_INTERFACE_TYPE_WIRED, 10); // wired, low speed
+  AddInterface("6", NR_INTERFACE_TYPE_WIFI, 10); // wifi, low speed
+  AddInterface("7", NR_INTERFACE_TYPE_WIFI, 1000); // wifi, high speed
+  AddInterface("8", NR_INTERFACE_TYPE_MOBILE, 10); // mobile, low speed
+  AddInterface("9", NR_INTERFACE_TYPE_MOBILE, 1000); // mobile, high speed
+  AddInterface("10", NR_INTERFACE_TYPE_UNKNOWN, 10); // unknown, low speed
+  AddInterface("11", NR_INTERFACE_TYPE_UNKNOWN, 1000); // unknown, high speed
+
+  // expected preference "4" > "5" > "1" > "7" > "6" > "2" > "9" > "8" > "3" > "11" > "10" > "0"
+
+  HasLowerPreference("0", "10");
+  HasLowerPreference("10", "11");
+  HasLowerPreference("11", "3");
+  HasLowerPreference("3", "8");
+  HasLowerPreference("8", "9");
+  HasLowerPreference("9", "2");
+  HasLowerPreference("2", "6");
+  HasLowerPreference("6", "7");
+  HasLowerPreference("7", "1");
+  HasLowerPreference("1", "5");
+  HasLowerPreference("5", "4");
+}
+
+TEST_F(WebRtcIcePacketFilterTest, TestSendNonStunPacket) {
+  const unsigned char data[] = "12345abcde";
+  TestOutgoing(data, sizeof(data), 123, 45, false);
+  TestOutgoingTcp(data, sizeof(data), false);
+}
+
+TEST_F(WebRtcIcePacketFilterTest, TestRecvNonStunPacket) {
+  const unsigned char data[] = "12345abcde";
+  TestIncoming(data, sizeof(data), 123, 45, false);
+  TestIncomingTcp(data, sizeof(data), true);
+}
+
+TEST_F(WebRtcIcePacketFilterTest, TestSendStunPacket) {
+  nr_stun_message *msg;
+  ASSERT_EQ(0, nr_stun_build_req_no_auth(NULL, &msg));
+  msg->header.type = NR_STUN_MSG_BINDING_REQUEST;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestOutgoing(msg->buffer, msg->length, 123, 45, true);
+  TestOutgoingTcp(msg->buffer, msg->length, true);
+  TestOutgoingTcpFramed(msg->buffer, msg->length, true);
+  ASSERT_EQ(0, nr_stun_message_destroy(&msg));
+}
+
+TEST_F(WebRtcIcePacketFilterTest, TestRecvStunPacketWithoutAPendingId) {
+  nr_stun_message *msg;
+  ASSERT_EQ(0, nr_stun_build_req_no_auth(NULL, &msg));
+
+  msg->header.id.octet[0] = 1;
+  msg->header.type = NR_STUN_MSG_BINDING_REQUEST;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestOutgoing(msg->buffer, msg->length, 123, 45, true);
+  TestOutgoingTcp(msg->buffer, msg->length, true);
+
+  msg->header.id.octet[0] = 0;
+  msg->header.type = NR_STUN_MSG_BINDING_RESPONSE;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestIncoming(msg->buffer, msg->length, 123, 45, true);
+  TestIncomingTcp(msg->buffer, msg->length, true);
+
+  ASSERT_EQ(0, nr_stun_message_destroy(&msg));
+}
+
+TEST_F(WebRtcIcePacketFilterTest, TestRecvStunPacketWithoutAPendingIdTcpFramed) {
+  nr_stun_message *msg;
+  ASSERT_EQ(0, nr_stun_build_req_no_auth(NULL, &msg));
+
+  msg->header.id.octet[0] = 1;
+  msg->header.type = NR_STUN_MSG_BINDING_REQUEST;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestOutgoingTcpFramed(msg->buffer, msg->length, true);
+
+  msg->header.id.octet[0] = 0;
+  msg->header.type = NR_STUN_MSG_BINDING_RESPONSE;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestIncomingTcpFramed(msg->buffer, msg->length, true);
+
+  ASSERT_EQ(0, nr_stun_message_destroy(&msg));
+}
+
+TEST_F(WebRtcIcePacketFilterTest, TestRecvStunPacketWithoutAPendingAddress) {
+  nr_stun_message *msg;
+  ASSERT_EQ(0, nr_stun_build_req_no_auth(NULL, &msg));
+
+  msg->header.type = NR_STUN_MSG_BINDING_REQUEST;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestOutgoing(msg->buffer, msg->length, 123, 45, true);
+  // nothing to test here for the TCP filter
+
+  msg->header.type = NR_STUN_MSG_BINDING_RESPONSE;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestIncoming(msg->buffer, msg->length, 123, 46, false);
+  TestIncoming(msg->buffer, msg->length, 124, 45, false);
+
+  ASSERT_EQ(0, nr_stun_message_destroy(&msg));
+}
+
+TEST_F(WebRtcIcePacketFilterTest, TestRecvStunPacketWithPendingIdAndAddress) {
+  nr_stun_message *msg;
+  ASSERT_EQ(0, nr_stun_build_req_no_auth(NULL, &msg));
+
+  msg->header.type = NR_STUN_MSG_BINDING_REQUEST;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestOutgoing(msg->buffer, msg->length, 123, 45, true);
+  TestOutgoingTcp(msg->buffer, msg->length, true);
+
+  msg->header.type = NR_STUN_MSG_BINDING_RESPONSE;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestIncoming(msg->buffer, msg->length, 123, 45, true);
+  TestIncomingTcp(msg->buffer, msg->length, true);
+
+  // Test whitelist by filtering non-stun packets.
+  const unsigned char data[] = "12345abcde";
+
+  // 123:45 is white-listed.
+  TestOutgoing(data, sizeof(data), 123, 45, true);
+  TestOutgoingTcp(data, sizeof(data), true);
+  TestIncoming(data, sizeof(data), 123, 45, true);
+  TestIncomingTcp(data, sizeof(data), true);
+
+  // Indications pass as well.
+  msg->header.type = NR_STUN_MSG_BINDING_INDICATION;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestOutgoing(msg->buffer, msg->length, 123, 45, true);
+  TestOutgoingTcp(msg->buffer, msg->length, true);
+  TestIncoming(msg->buffer, msg->length, 123, 45, true);
+  TestIncomingTcp(msg->buffer, msg->length, true);
+
+  // Packets from and to other address are still disallowed.
+  // Note: this doesn't apply for TCP connections
+  TestOutgoing(data, sizeof(data), 123, 46, false);
+  TestIncoming(data, sizeof(data), 123, 46, false);
+  TestOutgoing(data, sizeof(data), 124, 45, false);
+  TestIncoming(data, sizeof(data), 124, 45, false);
+
+  ASSERT_EQ(0, nr_stun_message_destroy(&msg));
+}
+
+TEST_F(WebRtcIcePacketFilterTest, TestRecvStunPacketWithPendingIdTcpFramed) {
+  nr_stun_message *msg;
+  ASSERT_EQ(0, nr_stun_build_req_no_auth(NULL, &msg));
+
+  msg->header.type = NR_STUN_MSG_BINDING_REQUEST;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestOutgoingTcpFramed(msg->buffer, msg->length, true);
+
+  msg->header.type = NR_STUN_MSG_BINDING_RESPONSE;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestIncomingTcpFramed(msg->buffer, msg->length, true);
+
+  // Test whitelist by filtering non-stun packets.
+  const unsigned char data[] = "12345abcde";
+
+  TestOutgoingTcpFramed(data, sizeof(data), true);
+  TestIncomingTcpFramed(data, sizeof(data), true);
+
+  ASSERT_EQ(0, nr_stun_message_destroy(&msg));
+}
+
+TEST_F(WebRtcIcePacketFilterTest, TestSendNonRequestStunPacket) {
+  nr_stun_message *msg;
+  ASSERT_EQ(0, nr_stun_build_req_no_auth(NULL, &msg));
+
+  msg->header.type = NR_STUN_MSG_BINDING_RESPONSE;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestOutgoing(msg->buffer, msg->length, 123, 45, false);
+  TestOutgoingTcp(msg->buffer, msg->length, false);
+
+  // Send a packet so we allow the incoming request.
+  msg->header.type = NR_STUN_MSG_BINDING_REQUEST;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestOutgoing(msg->buffer, msg->length, 123, 45, true);
+  TestOutgoingTcp(msg->buffer, msg->length, true);
+
+  // This packet makes us able to send a response.
+  msg->header.type = NR_STUN_MSG_BINDING_REQUEST;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestIncoming(msg->buffer, msg->length, 123, 45, true);
+  TestIncomingTcp(msg->buffer, msg->length, true);
+
+  msg->header.type = NR_STUN_MSG_BINDING_RESPONSE;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestOutgoing(msg->buffer, msg->length, 123, 45, true);
+  TestOutgoingTcp(msg->buffer, msg->length, true);
+
+  ASSERT_EQ(0, nr_stun_message_destroy(&msg));
+}
+
+TEST_F(WebRtcIcePacketFilterTest, TestRecvDataPacketWithAPendingAddress) {
+  nr_stun_message *msg;
+  ASSERT_EQ(0, nr_stun_build_req_no_auth(NULL, &msg));
+
+  msg->header.type = NR_STUN_MSG_BINDING_REQUEST;
+  ASSERT_EQ(0, nr_stun_encode_message(msg));
+  TestOutgoing(msg->buffer, msg->length, 123, 45, true);
+  TestOutgoingTcp(msg->buffer, msg->length, true);
+
+  const unsigned char data[] = "12345abcde";
+  TestIncoming(data, sizeof(data), 123, 45, true);
+  TestIncomingTcp(data, sizeof(data), true);
+
+  ASSERT_EQ(0, nr_stun_message_destroy(&msg));
+}
+
+TEST(WebRtcIceInternalsTest, TestAddBogusAttribute) {
+  nr_stun_message *req;
+  ASSERT_EQ(0, nr_stun_message_create(&req));
+  Data *data;
+  ASSERT_EQ(0, r_data_alloc(&data, 3000));
+  memset(data->data, 'A', data->len);
+  ASSERT_TRUE(nr_stun_message_add_message_integrity_attribute(req, data));
+  ASSERT_EQ(0, r_data_destroy(&data));
+  ASSERT_EQ(0, nr_stun_message_destroy(&req));
+}
diff --git a/media/mtransport/test/moz.build b/media/mtransport/test/moz.build
new file mode 100644
index 000000000..e8f453787
--- /dev/null
+++ b/media/mtransport/test/moz.build
@@ -0,0 +1,100 @@
+# -*- Mode: python; indent-tabs-mode: nil; tab-width: 40 -*-
+# vim: set filetype=python:
+# This Source Code Form is subject to the terms of the Mozilla Public
+# License, v. 2.0. If a copy of the MPL was not distributed with this
+# file, You can obtain one at http://mozilla.org/MPL/2.0/.
+
+if CONFIG['OS_TARGET'] != 'WINNT' and CONFIG['MOZ_WIDGET_TOOLKIT'] != 'gonk':
+    SOURCES += [
+        'buffered_stun_socket_unittest.cpp',
+        'ice_unittest.cpp',
+        'multi_tcp_socket_unittest.cpp',
+        'nrappkit_unittest.cpp',
+        'proxy_tunnel_socket_unittest.cpp',
+        'rlogconnector_unittest.cpp',
+        'runnable_utils_unittest.cpp',
+        'simpletokenbucket_unittest.cpp',
+        'sockettransportservice_unittest.cpp',
+        'stunserver.cpp',
+        'test_nr_socket_unittest.cpp',
+        'TestSyncRunnable.cpp',
+        'transport_unittests.cpp',
+        'turn_unittest.cpp',
+    ]
+
+    if CONFIG['MOZ_SCTP']:
+        SOURCES += [
+            'sctp_unittest.cpp',
+        ]
+
+
+for var in ('HAVE_STRDUP', 'NR_SOCKET_IS_VOID_PTR', 'SCTP_DEBUG', 'INET'):
+    DEFINES[var] = True
+
+if CONFIG['OS_TARGET'] == 'Android':
+    DEFINES['LINUX'] = True
+    DEFINES['ANDROID'] = True
+    LOCAL_INCLUDES += [
+        '/media/mtransport/third_party/nrappkit/src/port/android/include',
+    ]
+else:
+    DEFINES['INET6'] = True
+
+if CONFIG['OS_TARGET'] == 'Linux':
+    DEFINES['LINUX'] = True
+    LOCAL_INCLUDES += [
+        '/media/mtransport/third_party/nrappkit/src/port/linux/include',
+    ]
+
+if CONFIG['OS_TARGET'] == 'Darwin':
+    LOCAL_INCLUDES += [
+        '/media/mtransport/third_party/nrappkit/src/port/darwin/include',
+    ]
+
+if CONFIG['OS_TARGET'] in ('DragonFly', 'FreeBSD', 'NetBSD', 'OpenBSD'):
+    if CONFIG['OS_TARGET'] == 'Darwin':
+        DEFINES['DARWIN'] = True
+    else:
+        DEFINES['BSD'] = True
+    LOCAL_INCLUDES += [
+        '/media/mtransport/third_party/nrappkit/src/port/darwin/include',
+    ]
+
+# SCTP DEFINES
+if CONFIG['OS_TARGET'] == 'WINNT':
+    DEFINES['WIN'] = True
+    # for stun.h
+    DEFINES['WIN32'] = True
+    DEFINES['__Userspace_os_Windows'] = 1
+else:
+    # Works for Darwin, Linux, Android. Probably doesn't work for others.
+    DEFINES['__Userspace_os_%s' % CONFIG['OS_TARGET']] = 1
+
+if CONFIG['OS_TARGET'] in ('Darwin', 'Android'):
+    DEFINES['GTEST_USE_OWN_TR1_TUPLE'] = 1
+
+LOCAL_INCLUDES += [
+    '/media/mtransport/',
+    '/media/mtransport/third_party/',
+    '/media/mtransport/third_party/nICEr/src/crypto',
+    '/media/mtransport/third_party/nICEr/src/ice',
+    '/media/mtransport/third_party/nICEr/src/net',
+    '/media/mtransport/third_party/nICEr/src/stun',
+    '/media/mtransport/third_party/nICEr/src/util',
+    '/media/mtransport/third_party/nrappkit/src/event',
+    '/media/mtransport/third_party/nrappkit/src/log',
+    '/media/mtransport/third_party/nrappkit/src/plugin',
+    '/media/mtransport/third_party/nrappkit/src/port/generic/include',
+    '/media/mtransport/third_party/nrappkit/src/registry',
+    '/media/mtransport/third_party/nrappkit/src/share',
+    '/media/mtransport/third_party/nrappkit/src/stats',
+    '/media/mtransport/third_party/nrappkit/src/util/',
+    '/media/mtransport/third_party/nrappkit/src/util/libekr',
+    '/netwerk/sctp/src/',
+    '/xpcom/tests/'
+]
+
+FINAL_LIBRARY = 'xul-gtest'
+
+if CONFIG['GNU_CXX']:
+    CXXFLAGS += ['-Wno-error=shadow']
diff --git a/media/mtransport/test/mtransport_test_utils.h b/media/mtransport/test/mtransport_test_utils.h
new file mode 100644
index 000000000..81c16ff83
--- /dev/null
+++ b/media/mtransport/test/mtransport_test_utils.h
@@ -0,0 +1,52 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: ekr@rtfm.com
+
+#ifndef mtransport_test_utils_h__
+#define mtransport_test_utils_h__
+
+#include "nsCOMPtr.h"
+#include "nsNetCID.h"
+
+#include "nsIEventTarget.h"
+#include "nsPISocketTransportService.h"
+#include "nsServiceManagerUtils.h"
+
+class MtransportTestUtils {
+ public:
+  MtransportTestUtils() {
+      InitServices();
+  }
+
+  ~MtransportTestUtils() {
+  }
+
+  void InitServices() {
+    nsresult rv;
+    sts_target_ = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+    MOZ_ASSERT(NS_SUCCEEDED(rv));
+    sts_ = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+    MOZ_ASSERT(NS_SUCCEEDED(rv));
+  }
+
+  nsIEventTarget* sts_target() { return sts_target_; }
+
+ private:
+  nsCOMPtr<nsIEventTarget> sts_target_;
+  nsCOMPtr<nsPISocketTransportService> sts_;
+};
+
+
+#define CHECK_ENVIRONMENT_FLAG(envname) \
+  char *test_flag = getenv(envname); \
+  if (!test_flag || strcmp(test_flag, "1")) { \
+    printf("To run this test set %s=1 in your environment\n", envname); \
+    exit(0); \
+  } \
+
+
+#endif
diff --git a/media/mtransport/test/multi_tcp_socket_unittest.cpp b/media/mtransport/test/multi_tcp_socket_unittest.cpp
new file mode 100644
index 000000000..7e513181f
--- /dev/null
+++ b/media/mtransport/test/multi_tcp_socket_unittest.cpp
@@ -0,0 +1,540 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+#include <iostream>
+#include <vector>
+
+#include "mozilla/Atomics.h"
+#include "runnable_utils.h"
+#include "nss.h"
+#include "pk11pub.h"
+
+extern "C" {
+#include "nr_api.h"
+#include "nr_socket.h"
+#include "transport_addr.h"
+#include "ice_ctx.h"
+#include "nr_socket_multi_tcp.h"
+}
+
+#include "nr_socket_prsock.h"
+
+#include "stunserver.h"
+
+#include "nricectxhandler.h"
+#include "nricemediastream.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+using namespace mozilla;
+
+namespace {
+
+class MultiTcpSocketTest : public MtransportTest {
+ public:
+  MultiTcpSocketTest()
+    :MtransportTest(),
+     socks(3,nullptr),
+     readable(false),
+     ice_ctx_()
+   {}
+
+  void SetUp() {
+    MtransportTest::SetUp();
+
+    ice_ctx_ = NrIceCtxHandler::Create("stun", true);
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableNM(&TestStunTcpServer::GetInstance, AF_INET),
+                       NS_DISPATCH_SYNC);
+    test_utils_->sts_target()->Dispatch(
+      WrapRunnableNM(&TestStunTcpServer::GetInstance, AF_INET6),
+                     NS_DISPATCH_SYNC);
+  }
+
+
+  void TearDown() {
+    test_utils_->sts_target()->Dispatch(
+            WrapRunnable(
+                this, &MultiTcpSocketTest::Shutdown_s),
+            NS_DISPATCH_SYNC);
+
+    MtransportTest::TearDown();
+  }
+
+  DISALLOW_COPY_ASSIGN(MultiTcpSocketTest);
+
+  static void SockReadable(NR_SOCKET s, int how, void *arg) {
+    MultiTcpSocketTest *obj=static_cast<MultiTcpSocketTest *>(arg);
+    obj->SetReadable(true);
+  }
+
+  void Shutdown_s() {
+    ice_ctx_ = nullptr;
+    for (std::vector<nr_socket *>::iterator it=socks.begin();
+         it!=socks.end(); ++it) {
+      nr_socket_destroy(&(*it));
+    }
+  }
+
+  static uint16_t GetRandomPort() {
+    uint16_t result;
+    if (PK11_GenerateRandom((unsigned char*)&result, 2) != SECSuccess) {
+      MOZ_ASSERT(false);
+      return 0;
+    }
+    return result;
+  }
+
+  static uint16_t EnsureEphemeral(uint16_t port) {
+    // IANA ephemeral port range (49152 to 65535)
+    return port | 49152;
+  }
+
+  void Create_s(nr_socket_tcp_type tcp_type, std::string stun_server_addr,
+                uint16_t stun_server_port, nr_socket **sock) {
+    nr_transport_addr local;
+    // Get start of port range for test
+    static unsigned short port_s = GetRandomPort();
+    int r;
+
+    if (!stun_server_addr.empty()) {
+      std::vector<NrIceStunServer> stun_servers;
+      UniquePtr<NrIceStunServer> server(NrIceStunServer::Create(
+          stun_server_addr, stun_server_port, kNrIceTransportTcp));
+      stun_servers.push_back(*server);
+
+      ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetStunServers(stun_servers)));
+    }
+
+    r = 1;
+    for (int tries=10; tries && r; --tries) {
+      r = nr_str_port_to_transport_addr(
+        (char *)"127.0.0.1", EnsureEphemeral(port_s++), IPPROTO_TCP, &local);
+      ASSERT_EQ(0, r);
+
+      r = nr_socket_multi_tcp_create(ice_ctx_->ctx()->ctx(),
+          &local, tcp_type, 1, 2048, sock);
+    }
+
+    ASSERT_EQ(0, r);
+    printf("Creating socket on %s\n", local.as_string);
+    r = nr_socket_multi_tcp_set_readable_cb(*sock,
+        &MultiTcpSocketTest::SockReadable, this);
+    ASSERT_EQ(0, r);
+  }
+
+  nr_socket *Create(nr_socket_tcp_type tcp_type,
+                    std::string stun_server_addr = "",
+                    uint16_t stun_server_port = 0) {
+    nr_socket *sock=nullptr;
+    test_utils_->sts_target()->Dispatch(
+            WrapRunnable(
+                this, &MultiTcpSocketTest::Create_s, tcp_type,
+                stun_server_addr, stun_server_port, &sock),
+            NS_DISPATCH_SYNC);
+    return sock;
+  }
+
+  void Listen_s(nr_socket *sock) {
+    nr_transport_addr addr;
+    int r=nr_socket_getaddr(sock, &addr);
+    ASSERT_EQ(0, r);
+    printf("Listening on %s\n", addr.as_string);
+    r = nr_socket_listen(sock, 5);
+    ASSERT_EQ(0, r);
+  }
+
+  void Listen(nr_socket *sock) {
+    test_utils_->sts_target()->Dispatch(
+            WrapRunnable(
+                this, &MultiTcpSocketTest::Listen_s, sock),
+            NS_DISPATCH_SYNC);
+  }
+
+  void Destroy_s(nr_socket *sock) {
+    int r = nr_socket_destroy(&sock);
+    ASSERT_EQ(0, r);
+  }
+
+  void Destroy(nr_socket *sock) {
+    test_utils_->sts_target()->Dispatch(
+            WrapRunnable(
+                this, &MultiTcpSocketTest::Destroy_s, sock),
+            NS_DISPATCH_SYNC);
+  }
+
+  void Connect_s(nr_socket *from, nr_socket *to) {
+    nr_transport_addr addr_to;
+    nr_transport_addr addr_from;
+    int r=nr_socket_getaddr(to, &addr_to);
+    ASSERT_EQ(0, r);
+    r=nr_socket_getaddr(from, &addr_from);
+    ASSERT_EQ(0, r);
+    printf("Connecting from %s to %s\n", addr_from.as_string, addr_to.as_string);
+    r=nr_socket_connect(from, &addr_to);
+    ASSERT_EQ(0, r);
+  }
+
+  void Connect(nr_socket *from, nr_socket *to) {
+    test_utils_->sts_target()->Dispatch(
+            WrapRunnable(
+                this, &MultiTcpSocketTest::Connect_s, from, to),
+            NS_DISPATCH_SYNC);
+  }
+
+  void ConnectSo_s(nr_socket *so1, nr_socket *so2) {
+    nr_transport_addr addr_so1;
+    nr_transport_addr addr_so2;
+    int r=nr_socket_getaddr(so1, &addr_so1);
+    ASSERT_EQ(0, r);
+    r=nr_socket_getaddr(so2, &addr_so2);
+    ASSERT_EQ(0, r);
+    printf("Connecting SO %s <-> %s\n", addr_so1.as_string, addr_so2.as_string);
+    r=nr_socket_connect(so1, &addr_so2);
+    ASSERT_EQ(0, r);
+    r=nr_socket_connect(so2, &addr_so1);
+    ASSERT_EQ(0, r);
+  }
+
+  void ConnectSo(nr_socket *from, nr_socket *to) {
+    test_utils_->sts_target()->Dispatch(
+            WrapRunnable(
+                this, &MultiTcpSocketTest::ConnectSo_s, from, to),
+            NS_DISPATCH_SYNC);
+  }
+
+  void SendDataToAddress_s(nr_socket *from, nr_transport_addr *to, const char *data,
+                           size_t len) {
+    nr_transport_addr addr_from;
+
+    int r=nr_socket_getaddr(from, &addr_from);
+    ASSERT_EQ(0, r);
+    printf("Sending %lu bytes %s -> %s\n", (unsigned long)len,
+      addr_from.as_string, to->as_string);
+    r=nr_socket_sendto(from, data, len, 0, to);
+    ASSERT_EQ(0, r);
+  }
+
+  void SendData(nr_socket *from, nr_transport_addr *to, const char *data, size_t len) {
+    test_utils_->sts_target()->Dispatch(
+            WrapRunnable(
+                this, &MultiTcpSocketTest::SendDataToAddress_s, from, to, data,
+                len),
+            NS_DISPATCH_SYNC);
+  }
+
+  void SendDataToSocket_s(nr_socket *from, nr_socket *to, const char *data,
+                  size_t len) {
+    nr_transport_addr addr_to;
+
+    int r=nr_socket_getaddr(to, &addr_to);
+    ASSERT_EQ(0, r);
+    SendDataToAddress_s(from, &addr_to, data, len);
+  }
+
+  void SendData(nr_socket *from, nr_socket *to, const char *data, size_t len) {
+    test_utils_->sts_target()->Dispatch(
+            WrapRunnable(
+                this, &MultiTcpSocketTest::SendDataToSocket_s, from, to, data,
+                len),
+            NS_DISPATCH_SYNC);
+  }
+
+  void RecvDataFromAddress_s(nr_transport_addr *expected_from,
+                             nr_socket *sent_to,
+                             const char *expected_data,
+                             size_t expected_len) {
+    SetReadable(false);
+    size_t buflen = expected_len ? expected_len+1 : 100;
+    char received_data[buflen];
+    nr_transport_addr addr_to;
+    nr_transport_addr retaddr;
+    size_t retlen;
+
+    int r=nr_socket_getaddr(sent_to, &addr_to);
+    ASSERT_EQ(0, r);
+    printf("Receiving %lu bytes %s <- %s\n", (unsigned long)expected_len,
+      addr_to.as_string, expected_from->as_string);
+    r=nr_socket_recvfrom(sent_to, received_data, buflen,
+                         &retlen, 0, &retaddr);
+    ASSERT_EQ(0, r);
+    r=nr_transport_addr_cmp(&retaddr, expected_from,
+                            NR_TRANSPORT_ADDR_CMP_MODE_ALL);
+    ASSERT_EQ(0, r);
+    // expected_len == 0 means we just expected some data
+    if (expected_len == 0) {
+      ASSERT_GT(retlen, 0U);
+    } else {
+      ASSERT_EQ(expected_len, retlen);
+      r=memcmp(expected_data, received_data, retlen);
+      ASSERT_EQ(0, r);
+    }
+  }
+
+  void RecvData(nr_transport_addr *expected_from, nr_socket *sent_to,
+                const char *expected_data = nullptr, size_t expected_len = 0) {
+    ASSERT_TRUE_WAIT(IsReadable(), 1000);
+    test_utils_->sts_target()->Dispatch(
+            WrapRunnable(
+                this, &MultiTcpSocketTest::RecvDataFromAddress_s,
+                expected_from, sent_to, expected_data,
+                expected_len),
+            NS_DISPATCH_SYNC);
+  }
+
+  void RecvDataFromSocket_s(nr_socket *expected_from, nr_socket *sent_to,
+                            const char *expected_data, size_t expected_len) {
+    nr_transport_addr addr_from;
+
+    int r=nr_socket_getaddr(expected_from, &addr_from);
+    ASSERT_EQ(0, r);
+
+    RecvDataFromAddress_s(&addr_from, sent_to, expected_data, expected_len);
+  }
+
+  void RecvData(nr_socket *expected_from, nr_socket *sent_to,
+                const char *expected_data, size_t expected_len) {
+    ASSERT_TRUE_WAIT(IsReadable(), 1000);
+    test_utils_->sts_target()->Dispatch(
+            WrapRunnable(
+                this, &MultiTcpSocketTest::RecvDataFromSocket_s,
+                expected_from, sent_to, expected_data, expected_len),
+            NS_DISPATCH_SYNC);
+  }
+
+  void RecvDataFailed_s(nr_socket *sent_to, size_t expected_len, int expected_err) {
+    SetReadable(false);
+    char received_data[expected_len+1];
+    nr_transport_addr addr_to;
+    nr_transport_addr retaddr;
+    size_t retlen;
+
+    int r=nr_socket_getaddr(sent_to, &addr_to);
+    ASSERT_EQ(0, r);
+    r=nr_socket_recvfrom(sent_to, received_data, expected_len+1,
+                         &retlen, 0, &retaddr);
+    ASSERT_EQ(expected_err, r) << "Expecting receive failure " << expected_err
+    << " on " << addr_to.as_string;
+  }
+
+  void RecvDataFailed(nr_socket *sent_to, size_t expected_len,
+                      int expected_err) {
+    ASSERT_TRUE_WAIT(IsReadable(), 1000);
+    test_utils_->sts_target()->Dispatch(
+            WrapRunnable(
+                this, &MultiTcpSocketTest::RecvDataFailed_s, sent_to, expected_len,
+                expected_err),
+            NS_DISPATCH_SYNC);
+  }
+
+  void TransferData(nr_socket *from, nr_socket *to, const char *data,
+                    size_t len) {
+    SendData(from, to, data, len);
+    RecvData(from, to, data, len);
+  }
+
+ protected:
+  bool IsReadable() const {
+    return readable;
+  }
+  void SetReadable(bool r) {
+    readable=r;
+  }
+  std::vector<nr_socket *> socks;
+  Atomic<bool> readable;
+  RefPtr<NrIceCtxHandler> ice_ctx_;
+};
+}
+
+TEST_F(MultiTcpSocketTest, TestListen) {
+  socks[0] = Create(TCP_TYPE_PASSIVE);
+  Listen(socks[0]);
+}
+
+TEST_F(MultiTcpSocketTest, TestConnect) {
+  socks[0] = Create(TCP_TYPE_PASSIVE);
+  socks[1] = Create(TCP_TYPE_ACTIVE);
+  socks[2] = Create(TCP_TYPE_ACTIVE);
+  Listen(socks[0]);
+  Connect(socks[1], socks[0]);
+  Connect(socks[2], socks[0]);
+}
+
+TEST_F(MultiTcpSocketTest, TestTransmit) {
+  const char data[] = "TestTransmit";
+  socks[0] = Create(TCP_TYPE_ACTIVE);
+  socks[1] = Create(TCP_TYPE_PASSIVE);
+  Listen(socks[1]);
+  Connect(socks[0], socks[1]);
+
+  TransferData(socks[0], socks[1], data, sizeof(data));
+  TransferData(socks[1], socks[0], data, sizeof(data));
+}
+
+TEST_F(MultiTcpSocketTest, TestClosePassive) {
+  const char data[] = "TestClosePassive";
+  socks[0] = Create(TCP_TYPE_ACTIVE);
+  socks[1] = Create(TCP_TYPE_PASSIVE);
+  Listen(socks[1]);
+  Connect(socks[0], socks[1]);
+
+  TransferData(socks[0], socks[1], data, sizeof(data));
+  TransferData(socks[1], socks[0], data, sizeof(data));
+
+  /* We have to destroy as only that calls PR_Close() */
+  std::cerr << "Destructing socket" << std::endl;
+  Destroy(socks[1]);
+
+  RecvDataFailed(socks[0], sizeof(data), R_EOD);
+
+  socks[1] = nullptr;
+}
+
+TEST_F(MultiTcpSocketTest, TestCloseActive) {
+  const char data[] = "TestCloseActive";
+  socks[0] = Create(TCP_TYPE_ACTIVE);
+  socks[1] = Create(TCP_TYPE_PASSIVE);
+  Listen(socks[1]);
+  Connect(socks[0], socks[1]);
+
+  TransferData(socks[0], socks[1], data, sizeof(data));
+  TransferData(socks[1], socks[0], data, sizeof(data));
+
+  /* We have to destroy as only that calls PR_Close() */
+  std::cerr << "Destructing socket" << std::endl;
+  Destroy(socks[0]);
+
+  RecvDataFailed(socks[1], sizeof(data), R_EOD);
+
+  socks[0] = nullptr;
+}
+
+TEST_F(MultiTcpSocketTest, TestTwoSendsBeforeReceives) {
+  const char data1[] = "TestTwoSendsBeforeReceives";
+  const char data2[] = "2nd data";
+  socks[0] = Create(TCP_TYPE_ACTIVE);
+  socks[1] = Create(TCP_TYPE_PASSIVE);
+  Listen(socks[1]);
+  Connect(socks[0], socks[1]);
+
+  SendData(socks[0], socks[1], data1, sizeof(data1));
+  SendData(socks[0], socks[1], data2, sizeof(data2));
+  RecvData(socks[0], socks[1], data1, sizeof(data1));
+  /* ICE TCP framing turns TCP effectively into datagram mode */
+  RecvData(socks[0], socks[1], data2, sizeof(data2));
+}
+
+TEST_F(MultiTcpSocketTest, TestTwoActiveBidirectionalTransmit) {
+  const char data1[] = "TestTwoActiveBidirectionalTransmit";
+  const char data2[] = "ReplyToTheFirstSocket";
+  const char data3[] = "TestMessageFromTheSecondSocket";
+  const char data4[] = "ThisIsAReplyToTheSecondSocket";
+  socks[0] = Create(TCP_TYPE_PASSIVE);
+  socks[1] = Create(TCP_TYPE_ACTIVE);
+  socks[2] = Create(TCP_TYPE_ACTIVE);
+  Listen(socks[0]);
+  Connect(socks[1], socks[0]);
+  Connect(socks[2], socks[0]);
+
+  TransferData(socks[1], socks[0], data1, sizeof(data1));
+  TransferData(socks[0], socks[1], data2, sizeof(data2));
+  TransferData(socks[2], socks[0], data3, sizeof(data3));
+  TransferData(socks[0], socks[2], data4, sizeof(data4));
+}
+
+TEST_F(MultiTcpSocketTest, TestTwoPassiveBidirectionalTransmit) {
+  const char data1[] = "TestTwoPassiveBidirectionalTransmit";
+  const char data2[] = "FirstReply";
+  const char data3[] = "TestTwoPassiveBidirectionalTransmitToTheSecondSock";
+  const char data4[] = "SecondReply";
+  socks[0] = Create(TCP_TYPE_PASSIVE);
+  socks[1] = Create(TCP_TYPE_PASSIVE);
+  socks[2] = Create(TCP_TYPE_ACTIVE);
+  Listen(socks[0]);
+  Listen(socks[1]);
+  Connect(socks[2], socks[0]);
+  Connect(socks[2], socks[1]);
+
+  TransferData(socks[2], socks[0], data1, sizeof(data1));
+  TransferData(socks[0], socks[2], data2, sizeof(data2));
+  TransferData(socks[2], socks[1], data3, sizeof(data3));
+  TransferData(socks[1], socks[2], data4, sizeof(data4));
+}
+
+TEST_F(MultiTcpSocketTest, TestActivePassiveWithStunServerMockup) {
+  /* Fake STUN message able to pass the nr_is_stun_msg check
+     used in nr_socket_buffered_stun */
+  const char stunMessage[] = {
+    '\x00', '\x01', '\x00', '\x04', '\x21', '\x12', '\xa4', '\x42',
+    '\x00', '\x00', '\x00', '\x00', '\x00', '\x00', '\x0c', '\x00',
+    '\x00', '\x00', '\x00', '\x00', '\x1c', '\xed', '\xca', '\xfe'
+  };
+  const char data[] = "TestActivePassiveWithStunServerMockup";
+
+  nr_transport_addr stun_srv_addr;
+  std::string stun_addr;
+  uint16_t stun_port;
+  stun_addr = TestStunTcpServer::GetInstance(AF_INET)->addr();
+  stun_port = TestStunTcpServer::GetInstance(AF_INET)->port();
+  int r = nr_str_port_to_transport_addr(stun_addr.c_str(), stun_port, IPPROTO_TCP, &stun_srv_addr);
+  ASSERT_EQ(0, r);
+
+  socks[0] = Create(TCP_TYPE_PASSIVE, stun_addr, stun_port);
+  Listen(socks[0]);
+  socks[1] = Create(TCP_TYPE_ACTIVE, stun_addr, stun_port);
+
+  /* Send a fake STUN request and expect a STUN error response */
+  SendData(socks[0], &stun_srv_addr, stunMessage, sizeof(stunMessage));
+  RecvData(&stun_srv_addr, socks[0]);
+
+  Connect(socks[1], socks[0]);
+  TransferData(socks[1], socks[0], data, sizeof(data));
+  TransferData(socks[0], socks[1], data, sizeof(data));
+}
+
+TEST_F(MultiTcpSocketTest,  TestConnectTwoSo) {
+  socks[0] = Create(TCP_TYPE_SO);
+  socks[1] = Create(TCP_TYPE_SO);
+  ConnectSo(socks[0], socks[1]);
+}
+
+// test works on localhost only with delay applied:
+//   tc qdisc add dev lo root netem delay 5ms
+TEST_F(MultiTcpSocketTest, DISABLED_TestTwoSoBidirectionalTransmit) {
+  const char data[] = "TestTwoSoBidirectionalTransmit";
+  socks[0] = Create(TCP_TYPE_SO);
+  socks[1] = Create(TCP_TYPE_SO);
+  ConnectSo(socks[0], socks[1]);
+  TransferData(socks[0], socks[1], data, sizeof(data));
+  TransferData(socks[1], socks[0], data, sizeof(data));
+}
+
+TEST_F(MultiTcpSocketTest, TestBigData) {
+  char buf1[2048];
+  char buf2[1024];
+
+  for(unsigned i=0; i<sizeof(buf1); ++i) {
+    buf1[i]=i&0xff;
+  }
+  for(unsigned i=0; i<sizeof(buf2); ++i) {
+    buf2[i]=(i+0x80)&0xff;
+  }
+  socks[0] = Create(TCP_TYPE_ACTIVE);
+  socks[1] = Create(TCP_TYPE_PASSIVE);
+  Listen(socks[1]);
+  Connect(socks[0], socks[1]);
+
+  TransferData(socks[0], socks[1], buf1, sizeof(buf1));
+  TransferData(socks[0], socks[1], buf2, sizeof(buf2));
+// opposite dir
+  SendData(socks[1], socks[0], buf2, sizeof(buf2));
+  SendData(socks[1], socks[0], buf1, sizeof(buf1));
+  RecvData(socks[1], socks[0], buf2, sizeof(buf2));
+  RecvData(socks[1], socks[0], buf1, sizeof(buf1));
+}
diff --git a/media/mtransport/test/nrappkit_unittest.cpp b/media/mtransport/test/nrappkit_unittest.cpp
new file mode 100644
index 000000000..48f904758
--- /dev/null
+++ b/media/mtransport/test/nrappkit_unittest.cpp
@@ -0,0 +1,134 @@
+
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: ekr@rtfm.com
+#include <iostream>
+
+#include "nsThreadUtils.h"
+#include "nsXPCOM.h"
+
+// nrappkit includes
+extern "C" {
+#include "nr_api.h"
+#include "async_timer.h"
+}
+
+#include "runnable_utils.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+using namespace mozilla;
+
+namespace {
+
+class TimerTest : public MtransportTest {
+ public:
+  TimerTest() : MtransportTest(), handle_(nullptr), fired_(false) {}
+  virtual ~TimerTest() {}
+
+  int ArmTimer(int timeout) {
+    int ret;
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableRet(&ret, this, &TimerTest::ArmTimer_w, timeout),
+        NS_DISPATCH_SYNC);
+
+    return ret;
+  }
+
+  int ArmCancelTimer(int timeout) {
+    int ret;
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableRet(&ret, this, &TimerTest::ArmCancelTimer_w, timeout),
+        NS_DISPATCH_SYNC);
+
+    return ret;
+  }
+
+  int ArmTimer_w(int timeout) {
+    return NR_ASYNC_TIMER_SET(timeout, cb, this, &handle_);
+  }
+
+  int ArmCancelTimer_w(int timeout) {
+    int r;
+    r = ArmTimer_w(timeout);
+    if (r)
+      return r;
+
+    return CancelTimer_w();
+  }
+
+  int CancelTimer() {
+    int ret;
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableRet(&ret, this, &TimerTest::CancelTimer_w),
+        NS_DISPATCH_SYNC);
+
+    return ret;
+  }
+
+  int CancelTimer_w() {
+    return NR_async_timer_cancel(handle_);
+  }
+
+  int Schedule() {
+    int ret;
+
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableRet(&ret, this, &TimerTest::Schedule_w),
+        NS_DISPATCH_SYNC);
+
+    return ret;
+  }
+
+  int Schedule_w() {
+    NR_ASYNC_SCHEDULE(cb, this);
+
+    return 0;
+  }
+
+
+  static void cb(NR_SOCKET r, int how, void *arg) {
+    std::cerr << "Timer fired " << std::endl;
+
+    TimerTest *t = static_cast<TimerTest *>(arg);
+
+    t->fired_ = true;
+  }
+
+ protected:
+  void *handle_;
+  bool fired_;
+};
+}
+
+TEST_F(TimerTest, SimpleTimer) {
+  ArmTimer(100);
+  ASSERT_TRUE_WAIT(fired_, 1000);
+}
+
+TEST_F(TimerTest, CancelTimer) {
+  ArmTimer(1000);
+  CancelTimer();
+  PR_Sleep(2000);
+  ASSERT_FALSE(fired_);
+}
+
+TEST_F(TimerTest, CancelTimer0) {
+  ArmCancelTimer(0);
+  PR_Sleep(100);
+  ASSERT_FALSE(fired_);
+}
+
+TEST_F(TimerTest, ScheduleTest) {
+  Schedule();
+  ASSERT_TRUE_WAIT(fired_, 1000);
+}
diff --git a/media/mtransport/test/proxy_tunnel_socket_unittest.cpp b/media/mtransport/test/proxy_tunnel_socket_unittest.cpp
new file mode 100644
index 000000000..facd0c04c
--- /dev/null
+++ b/media/mtransport/test/proxy_tunnel_socket_unittest.cpp
@@ -0,0 +1,344 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original authors: ekr@rtfm.com; ryan@tokbox.com
+
+#include <iostream>
+
+#include "nspr.h"
+#include "nss.h"
+#include "ssl.h"
+
+extern "C" {
+#include "nr_api.h"
+#include "nr_socket.h"
+#include "nr_proxy_tunnel.h"
+#include "transport_addr.h"
+#include "stun.h"
+}
+
+#include "databuffer.h"
+#include "dummysocket.h"
+
+#include "nr_socket_prsock.h"
+#include "nriceresolverfake.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+using namespace mozilla;
+
+const std::string kRemoteAddr = "192.0.2.133";
+const uint16_t kRemotePort = 3333;
+
+const std::string kProxyHost = "example.com";
+const std::string kProxyAddr = "192.0.2.134";
+const uint16_t kProxyPort = 9999;
+
+const std::string kHelloMessage = "HELLO";
+const std::string kGarbageMessage = "xxxxxxxxxx";
+
+std::string connect_message(const std::string &host, uint16_t port, const std::string &alpn, const std::string &tail) {
+  std::stringstream ss;
+  ss << "CONNECT " << host << ":" << port << " HTTP/1.0\r\n";
+  if (!alpn.empty()) {
+    ss << "ALPN: " << alpn << "\r\n";
+  }
+  ss << "\r\n" << tail;
+  return ss.str();
+}
+
+std::string connect_response(int code, const std::string &tail = "") {
+  std::stringstream ss;
+  ss << "HTTP/1.0 " << code << "\r\n\r\n" << tail;
+  return ss.str();
+}
+
+class DummyResolver {
+ public:
+  DummyResolver() {
+    vtbl_ = new nr_resolver_vtbl;
+    vtbl_->destroy = &DummyResolver::destroy;
+    vtbl_->resolve = &DummyResolver::resolve;
+    vtbl_->cancel = &DummyResolver::cancel;
+    nr_resolver_create_int((void *)this, vtbl_, &resolver_);
+  }
+
+  ~DummyResolver() {
+    nr_resolver_destroy(&resolver_);
+    delete vtbl_;
+  }
+
+  static int destroy(void **objp) {
+    return 0;
+  }
+
+  static int resolve(void *obj,
+                     nr_resolver_resource *resource,
+                     int (*cb)(void *cb_arg, nr_transport_addr *addr),
+                     void *cb_arg,
+                     void **handle) {
+    nr_transport_addr addr;
+
+    nr_str_port_to_transport_addr(
+        (char *)kProxyAddr.c_str(), kProxyPort, IPPROTO_TCP, &addr);
+
+    cb(cb_arg, &addr);
+    return 0;
+  }
+
+  static int cancel(void *obj, void *handle) {
+    return 0;
+  }
+
+  nr_resolver *get_nr_resolver() {
+    return resolver_;
+  }
+
+ private:
+  nr_resolver_vtbl *vtbl_;
+  nr_resolver *resolver_;
+};
+
+class ProxyTunnelSocketTest : public MtransportTest {
+ public:
+  ProxyTunnelSocketTest()
+      : socket_impl_(nullptr),
+        nr_socket_(nullptr) {}
+
+  ~ProxyTunnelSocketTest() {
+    nr_socket_destroy(&nr_socket_);
+    nr_proxy_tunnel_config_destroy(&config_);
+  }
+
+  void SetUp() override {
+    MtransportTest::SetUp();
+
+    nr_resolver_ = resolver_impl_.get_nr_resolver();
+
+    int r = nr_str_port_to_transport_addr(
+        (char *)kRemoteAddr.c_str(), kRemotePort, IPPROTO_TCP, &remote_addr_);
+    ASSERT_EQ(0, r);
+
+    r = nr_str_port_to_transport_addr(
+        (char *)kProxyAddr.c_str(), kProxyPort, IPPROTO_TCP, &proxy_addr_);
+    ASSERT_EQ(0, r);
+
+    nr_proxy_tunnel_config_create(&config_);
+    nr_proxy_tunnel_config_set_resolver(config_, nr_resolver_);
+    nr_proxy_tunnel_config_set_proxy(config_, kProxyAddr.c_str(), kProxyPort);
+
+    Configure();
+  }
+
+  // This reconfigures the socket with the updated information in config_.
+  void Configure() {
+    if (nr_socket_) {
+      EXPECT_EQ(0, nr_socket_destroy(&nr_socket_));
+      EXPECT_EQ(nullptr, nr_socket_);
+    }
+
+    RefPtr<DummySocket> dummy(new DummySocket());
+    int r = nr_socket_proxy_tunnel_create(
+        config_,
+        dummy->get_nr_socket(),
+        &nr_socket_);
+    ASSERT_EQ(0, r);
+
+    socket_impl_ = dummy.forget();  // Now owned by nr_socket_.
+  }
+
+  void Connect(int expectedReturn = 0) {
+    int r = nr_socket_connect(nr_socket_, &remote_addr_);
+    EXPECT_EQ(expectedReturn, r);
+
+    size_t written = 0;
+    r = nr_socket_write(nr_socket_, kHelloMessage.c_str(), kHelloMessage.size(), &written, 0);
+    EXPECT_EQ(0, r);
+    EXPECT_EQ(kHelloMessage.size(), written);
+  }
+
+  nr_socket *socket() { return nr_socket_; }
+
+ protected:
+  RefPtr<DummySocket> socket_impl_;
+  DummyResolver resolver_impl_;
+  nr_socket *nr_socket_;
+  nr_resolver *nr_resolver_;
+  nr_proxy_tunnel_config *config_;
+  nr_transport_addr proxy_addr_;
+  nr_transport_addr remote_addr_;
+};
+
+
+TEST_F(ProxyTunnelSocketTest, TestCreate) {
+}
+
+TEST_F(ProxyTunnelSocketTest, TestConnectProxyAddress) {
+  int r = nr_socket_connect(nr_socket_, &remote_addr_);
+  ASSERT_EQ(0, r);
+
+  ASSERT_EQ(0, nr_transport_addr_cmp(socket_impl_->get_connect_addr(), &proxy_addr_,
+        NR_TRANSPORT_ADDR_CMP_MODE_ALL));
+}
+
+// TODO: Reenable once bug 1251212 is fixed
+TEST_F(ProxyTunnelSocketTest, DISABLED_TestConnectProxyRequest) {
+  Connect();
+
+  std::string msg = connect_message(kRemoteAddr, kRemotePort, "", kHelloMessage);
+  socket_impl_->CheckWriteBuffer(reinterpret_cast<const uint8_t *>(msg.c_str()), msg.size());
+}
+
+// TODO: Reenable once bug 1251212 is fixed
+TEST_F(ProxyTunnelSocketTest, DISABLED_TestAlpnConnect) {
+  const std::string alpn = "this,is,alpn";
+  int r = nr_proxy_tunnel_config_set_alpn(config_, alpn.c_str());
+  EXPECT_EQ(0, r);
+
+  Configure();
+  Connect();
+
+  std::string msg = connect_message(kRemoteAddr, kRemotePort, alpn, kHelloMessage);
+  socket_impl_->CheckWriteBuffer(reinterpret_cast<const uint8_t *>(msg.c_str()), msg.size());
+}
+
+// TODO: Reenable once bug 1251212 is fixed
+TEST_F(ProxyTunnelSocketTest, DISABLED_TestNullAlpnConnect) {
+  int r = nr_proxy_tunnel_config_set_alpn(config_, nullptr);
+  EXPECT_EQ(0, r);
+
+  Configure();
+  Connect();
+
+  std::string msg = connect_message(kRemoteAddr, kRemotePort, "", kHelloMessage);
+  socket_impl_->CheckWriteBuffer(reinterpret_cast<const uint8_t *>(msg.c_str()), msg.size());
+}
+
+// TODO: Reenable once bug 1251212 is fixed
+TEST_F(ProxyTunnelSocketTest, DISABLED_TestConnectProxyHostRequest) {
+  nr_proxy_tunnel_config_set_proxy(config_, kProxyHost.c_str(), kProxyPort);
+  Configure();
+  // Because kProxyHost is a domain name and not an IP address,
+  // nr_socket_connect will need to resolve an IP address before continuing.  It
+  // does that, and assumes that resolving the IP will take some time, so it
+  // returns R_WOULDBLOCK.
+  //
+  // However, In this test setup, the resolution happens inline immediately, so
+  // nr_socket_connect is called recursively on the inner socket in
+  // nr_socket_proxy_tunnel_resolved_cb.  That also completes.  Thus, the socket
+  // is actually successfully connected after this call, even though
+  // nr_socket_connect reports an error.
+  //
+  // Arguably nr_socket_proxy_tunnel_connect() is busted, because it shouldn't
+  // report an error when it doesn't need any further assistance from the
+  // calling code, but that's pretty minor.
+  Connect(R_WOULDBLOCK);
+
+  std::string msg = connect_message(kRemoteAddr, kRemotePort, "", kHelloMessage);
+  socket_impl_->CheckWriteBuffer(reinterpret_cast<const uint8_t *>(msg.c_str()), msg.size());
+}
+
+// TODO: Reenable once bug 1251212 is fixed
+TEST_F(ProxyTunnelSocketTest, DISABLED_TestConnectProxyWrite) {
+  Connect();
+
+  socket_impl_->ClearWriteBuffer();
+
+  size_t written = 0;
+  int r = nr_socket_write(nr_socket_, kHelloMessage.c_str(), kHelloMessage.size(), &written, 0);
+  EXPECT_EQ(0, r);
+  EXPECT_EQ(kHelloMessage.size(), written);
+
+  socket_impl_->CheckWriteBuffer(reinterpret_cast<const uint8_t *>(kHelloMessage.c_str()),
+      kHelloMessage.size());
+}
+
+TEST_F(ProxyTunnelSocketTest, TestConnectProxySuccessResponse) {
+  int r = nr_socket_connect(nr_socket_, &remote_addr_);
+  ASSERT_EQ(0, r);
+
+  std::string resp = connect_response(200, kHelloMessage);
+  socket_impl_->SetReadBuffer(reinterpret_cast<const uint8_t *>(resp.c_str()), resp.size());
+
+  char buf[4096];
+  size_t read = 0;
+  r = nr_socket_read(nr_socket_, buf, sizeof(buf), &read, 0);
+  ASSERT_EQ(0, r);
+
+  ASSERT_EQ(kHelloMessage.size(), read);
+  ASSERT_EQ(0, memcmp(buf, kHelloMessage.c_str(), kHelloMessage.size()));
+}
+
+TEST_F(ProxyTunnelSocketTest, TestConnectProxyRead) {
+  int r = nr_socket_connect(nr_socket_, &remote_addr_);
+  ASSERT_EQ(0, r);
+
+  std::string resp = connect_response(200, kHelloMessage);
+  socket_impl_->SetReadBuffer(reinterpret_cast<const uint8_t *>(resp.c_str()), resp.size());
+
+  char buf[4096];
+  size_t read = 0;
+  r = nr_socket_read(nr_socket_, buf, sizeof(buf), &read, 0);
+  ASSERT_EQ(0, r);
+
+  socket_impl_->ClearReadBuffer();
+  socket_impl_->SetReadBuffer(reinterpret_cast<const uint8_t *>(kHelloMessage.c_str()),
+      kHelloMessage.size());
+
+  r = nr_socket_read(nr_socket_, buf, sizeof(buf), &read, 0);
+  ASSERT_EQ(0, r);
+
+  ASSERT_EQ(kHelloMessage.size(), read);
+  ASSERT_EQ(0, memcmp(buf, kHelloMessage.c_str(), kHelloMessage.size()));
+}
+
+TEST_F(ProxyTunnelSocketTest, TestConnectProxyReadNone) {
+  int r = nr_socket_connect(nr_socket_, &remote_addr_);
+  ASSERT_EQ(0, r);
+
+  std::string resp = connect_response(200);
+  socket_impl_->SetReadBuffer(reinterpret_cast<const uint8_t *>(resp.c_str()), resp.size());
+
+  char buf[4096];
+  size_t read = 0;
+  r = nr_socket_read(nr_socket_, buf, sizeof(buf), &read, 0);
+  ASSERT_EQ(R_WOULDBLOCK, r);
+
+  socket_impl_->ClearReadBuffer();
+  socket_impl_->SetReadBuffer(reinterpret_cast<const uint8_t *>(kHelloMessage.c_str()),
+      kHelloMessage.size());
+
+  r = nr_socket_read(nr_socket_, buf, sizeof(buf), &read, 0);
+  ASSERT_EQ(0, r);
+}
+
+TEST_F(ProxyTunnelSocketTest, TestConnectProxyFailResponse) {
+  int r = nr_socket_connect(nr_socket_, &remote_addr_);
+  ASSERT_EQ(0, r);
+
+  std::string resp = connect_response(500, kHelloMessage);
+  socket_impl_->SetReadBuffer(reinterpret_cast<const uint8_t *>(resp.c_str()), resp.size());
+
+  char buf[4096];
+  size_t read = 0;
+  r = nr_socket_read(nr_socket_, buf, sizeof(buf), &read, 0);
+  ASSERT_NE(0, r);
+}
+
+TEST_F(ProxyTunnelSocketTest, TestConnectProxyGarbageResponse) {
+  int r = nr_socket_connect(nr_socket_, &remote_addr_);
+  ASSERT_EQ(0, r);
+
+  socket_impl_->SetReadBuffer(reinterpret_cast<const uint8_t *>(kGarbageMessage.c_str()),
+      kGarbageMessage.size());
+
+  char buf[4096];
+  size_t read = 0;
+  r = nr_socket_read(nr_socket_, buf, sizeof(buf), &read, 0);
+  ASSERT_EQ(0ul, read);
+}
diff --git a/media/mtransport/test/rlogconnector_unittest.cpp b/media/mtransport/test/rlogconnector_unittest.cpp
new file mode 100644
index 000000000..e283e8199
--- /dev/null
+++ b/media/mtransport/test/rlogconnector_unittest.cpp
@@ -0,0 +1,264 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Original author: bcampen@mozilla.com */
+
+#include "rlogconnector.h"
+
+extern "C" {
+#include "registry.h"
+#include "r_log.h"
+}
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+#include <deque>
+#include <string>
+#include <vector>
+
+using mozilla::RLogConnector;
+
+int NR_LOG_TEST = 0;
+
+class RLogConnectorTest : public ::testing::Test {
+  public:
+    RLogConnectorTest() {
+      Init();
+    }
+
+    ~RLogConnectorTest() {
+      Free();
+    }
+
+    static void SetUpTestCase() {
+      NR_reg_init(NR_REG_MODE_LOCAL);
+      r_log_init();
+      /* Would be nice to be able to unregister in the fixture */
+      const char* facility = "rlogconnector_test";
+      r_log_register(const_cast<char*>(facility), &NR_LOG_TEST);
+    }
+
+    void Init() {
+      RLogConnector::CreateInstance();
+    }
+
+    void Free() {
+      RLogConnector::DestroyInstance();
+    }
+
+    void ReInit() {
+      Free();
+      Init();
+    }
+};
+
+TEST_F(RLogConnectorTest, TestGetFree) {
+  RLogConnector* instance = RLogConnector::GetInstance();
+  ASSERT_NE(nullptr, instance);
+}
+
+TEST_F(RLogConnectorTest, TestFilterEmpty) {
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->GetAny(0, &logs);
+  ASSERT_EQ(0U, logs.size());
+}
+
+TEST_F(RLogConnectorTest, TestBasicFilter) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->Filter("Test", 0, &logs);
+  ASSERT_EQ(1U, logs.size());
+}
+
+TEST_F(RLogConnectorTest, TestBasicFilterContent) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->Filter("Test", 0, &logs);
+  ASSERT_EQ("Test", logs.back());
+}
+
+TEST_F(RLogConnectorTest, TestFilterAnyFrontMatch) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test");
+  std::vector<std::string> substrings;
+  substrings.push_back("foo");
+  substrings.push_back("Test");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->FilterAny(substrings, 0, &logs);
+  ASSERT_EQ("Test", logs.back());
+}
+
+TEST_F(RLogConnectorTest, TestFilterAnyBackMatch) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test");
+  std::vector<std::string> substrings;
+  substrings.push_back("Test");
+  substrings.push_back("foo");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->FilterAny(substrings, 0, &logs);
+  ASSERT_EQ("Test", logs.back());
+}
+
+TEST_F(RLogConnectorTest, TestFilterAnyBothMatch) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test");
+  std::vector<std::string> substrings;
+  substrings.push_back("Tes");
+  substrings.push_back("est");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->FilterAny(substrings, 0, &logs);
+  ASSERT_EQ("Test", logs.back());
+}
+
+TEST_F(RLogConnectorTest, TestFilterAnyNeitherMatch) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test");
+  std::vector<std::string> substrings;
+  substrings.push_back("tes");
+  substrings.push_back("esT");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->FilterAny(substrings, 0, &logs);
+  ASSERT_EQ(0U, logs.size());
+}
+
+TEST_F(RLogConnectorTest, TestAllMatch) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test1");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test2");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->GetAny(0, &logs);
+  ASSERT_EQ(2U, logs.size());
+}
+
+TEST_F(RLogConnectorTest, TestOrder) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test1");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test2");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->GetAny(0, &logs);
+  ASSERT_EQ("Test2", logs.back());
+  ASSERT_EQ("Test1", logs.front());
+}
+
+TEST_F(RLogConnectorTest, TestNoMatch) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test1");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test2");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->Filter("foo", 0, &logs);
+  ASSERT_EQ(0U, logs.size());
+}
+
+TEST_F(RLogConnectorTest, TestSubstringFilter) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test1");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test2");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->Filter("t1", 0, &logs);
+  ASSERT_EQ(1U, logs.size());
+  ASSERT_EQ("Test1", logs.back());
+}
+
+TEST_F(RLogConnectorTest, TestFilterLimit) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test1");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test2");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test3");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test4");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test5");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test6");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->Filter("Test", 2, &logs);
+  ASSERT_EQ(2U, logs.size());
+  ASSERT_EQ("Test6", logs.back());
+  ASSERT_EQ("Test5", logs.front());
+}
+
+TEST_F(RLogConnectorTest, TestFilterAnyLimit) {
+  r_log(NR_LOG_TEST, LOG_INFO, "TestOne");
+  r_log(NR_LOG_TEST, LOG_INFO, "TestTwo");
+  r_log(NR_LOG_TEST, LOG_INFO, "TestThree");
+  r_log(NR_LOG_TEST, LOG_INFO, "TestFour");
+  r_log(NR_LOG_TEST, LOG_INFO, "TestFive");
+  r_log(NR_LOG_TEST, LOG_INFO, "TestSix");
+  std::vector<std::string> substrings;
+  // Matches Two, Three, Four, and Six
+  substrings.push_back("tT");
+  substrings.push_back("o");
+  substrings.push_back("r");
+  substrings.push_back("S");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->FilterAny(substrings, 2, &logs);
+  ASSERT_EQ(2U, logs.size());
+  ASSERT_EQ("TestSix", logs.back());
+  ASSERT_EQ("TestFour", logs.front());
+}
+
+TEST_F(RLogConnectorTest, TestLimit) {
+  RLogConnector::GetInstance()->SetLogLimit(3);
+  r_log(NR_LOG_TEST, LOG_INFO, "Test1");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test2");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test3");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test4");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test5");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test6");
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->GetAny(0, &logs);
+  ASSERT_EQ(3U, logs.size());
+  ASSERT_EQ("Test6", logs.back());
+  ASSERT_EQ("Test4", logs.front());
+}
+
+TEST_F(RLogConnectorTest, TestLimitBulkDiscard) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test1");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test2");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test3");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test4");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test5");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test6");
+  RLogConnector::GetInstance()->SetLogLimit(3);
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->GetAny(0, &logs);
+  ASSERT_EQ(3U, logs.size());
+  ASSERT_EQ("Test6", logs.back());
+  ASSERT_EQ("Test4", logs.front());
+}
+
+TEST_F(RLogConnectorTest, TestIncreaseLimit) {
+  RLogConnector::GetInstance()->SetLogLimit(3);
+  r_log(NR_LOG_TEST, LOG_INFO, "Test1");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test2");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test3");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test4");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test5");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test6");
+  RLogConnector::GetInstance()->SetLogLimit(300);
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->GetAny(0, &logs);
+  ASSERT_EQ(3U, logs.size());
+  ASSERT_EQ("Test6", logs.back());
+  ASSERT_EQ("Test4", logs.front());
+}
+
+TEST_F(RLogConnectorTest, TestClear) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test1");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test2");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test3");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test4");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test5");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test6");
+  RLogConnector::GetInstance()->SetLogLimit(0);
+  RLogConnector::GetInstance()->SetLogLimit(4096);
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->GetAny(0, &logs);
+  ASSERT_EQ(0U, logs.size());
+}
+
+TEST_F(RLogConnectorTest, TestReInit) {
+  r_log(NR_LOG_TEST, LOG_INFO, "Test1");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test2");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test3");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test4");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test5");
+  r_log(NR_LOG_TEST, LOG_INFO, "Test6");
+  ReInit();
+  std::deque<std::string> logs;
+  RLogConnector::GetInstance()->GetAny(0, &logs);
+  ASSERT_EQ(0U, logs.size());
+}
diff --git a/media/mtransport/test/runnable_utils_unittest.cpp b/media/mtransport/test/runnable_utils_unittest.cpp
new file mode 100644
index 000000000..28ca57aa1
--- /dev/null
+++ b/media/mtransport/test/runnable_utils_unittest.cpp
@@ -0,0 +1,227 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: ekr@rtfm.com
+#include <iostream>
+
+#include "prio.h"
+
+#include "nsCOMPtr.h"
+#include "nsNetCID.h"
+#include "nsXPCOM.h"
+#include "nsXPCOMGlue.h"
+
+#include "mozilla/RefPtr.h"
+#include "nsIComponentManager.h"
+#include "nsIComponentRegistrar.h"
+#include "nsIIOService.h"
+#include "nsIServiceManager.h"
+#include "nsISocketTransportService.h"
+
+#include "nsASocketHandler.h"
+#include "nsServiceManagerUtils.h"
+#include "nsThreadUtils.h"
+
+#include "runnable_utils.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+using namespace mozilla;
+
+namespace {
+
+class Destructor {
+ private:
+  ~Destructor() {
+    std::cerr << "Destructor called" << std::endl;
+    *destroyed_ = true;
+  }
+ public:
+  explicit Destructor(bool* destroyed) : destroyed_(destroyed) {}
+
+  NS_INLINE_DECL_THREADSAFE_REFCOUNTING(Destructor)
+
+ private:
+  bool *destroyed_;
+};
+
+class TargetClass {
+ public:
+  explicit TargetClass(int *ran) : ran_(ran) {}
+
+  void m1(int x) {
+    std::cerr << __FUNCTION__ << " " << x << std::endl;
+    *ran_ = 1;
+  }
+
+  void m2(int x, int y) {
+    std::cerr << __FUNCTION__ << " " << x << " " << y << std::endl;
+    *ran_ = 2;
+  }
+
+  void m1set(bool *z) {
+    std::cerr << __FUNCTION__ << std::endl;
+    *z = true;
+  }
+  int return_int(int x) {
+    std::cerr << __FUNCTION__ << std::endl;
+    return x;
+  }
+  void destructor_target(Destructor*) {
+  }
+
+  void destructor_target_ref(RefPtr<Destructor> destructor) {
+  }
+
+  int *ran_;
+};
+
+
+class RunnableArgsTest : public MtransportTest {
+ public:
+  RunnableArgsTest() : MtransportTest(), ran_(0), cl_(&ran_){}
+
+  void Test1Arg() {
+    Runnable * r = WrapRunnable(&cl_, &TargetClass::m1, 1);
+    r->Run();
+    ASSERT_EQ(1, ran_);
+  }
+
+  void Test2Args() {
+    Runnable* r = WrapRunnable(&cl_, &TargetClass::m2, 1, 2);
+    r->Run();
+    ASSERT_EQ(2, ran_);
+  }
+
+ private:
+  int ran_;
+  TargetClass cl_;
+};
+
+class DispatchTest : public MtransportTest {
+ public:
+  DispatchTest() : MtransportTest(), ran_(0), cl_(&ran_) {}
+
+  void SetUp() {
+    MtransportTest::SetUp();
+
+    nsresult rv;
+    target_ = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+    ASSERT_TRUE(NS_SUCCEEDED(rv));
+  }
+
+  void Test1Arg() {
+    Runnable* r = WrapRunnable(&cl_, &TargetClass::m1, 1);
+    target_->Dispatch(r, NS_DISPATCH_SYNC);
+    ASSERT_EQ(1, ran_);
+  }
+
+  void Test2Args() {
+    Runnable* r = WrapRunnable(&cl_, &TargetClass::m2, 1, 2);
+    target_->Dispatch(r, NS_DISPATCH_SYNC);
+    ASSERT_EQ(2, ran_);
+  }
+
+  void Test1Set() {
+    bool x = false;
+    target_->Dispatch(WrapRunnable(&cl_, &TargetClass::m1set, &x),
+                      NS_DISPATCH_SYNC);
+    ASSERT_TRUE(x);
+  }
+
+  void TestRet() {
+    int z;
+    int x = 10;
+
+    target_->Dispatch(WrapRunnableRet(&z, &cl_, &TargetClass::return_int, x),
+                      NS_DISPATCH_SYNC);
+    ASSERT_EQ(10, z);
+  }
+
+ protected:
+  int ran_;
+  TargetClass cl_;
+  nsCOMPtr<nsIEventTarget> target_;
+};
+
+
+TEST_F(RunnableArgsTest, OneArgument) {
+  Test1Arg();
+}
+
+TEST_F(RunnableArgsTest, TwoArguments) {
+  Test2Args();
+}
+
+TEST_F(DispatchTest, OneArgument) {
+  Test1Arg();
+}
+
+TEST_F(DispatchTest, TwoArguments) {
+  Test2Args();
+}
+
+TEST_F(DispatchTest, Test1Set) {
+  Test1Set();
+}
+
+TEST_F(DispatchTest, TestRet) {
+  TestRet();
+}
+
+void SetNonMethod(TargetClass *cl, int x) {
+  cl->m1(x);
+}
+
+int SetNonMethodRet(TargetClass *cl, int x) {
+  cl->m1(x);
+
+  return x;
+}
+
+TEST_F(DispatchTest, TestNonMethod) {
+  test_utils_->sts_target()->Dispatch(
+      WrapRunnableNM(SetNonMethod, &cl_, 10), NS_DISPATCH_SYNC);
+
+  ASSERT_EQ(1, ran_);
+}
+
+TEST_F(DispatchTest, TestNonMethodRet) {
+  int z;
+
+  test_utils_->sts_target()->Dispatch(
+      WrapRunnableNMRet(&z, SetNonMethodRet, &cl_, 10), NS_DISPATCH_SYNC);
+
+  ASSERT_EQ(1, ran_);
+  ASSERT_EQ(10, z);
+}
+
+TEST_F(DispatchTest, TestDestructor) {
+  bool destroyed = false;
+  RefPtr<Destructor> destructor = new Destructor(&destroyed);
+  target_->Dispatch(WrapRunnable(&cl_, &TargetClass::destructor_target,
+                                 destructor),
+                    NS_DISPATCH_SYNC);
+  ASSERT_FALSE(destroyed);
+  destructor = nullptr;
+  ASSERT_TRUE(destroyed);
+}
+
+TEST_F(DispatchTest, TestDestructorRef) {
+  bool destroyed = false;
+  RefPtr<Destructor> destructor = new Destructor(&destroyed);
+  target_->Dispatch(WrapRunnable(&cl_, &TargetClass::destructor_target_ref,
+                                 destructor),
+                    NS_DISPATCH_SYNC);
+  ASSERT_FALSE(destroyed);
+  destructor = nullptr;
+  ASSERT_TRUE(destroyed);
+}
+
+
+} // end of namespace
diff --git a/media/mtransport/test/sctp_unittest.cpp b/media/mtransport/test/sctp_unittest.cpp
new file mode 100644
index 000000000..886589cae
--- /dev/null
+++ b/media/mtransport/test/sctp_unittest.cpp
@@ -0,0 +1,393 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: ekr@rtfm.com
+
+#include <iostream>
+#include <string>
+#include <map>
+
+#include "sigslot.h"
+
+#include "logging.h"
+#include "nsNetCID.h"
+#include "nsITimer.h"
+#include "nsComponentManagerUtils.h"
+#include "nsThreadUtils.h"
+#include "nsXPCOM.h"
+
+#include "transportflow.h"
+#include "transportlayer.h"
+#include "transportlayerloopback.h"
+
+#include "runnable_utils.h"
+#include "usrsctp.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+
+using namespace mozilla;
+
+static bool sctp_logging = false;
+static int port_number = 5000;
+
+namespace {
+
+class TransportTestPeer;
+
+class SendPeriodic : public nsITimerCallback {
+ public:
+  SendPeriodic(TransportTestPeer *peer, int to_send) :
+      peer_(peer),
+      to_send_(to_send) {}
+
+  NS_DECL_THREADSAFE_ISUPPORTS
+  NS_DECL_NSITIMERCALLBACK
+
+ protected:
+  virtual ~SendPeriodic() {}
+
+  TransportTestPeer *peer_;
+  int to_send_;
+};
+
+NS_IMPL_ISUPPORTS(SendPeriodic, nsITimerCallback)
+
+
+class TransportTestPeer : public sigslot::has_slots<> {
+ public:
+  TransportTestPeer(std::string name, int local_port, int remote_port,
+                    MtransportTestUtils* utils)
+      : name_(name), connected_(false),
+        sent_(0), received_(0),
+        flow_(new TransportFlow()),
+        loopback_(new TransportLayerLoopback()),
+        sctp_(usrsctp_socket(AF_CONN, SOCK_STREAM, IPPROTO_SCTP, receive_cb, nullptr, 0, nullptr)),
+        timer_(do_CreateInstance(NS_TIMER_CONTRACTID)),
+        periodic_(nullptr),
+        test_utils_(utils) {
+    std::cerr << "Creating TransportTestPeer; flow=" <<
+        static_cast<void *>(flow_.get()) <<
+        " local=" << local_port <<
+        " remote=" << remote_port << std::endl;
+
+    usrsctp_register_address(static_cast<void *>(this));
+    int r = usrsctp_set_non_blocking(sctp_, 1);
+    EXPECT_GE(r, 0);
+
+    struct linger l;
+    l.l_onoff = 1;
+    l.l_linger = 0;
+    r = usrsctp_setsockopt(sctp_, SOL_SOCKET, SO_LINGER, &l,
+                       (socklen_t)sizeof(l));
+    EXPECT_GE(r, 0);
+
+    struct sctp_event subscription;
+    memset(&subscription, 0, sizeof(subscription));
+    subscription.se_assoc_id = SCTP_ALL_ASSOC;
+    subscription.se_on = 1;
+    subscription.se_type = SCTP_ASSOC_CHANGE;
+    r = usrsctp_setsockopt(sctp_, IPPROTO_SCTP, SCTP_EVENT, &subscription,
+                           sizeof(subscription));
+    EXPECT_GE(r, 0);
+
+    memset(&local_addr_, 0, sizeof(local_addr_));
+    local_addr_.sconn_family = AF_CONN;
+#if !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows) && !defined(__Userspace_os_Android)
+    local_addr_.sconn_len = sizeof(struct sockaddr_conn);
+#endif
+    local_addr_.sconn_port = htons(local_port);
+    local_addr_.sconn_addr = static_cast<void *>(this);
+
+
+    memset(&remote_addr_, 0, sizeof(remote_addr_));
+    remote_addr_.sconn_family = AF_CONN;
+#if !defined(__Userspace_os_Linux) && !defined(__Userspace_os_Windows) && !defined(__Userspace_os_Android)
+    remote_addr_.sconn_len = sizeof(struct sockaddr_conn);
+#endif
+    remote_addr_.sconn_port = htons(remote_port);
+    remote_addr_.sconn_addr = static_cast<void *>(this);
+
+    nsresult res;
+    res = loopback_->Init();
+    EXPECT_EQ((nsresult)NS_OK, res);
+  }
+
+  ~TransportTestPeer() {
+    std::cerr << "Destroying sctp connection flow=" <<
+        static_cast<void *>(flow_.get()) << std::endl;
+    usrsctp_close(sctp_);
+    usrsctp_deregister_address(static_cast<void *>(this));
+
+    test_utils_->sts_target()->Dispatch(WrapRunnable(this,
+                                                   &TransportTestPeer::Disconnect_s),
+                                      NS_DISPATCH_SYNC);
+
+    std::cerr << "~TransportTestPeer() completed" << std::endl;
+  }
+
+  void ConnectSocket(TransportTestPeer *peer) {
+    test_utils_->sts_target()->Dispatch(WrapRunnable(
+        this, &TransportTestPeer::ConnectSocket_s, peer),
+                                       NS_DISPATCH_SYNC);
+  }
+
+  void ConnectSocket_s(TransportTestPeer *peer) {
+    loopback_->Connect(peer->loopback_);
+
+    ASSERT_EQ((nsresult)NS_OK, flow_->PushLayer(loopback_));
+
+    flow_->SignalPacketReceived.connect(this, &TransportTestPeer::PacketReceived);
+
+    // SCTP here!
+    ASSERT_TRUE(sctp_);
+    std::cerr << "Calling usrsctp_bind()" << std::endl;
+    int r = usrsctp_bind(sctp_, reinterpret_cast<struct sockaddr *>(
+        &local_addr_), sizeof(local_addr_));
+    ASSERT_GE(0, r);
+
+    std::cerr << "Calling usrsctp_connect()" << std::endl;
+    r = usrsctp_connect(sctp_, reinterpret_cast<struct sockaddr *>(
+        &remote_addr_), sizeof(remote_addr_));
+    ASSERT_GE(0, r);
+  }
+
+  void Disconnect_s() {
+    if (flow_) {
+      flow_ = nullptr;
+    }
+  }
+
+  void Disconnect() {
+    loopback_->Disconnect();
+  }
+
+
+  void StartTransfer(size_t to_send) {
+    periodic_ = new SendPeriodic(this, to_send);
+    timer_->SetTarget(test_utils_->sts_target());
+    timer_->InitWithCallback(periodic_, 10, nsITimer::TYPE_REPEATING_SLACK);
+  }
+
+  void SendOne() {
+    unsigned char buf[100];
+    memset(buf, sent_ & 0xff, sizeof(buf));
+
+    struct sctp_sndinfo info;
+    info.snd_sid = 1;
+    info.snd_flags = 0;
+    info.snd_ppid = 50;  // What the heck is this?
+    info.snd_context = 0;
+    info.snd_assoc_id = 0;
+
+    int r = usrsctp_sendv(sctp_, buf, sizeof(buf), nullptr, 0,
+                          static_cast<void *>(&info),
+                          sizeof(info), SCTP_SENDV_SNDINFO, 0);
+    ASSERT_TRUE(r >= 0);
+    ASSERT_EQ(sizeof(buf), (size_t)r);
+
+    ++sent_;
+  }
+
+  int sent() const { return sent_; }
+  int received() const { return received_; }
+  bool connected() const { return connected_; }
+
+  static TransportResult SendPacket_s(const unsigned char* data, size_t len,
+                                      const RefPtr<TransportFlow>& flow) {
+    TransportResult res = flow->SendPacket(data, len);
+    delete data; // we always allocate
+    return res;
+  }
+
+  TransportResult SendPacket(const unsigned char* data, size_t len) {
+    unsigned char *buffer = new unsigned char[len];
+    memcpy(buffer, data, len);
+
+    // Uses DISPATCH_NORMAL to avoid possible deadlocks when we're called
+    // from MainThread especially during shutdown (same as DataChannels).
+    // RUN_ON_THREAD short-circuits if already on the STS thread, which is
+    // normal for most transfers outside of connect() and close().  Passes
+    // a refptr to flow_ to avoid any async deletion issues (since we can't
+    // make 'this' into a refptr as it isn't refcounted)
+    RUN_ON_THREAD(test_utils_->sts_target(), WrapRunnableNM(
+        &TransportTestPeer::SendPacket_s, buffer, len, flow_),
+                  NS_DISPATCH_NORMAL);
+
+    return 0;
+  }
+
+  void PacketReceived(TransportFlow * flow, const unsigned char* data,
+                      size_t len) {
+    std::cerr << "Received " << len << " bytes" << std::endl;
+
+    // Pass the data to SCTP
+
+    usrsctp_conninput(static_cast<void *>(this), data, len, 0);
+  }
+
+  // Process SCTP notification
+  void Notification(union sctp_notification *msg, size_t len) {
+    ASSERT_EQ(msg->sn_header.sn_length, len);
+
+    if (msg->sn_header.sn_type == SCTP_ASSOC_CHANGE) {
+      struct sctp_assoc_change *change = &msg->sn_assoc_change;
+
+      if (change->sac_state == SCTP_COMM_UP) {
+        std::cerr << "Connection up" << std::endl;
+        SetConnected(true);
+      } else {
+        std::cerr << "Connection down" << std::endl;
+        SetConnected(false);
+      }
+    }
+  }
+
+  void SetConnected(bool state) {
+    connected_ = state;
+  }
+
+  static int conn_output(void *addr, void *buffer, size_t length, uint8_t tos, uint8_t set_df) {
+    TransportTestPeer *peer = static_cast<TransportTestPeer *>(addr);
+
+    peer->SendPacket(static_cast<unsigned char *>(buffer), length);
+
+    return 0;
+  }
+
+  static int receive_cb(struct socket* sock, union sctp_sockstore addr,
+                        void *data, size_t datalen,
+                        struct sctp_rcvinfo rcv, int flags, void *ulp_info) {
+    TransportTestPeer *me = static_cast<TransportTestPeer *>(
+        addr.sconn.sconn_addr);
+    MOZ_ASSERT(me);
+
+    if (flags & MSG_NOTIFICATION) {
+      union sctp_notification *notif =
+          static_cast<union sctp_notification *>(data);
+
+      me->Notification(notif, datalen);
+      return 0;
+    }
+
+    me->received_ += datalen;
+
+    std::cerr << "receive_cb: sock " << sock << " data " << data << "(" << datalen << ") total received bytes = " << me->received_ << std::endl;
+
+    return 0;
+  }
+
+
+ private:
+  std::string name_;
+  bool connected_;
+  size_t sent_;
+  size_t received_;
+  RefPtr<TransportFlow> flow_;
+  TransportLayerLoopback *loopback_;
+
+  struct sockaddr_conn local_addr_;
+  struct sockaddr_conn remote_addr_;
+  struct socket *sctp_;
+  nsCOMPtr<nsITimer> timer_;
+  RefPtr<SendPeriodic> periodic_;
+  MtransportTestUtils* test_utils_;
+};
+
+
+// Implemented here because it calls a method of TransportTestPeer
+NS_IMETHODIMP SendPeriodic::Notify(nsITimer *timer) {
+  peer_->SendOne();
+  --to_send_;
+  if (!to_send_) {
+    timer->Cancel();
+  }
+  return NS_OK;
+}
+
+class SctpTransportTest : public MtransportTest {
+ public:
+  SctpTransportTest() {
+  }
+
+  ~SctpTransportTest() {
+  }
+
+  static void debug_printf(const char *format, ...) {
+    va_list ap;
+
+    va_start(ap, format);
+    vprintf(format, ap);
+    va_end(ap);
+  }
+
+
+  static void SetUpTestCase() {
+    if (sctp_logging) {
+      usrsctp_init(0, &TransportTestPeer::conn_output, debug_printf);
+      usrsctp_sysctl_set_sctp_debug_on(0xffffffff);
+    } else {
+      usrsctp_init(0, &TransportTestPeer::conn_output, nullptr);
+    }
+  }
+
+  void TearDown() override {
+    if (p1_)
+      p1_->Disconnect();
+    if (p2_)
+      p2_->Disconnect();
+    delete p1_;
+    delete p2_;
+
+    MtransportTest::TearDown();
+  }
+
+
+  void ConnectSocket(int p1port = 0, int p2port = 0) {
+    if (!p1port)
+      p1port = port_number++;
+    if (!p2port)
+      p2port = port_number++;
+
+    p1_ = new TransportTestPeer("P1", p1port, p2port, test_utils_);
+    p2_ = new TransportTestPeer("P2", p2port, p1port, test_utils_);
+
+    p1_->ConnectSocket(p2_);
+    p2_->ConnectSocket(p1_);
+    ASSERT_TRUE_WAIT(p1_->connected(), 2000);
+    ASSERT_TRUE_WAIT(p2_->connected(), 2000);
+  }
+
+  void TestTransfer(int expected = 1) {
+    std::cerr << "Starting trasnsfer test" << std::endl;
+    p1_->StartTransfer(expected);
+    ASSERT_TRUE_WAIT(p1_->sent() == expected, 10000);
+    ASSERT_TRUE_WAIT(p2_->received() == (expected * 100), 10000);
+    std::cerr << "P2 received " << p2_->received() << std::endl;
+  }
+
+ protected:
+  TransportTestPeer *p1_;
+  TransportTestPeer *p2_;
+};
+
+TEST_F(SctpTransportTest, TestConnect) {
+  ConnectSocket();
+}
+
+TEST_F(SctpTransportTest, TestConnectSymmetricalPorts) {
+  ConnectSocket(5002,5002);
+}
+
+TEST_F(SctpTransportTest, TestTransfer) {
+  ConnectSocket();
+  TestTransfer(50);
+}
+
+
+}  // end namespace
diff --git a/media/mtransport/test/simpletokenbucket_unittest.cpp b/media/mtransport/test/simpletokenbucket_unittest.cpp
new file mode 100644
index 000000000..70c962bb8
--- /dev/null
+++ b/media/mtransport/test/simpletokenbucket_unittest.cpp
@@ -0,0 +1,107 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+/* Original author: bcampen@mozilla.com */
+
+#include "simpletokenbucket.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+using mozilla::SimpleTokenBucket;
+
+class TestSimpleTokenBucket : public SimpleTokenBucket {
+  public:
+    TestSimpleTokenBucket(size_t bucketSize, size_t tokensPerSecond) :
+      SimpleTokenBucket(bucketSize, tokensPerSecond) {
+    }
+
+    void fastForward(int32_t timeMilliSeconds) {
+      if (timeMilliSeconds >= 0) {
+        last_time_tokens_added_ -= PR_MillisecondsToInterval(timeMilliSeconds);
+      } else {
+        last_time_tokens_added_ += PR_MillisecondsToInterval(-timeMilliSeconds);
+      }
+    }
+};
+
+TEST(SimpleTokenBucketTest, TestConstruct) {
+  TestSimpleTokenBucket b(10, 1);
+}
+
+TEST(SimpleTokenBucketTest, TestGet) {
+  TestSimpleTokenBucket b(10, 1);
+  ASSERT_EQ(5U, b.getTokens(5));
+}
+
+TEST(SimpleTokenBucketTest, TestGetAll) {
+  TestSimpleTokenBucket b(10, 1);
+  ASSERT_EQ(10U, b.getTokens(10));
+}
+
+TEST(SimpleTokenBucketTest, TestGetInsufficient) {
+  TestSimpleTokenBucket b(10, 1);
+  ASSERT_EQ(5U, b.getTokens(5));
+  ASSERT_EQ(5U, b.getTokens(6));
+}
+
+TEST(SimpleTokenBucketTest, TestGetBucketCount) {
+  TestSimpleTokenBucket b(10, 1);
+  ASSERT_EQ(10U, b.getTokens(UINT32_MAX));
+  ASSERT_EQ(5U, b.getTokens(5));
+  ASSERT_EQ(5U, b.getTokens(UINT32_MAX));
+}
+
+TEST(SimpleTokenBucketTest, TestTokenRefill) {
+  TestSimpleTokenBucket b(10, 1);
+  ASSERT_EQ(5U, b.getTokens(5));
+  b.fastForward(1000);
+  ASSERT_EQ(6U, b.getTokens(6));
+}
+
+TEST(SimpleTokenBucketTest, TestNoTimeWasted) {
+  // Makes sure that when the time elapsed is insufficient to add any
+  // tokens to the bucket, the internal timestamp that is used in this
+  // calculation is not updated (ie; two subsequent 0.5 second elapsed times
+  // counts as a full second)
+  TestSimpleTokenBucket b(10, 1);
+  ASSERT_EQ(5U, b.getTokens(5));
+  b.fastForward(500);
+  ASSERT_EQ(5U, b.getTokens(6));
+  b.fastForward(500);
+  ASSERT_EQ(6U, b.getTokens(6));
+}
+
+TEST(SimpleTokenBucketTest, TestNegativeTime) {
+  TestSimpleTokenBucket b(10, 1);
+  b.fastForward(-1000);
+  // Make sure we don't end up with an invalid number of tokens, but otherwise
+  // permit anything.
+  ASSERT_GT(11U, b.getTokens(100));
+}
+
+TEST(SimpleTokenBucketTest, TestEmptyBucket) {
+  TestSimpleTokenBucket b(10, 1);
+  ASSERT_EQ(10U, b.getTokens(10));
+  ASSERT_EQ(0U, b.getTokens(10));
+}
+
+TEST(SimpleTokenBucketTest, TestEmptyThenFillBucket) {
+  TestSimpleTokenBucket b(10, 1);
+  ASSERT_EQ(10U, b.getTokens(10));
+  ASSERT_EQ(0U, b.getTokens(1));
+  b.fastForward(50000);
+  ASSERT_EQ(10U, b.getTokens(10));
+}
+
+TEST(SimpleTokenBucketTest, TestNoOverflow) {
+  TestSimpleTokenBucket b(10, 1);
+  ASSERT_EQ(10U, b.getTokens(10));
+  ASSERT_EQ(0U, b.getTokens(1));
+  b.fastForward(50000);
+  ASSERT_EQ(10U, b.getTokens(11));
+}
diff --git a/media/mtransport/test/sockettransportservice_unittest.cpp b/media/mtransport/test/sockettransportservice_unittest.cpp
new file mode 100644
index 000000000..43746c908
--- /dev/null
+++ b/media/mtransport/test/sockettransportservice_unittest.cpp
@@ -0,0 +1,208 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: ekr@rtfm.com
+#include <iostream>
+
+#include "prio.h"
+
+#include "nsCOMPtr.h"
+#include "nsNetCID.h"
+#include "nsXPCOM.h"
+#include "nsXPCOMGlue.h"
+
+#include "nsIComponentManager.h"
+#include "nsIComponentRegistrar.h"
+#include "nsIIOService.h"
+#include "nsIServiceManager.h"
+#include "nsISocketTransportService.h"
+
+#include "nsASocketHandler.h"
+#include "nsServiceManagerUtils.h"
+#include "nsThreadUtils.h"
+
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+using namespace mozilla;
+
+namespace {
+class SocketTransportServiceTest : public MtransportTest {
+ public:
+  SocketTransportServiceTest() : MtransportTest(),
+                                 received_(0),
+                                 readpipe_(nullptr),
+                                 writepipe_(nullptr),
+                                 registered_(false) {
+  }
+
+  ~SocketTransportServiceTest() {
+    if (readpipe_)
+      PR_Close(readpipe_);
+    if (writepipe_)
+      PR_Close(writepipe_);
+  }
+
+  void SetUp();
+  void RegisterHandler();
+  void SendEvent();
+  void SendPacket();
+
+  void ReceivePacket() {
+    ++received_;
+  }
+
+  void ReceiveEvent() {
+    ++received_;
+  }
+
+  size_t Received() {
+    return received_;
+  }
+
+ private:
+  nsCOMPtr<nsISocketTransportService> stservice_;
+  nsCOMPtr<nsIEventTarget> target_;
+  size_t received_;
+  PRFileDesc *readpipe_;
+  PRFileDesc *writepipe_;
+  bool registered_;
+};
+
+
+// Received an event.
+class EventReceived : public Runnable {
+public:
+  explicit EventReceived(SocketTransportServiceTest *test) :
+      test_(test) {}
+
+  NS_IMETHOD Run() override {
+    test_->ReceiveEvent();
+    return NS_OK;
+  }
+
+  SocketTransportServiceTest *test_;
+};
+
+
+// Register our listener on the socket
+class RegisterEvent : public Runnable {
+public:
+  explicit RegisterEvent(SocketTransportServiceTest *test) :
+      test_(test) {}
+
+  NS_IMETHOD Run() override {
+    test_->RegisterHandler();
+    return NS_OK;
+  }
+
+  SocketTransportServiceTest *test_;
+};
+
+
+class SocketHandler : public nsASocketHandler {
+ public:
+  explicit SocketHandler(SocketTransportServiceTest *test) : test_(test) {
+  }
+
+  void OnSocketReady(PRFileDesc *fd, int16_t outflags) override {
+    unsigned char buf[1600];
+
+    int32_t rv;
+    rv = PR_Recv(fd, buf, sizeof(buf), 0, PR_INTERVAL_NO_WAIT);
+    if (rv > 0) {
+      std::cerr << "Read " << rv << " bytes" << std::endl;
+      test_->ReceivePacket();
+    }
+  }
+
+  void OnSocketDetached(PRFileDesc *fd) override {}
+
+  void IsLocal(bool *aIsLocal) override {
+    // TODO(jesup): better check? Does it matter? (likely no)
+    *aIsLocal = false;
+  }
+
+  virtual uint64_t ByteCountSent() override { return 0; }
+  virtual uint64_t ByteCountReceived() override { return 0; }
+
+  NS_DECL_ISUPPORTS
+
+ protected:
+  virtual ~SocketHandler() {}
+
+ private:
+  SocketTransportServiceTest *test_;
+};
+
+NS_IMPL_ISUPPORTS0(SocketHandler)
+
+void SocketTransportServiceTest::SetUp() {
+  MtransportTest::SetUp();
+
+  // Get the transport service as a dispatch target
+  nsresult rv;
+  target_ = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+
+  // Get the transport service as a transport service
+  stservice_ = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+
+  // Create a loopback pipe
+  PRStatus status = PR_CreatePipe(&readpipe_, &writepipe_);
+  ASSERT_EQ(status, PR_SUCCESS);
+
+  // Register ourselves as a listener for the read side of the
+  // socket. The registration has to happen on the STS thread,
+  // hence this event stuff.
+  rv = target_->Dispatch(new RegisterEvent(this), 0);
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+  ASSERT_TRUE_WAIT(registered_, 10000);
+
+}
+
+void SocketTransportServiceTest::RegisterHandler() {
+  nsresult rv;
+
+  rv = stservice_->AttachSocket(readpipe_, new SocketHandler(this));
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+
+  registered_ = true;
+}
+
+void SocketTransportServiceTest::SendEvent() {
+  nsresult rv;
+
+  rv = target_->Dispatch(new EventReceived(this), 0);
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+  ASSERT_TRUE_WAIT(Received() == 1, 10000);
+}
+
+void SocketTransportServiceTest::SendPacket() {
+  unsigned char buffer[1024];
+  memset(buffer, 0, sizeof(buffer));
+
+  int32_t status = PR_Write(writepipe_, buffer, sizeof(buffer));
+  uint32_t size = status & 0xffff;
+  ASSERT_EQ(sizeof(buffer), size);
+}
+
+
+
+// The unit tests themselves
+TEST_F(SocketTransportServiceTest, SendEvent) {
+  SendEvent();
+}
+
+TEST_F(SocketTransportServiceTest, SendPacket) {
+  SendPacket();
+}
+
+
+}  // end namespace
diff --git a/media/mtransport/test/stunserver.cpp b/media/mtransport/test/stunserver.cpp
new file mode 100644
index 000000000..7318c7c95
--- /dev/null
+++ b/media/mtransport/test/stunserver.cpp
@@ -0,0 +1,664 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: ekr@rtfm.com
+
+/*
+Original code from nICEr and nrappkit.
+
+nICEr copyright:
+
+Copyright (c) 2007, Adobe Systems, Incorporated
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+* Neither the name of Adobe Systems, Network Resonance nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+
+nrappkit copyright:
+
+   Copyright (C) 2001-2003, Network Resonance, Inc.
+   Copyright (C) 2006, Network Resonance, Inc.
+   All Rights Reserved
+
+   Redistribution and use in source and binary forms, with or without
+   modification, are permitted provided that the following conditions
+   are met:
+
+   1. Redistributions of source code must retain the above copyright
+      notice, this list of conditions and the following disclaimer.
+   2. Redistributions in binary form must reproduce the above copyright
+      notice, this list of conditions and the following disclaimer in the
+      documentation and/or other materials provided with the distribution.
+   3. Neither the name of Network Resonance, Inc. nor the name of any
+      contributors to this software may be used to endorse or promote
+      products derived from this software without specific prior written
+      permission.
+
+   THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ``AS IS''
+   AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+   IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+   ARE DISCLAIMED.  IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
+   LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
+   CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
+   SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
+   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
+   CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
+   ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
+   POSSIBILITY OF SUCH DAMAGE.
+
+
+   ekr@rtfm.com  Thu Dec 20 20:14:49 2001
+*/
+#include "logging.h"
+#include "mozilla/UniquePtr.h"
+#include "mozilla/Unused.h"
+#include "databuffer.h"
+
+extern "C" {
+#include "nr_api.h"
+#include "async_wait.h"
+#include "async_timer.h"
+#include "nr_socket.h"
+#include "nr_socket_local.h"
+#include "transport_addr.h"
+#include "addrs.h"
+#include "local_addr.h"
+#include "stun_util.h"
+#include "registry.h"
+#include "nr_socket_buffered_stun.h"
+}
+
+#include "stunserver.h"
+
+#include <string>
+
+MOZ_MTLOG_MODULE("stunserver");
+
+namespace mozilla {
+
+// Wrapper nr_socket which allows us to lie to the stun server about the
+// IP address.
+struct nr_socket_wrapped {
+  nr_socket *sock_;
+  nr_transport_addr addr_;
+};
+
+static int nr_socket_wrapped_destroy(void **objp) {
+  if (!objp || !*objp)
+    return 0;
+
+  nr_socket_wrapped *wrapped = static_cast<nr_socket_wrapped *>(*objp);
+  *objp = 0;
+
+  delete wrapped;
+
+  return 0;
+}
+
+static int nr_socket_wrapped_sendto(void *obj, const void *msg, size_t len, int flags,
+    nr_transport_addr *addr) {
+  nr_socket_wrapped *wrapped = static_cast<nr_socket_wrapped *>(obj);
+
+  return nr_socket_sendto(wrapped->sock_, msg, len, flags, &wrapped->addr_);
+}
+
+static int nr_socket_wrapped_recvfrom(void *obj, void * restrict buf, size_t maxlen,
+    size_t *len, int flags, nr_transport_addr *addr) {
+  nr_socket_wrapped *wrapped = static_cast<nr_socket_wrapped *>(obj);
+
+  return nr_socket_recvfrom(wrapped->sock_, buf, maxlen, len, flags, addr);
+}
+
+static int nr_socket_wrapped_getfd(void *obj, NR_SOCKET *fd) {
+  nr_socket_wrapped *wrapped = static_cast<nr_socket_wrapped *>(obj);
+
+  return nr_socket_getfd(wrapped->sock_, fd);
+}
+
+static int nr_socket_wrapped_getaddr(void *obj, nr_transport_addr *addrp) {
+  nr_socket_wrapped *wrapped = static_cast<nr_socket_wrapped *>(obj);
+
+  return nr_socket_getaddr(wrapped->sock_, addrp);
+}
+
+static int nr_socket_wrapped_close(void *obj) {
+  MOZ_CRASH();
+}
+
+static int nr_socket_wrapped_set_send_addr(nr_socket *sock, nr_transport_addr *addr) {
+  nr_socket_wrapped *wrapped = static_cast<nr_socket_wrapped *>(sock->obj);
+
+  return nr_transport_addr_copy(&wrapped->addr_, addr);
+}
+
+static nr_socket_vtbl nr_socket_wrapped_vtbl = {
+  2,
+  nr_socket_wrapped_destroy,
+  nr_socket_wrapped_sendto,
+  nr_socket_wrapped_recvfrom,
+  nr_socket_wrapped_getfd,
+  nr_socket_wrapped_getaddr,
+  0,
+  0,
+  0,
+  nr_socket_wrapped_close,
+  0,
+  0
+};
+
+int nr_socket_wrapped_create(nr_socket *inner, nr_socket **outp) {
+  auto wrapped = MakeUnique<nr_socket_wrapped>();
+
+  wrapped->sock_ = inner;
+
+  int r = nr_socket_create_int(wrapped.get(), &nr_socket_wrapped_vtbl, outp);
+  if (r)
+    return r;
+
+  Unused << wrapped.release();
+  return 0;
+}
+
+
+// Instance static.
+// Note: Calling Create() at static init time is not going to be safe, since
+// we have no reason to expect this will be initted to a nullptr yet.
+TestStunServer *TestStunServer::instance;
+TestStunTcpServer *TestStunTcpServer::instance;
+TestStunServer *TestStunServer::instance6;
+TestStunTcpServer *TestStunTcpServer::instance6;
+uint16_t TestStunServer::instance_port = 3478;
+uint16_t TestStunTcpServer::instance_port = 3478;
+
+TestStunServer::~TestStunServer() {
+  // TODO(ekr@rtfm.com): Put this on the right thread.
+
+  // Unhook callback from our listen socket.
+  if (listen_sock_) {
+    NR_SOCKET fd;
+    if (!nr_socket_getfd(listen_sock_, &fd)) {
+      NR_ASYNC_CANCEL(fd, NR_ASYNC_WAIT_READ);
+    }
+  }
+
+  // Free up stun context and network resources
+  nr_stun_server_ctx_destroy(&stun_server_);
+  nr_socket_destroy(&listen_sock_);
+  nr_socket_destroy(&send_sock_);
+
+  // Make sure we aren't still waiting on a deferred response timer to pop
+  if (timer_handle_)
+    NR_async_timer_cancel(timer_handle_);
+
+  delete response_addr_;
+}
+
+int TestStunServer::SetInternalPort(nr_local_addr *addr, uint16_t port) {
+  if (nr_transport_addr_set_port(&addr->addr, port)) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't set port");
+    return R_INTERNAL;
+  }
+
+  if (nr_transport_addr_fmt_addr_string(&addr->addr)) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't re-set addr string");
+    return R_INTERNAL;
+  }
+
+  return 0;
+}
+
+int TestStunServer::TryOpenListenSocket(nr_local_addr *addr, uint16_t port) {
+
+  int r = SetInternalPort(addr, port);
+
+  if (r)
+    return r;
+
+  if (nr_socket_local_create(nullptr, &addr->addr, &listen_sock_)) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't create listen socket");
+    return R_ALREADY;
+  }
+
+  return 0;
+}
+
+int TestStunServer::Initialize(int address_family) {
+  static const size_t max_addrs = 100;
+  nr_local_addr addrs[max_addrs];
+  int addr_ct;
+  int r;
+  int i;
+
+  r = nr_stun_find_local_addresses(addrs, max_addrs, &addr_ct);
+  if (r) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't retrieve addresses");
+    return R_INTERNAL;
+  }
+
+  if (addr_ct < 1) {
+    MOZ_MTLOG(ML_ERROR, "No local addresses");
+    return R_INTERNAL;
+  }
+
+  for (i = 0; i < addr_ct; ++i) {
+    if (addrs[i].addr.addr->sa_family == address_family) {
+      break;
+    }
+  }
+
+  if (i == addr_ct) {
+    MOZ_MTLOG(ML_ERROR, "No local addresses of the configured IP version");
+    return R_INTERNAL;
+  }
+
+  int tries = 100;
+  while (tries--) {
+    // Bind on configured port (default 3478)
+    r = TryOpenListenSocket(&addrs[i], instance_port);
+    // We interpret R_ALREADY to mean the addr is probably in use. Try another.
+    // Otherwise, it either worked or it didn't, and we check below.
+    if (r != R_ALREADY) {
+      break;
+    }
+    ++instance_port;
+  }
+
+  if (r) {
+    return R_INTERNAL;
+  }
+
+  r = nr_socket_wrapped_create(listen_sock_, &send_sock_);
+  if (r) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't create send socket");
+    return R_INTERNAL;
+  }
+
+  r = nr_stun_server_ctx_create(const_cast<char *>("Test STUN server"),
+                                send_sock_,
+                                &stun_server_);
+  if (r) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't create STUN server");
+    return R_INTERNAL;
+  }
+
+  // Cache the address and port.
+  char addr_string[INET6_ADDRSTRLEN];
+  r = nr_transport_addr_get_addrstring(&addrs[i].addr, addr_string,
+                                       sizeof(addr_string));
+  if (r) {
+    MOZ_MTLOG(ML_ERROR, "Failed to convert listen addr to a string representation");
+    return R_INTERNAL;
+  }
+
+  listen_addr_ = addr_string;
+  listen_port_ = instance_port;
+
+  return 0;
+}
+
+UniquePtr<TestStunServer> TestStunServer::Create(int address_family) {
+  NR_reg_init(NR_REG_MODE_LOCAL);
+
+  UniquePtr<TestStunServer> server(new TestStunServer());
+
+  if (server->Initialize(address_family))
+    return nullptr;
+
+  NR_SOCKET fd;
+  int r = nr_socket_getfd(server->listen_sock_, &fd);
+  if (r) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't get fd");
+    return nullptr;
+  }
+
+  NR_ASYNC_WAIT(fd, NR_ASYNC_WAIT_READ, &TestStunServer::readable_cb, server.get());
+
+  return server;
+}
+
+void TestStunServer::ConfigurePort(uint16_t port) {
+  instance_port = port;
+}
+
+TestStunServer* TestStunServer::GetInstance(int address_family) {
+  switch (address_family) {
+    case AF_INET:
+      if (!instance)
+        instance = Create(address_family).release();
+
+      MOZ_ASSERT(instance);
+      return instance;
+    case AF_INET6:
+      if (!instance6)
+        instance6 = Create(address_family).release();
+
+      return instance6;
+    default:
+      MOZ_CRASH();
+  }
+}
+
+void TestStunServer::ShutdownInstance() {
+  delete instance;
+  instance = nullptr;
+  delete instance6;
+  instance6 = nullptr;
+}
+
+
+struct DeferredStunOperation {
+  DeferredStunOperation(TestStunServer *server,
+                        const char *data, size_t len,
+                        nr_transport_addr *addr,
+                        nr_socket *sock) :
+      server_(server),
+      buffer_(reinterpret_cast<const uint8_t *>(data), len),
+      sock_(sock) {
+    nr_transport_addr_copy(&addr_, addr);
+  }
+
+  TestStunServer *server_;
+  DataBuffer buffer_;
+  nr_transport_addr addr_;
+  nr_socket *sock_;
+};
+
+void TestStunServer::Process(const uint8_t *msg, size_t len, nr_transport_addr *addr, nr_socket *sock) {
+
+  if (!sock) {
+    sock = send_sock_;
+  }
+
+  // Set the wrapped address so that the response goes to the right place.
+  nr_socket_wrapped_set_send_addr(sock, addr);
+
+  nr_stun_server_process_request(stun_server_, sock,
+                                 const_cast<char *>(reinterpret_cast<const char *>(msg)),
+                                 len,
+                                 response_addr_ ?
+                                 response_addr_ : addr,
+                                 NR_STUN_AUTH_RULE_OPTIONAL);
+}
+
+void TestStunServer::process_cb(NR_SOCKET s, int how, void *cb_arg) {
+  DeferredStunOperation *op = static_cast<DeferredStunOperation *>(cb_arg);
+  op->server_->timer_handle_ = nullptr;
+  op->server_->Process(op->buffer_.data(), op->buffer_.len(), &op->addr_, op->sock_);
+
+  delete op;
+}
+
+nr_socket* TestStunServer::GetReceivingSocket(NR_SOCKET s) {
+  return listen_sock_;
+}
+
+nr_socket* TestStunServer::GetSendingSocket(nr_socket *sock) {
+  return send_sock_;
+}
+
+void TestStunServer::readable_cb(NR_SOCKET s, int how, void *cb_arg) {
+  TestStunServer *server = static_cast<TestStunServer*>(cb_arg);
+
+  char message[max_stun_message_size];
+  size_t message_len;
+  nr_transport_addr addr;
+  nr_socket *recv_sock = server->GetReceivingSocket(s);
+  if (!recv_sock) {
+    MOZ_MTLOG(ML_ERROR, "Failed to lookup receiving socket");
+    return;
+  }
+  nr_socket *send_sock = server->GetSendingSocket(recv_sock);
+
+  /* Re-arm. */
+  NR_ASYNC_WAIT(s, NR_ASYNC_WAIT_READ, &TestStunServer::readable_cb, server);
+
+  if (nr_socket_recvfrom(recv_sock, message, sizeof(message),
+      &message_len, 0, &addr)) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't read STUN message");
+    return;
+  }
+
+  MOZ_MTLOG(ML_DEBUG, "Received data of length " << message_len);
+
+  // If we have initial dropping set, check at this point.
+  std::string key(addr.as_string);
+
+  if (server->received_ct_.count(key) == 0) {
+    server->received_ct_[key] = 0;
+  }
+
+  ++server->received_ct_[key];
+
+  if (!server->active_ || (server->received_ct_[key] <= server->initial_ct_)) {
+    MOZ_MTLOG(ML_DEBUG, "Dropping message #"
+              << server->received_ct_[key] << " from " << key);
+    return;
+  }
+
+  if (server->delay_ms_) {
+    NR_ASYNC_TIMER_SET(server->delay_ms_,
+                       process_cb,
+                       new DeferredStunOperation(
+                           server,
+                           message, message_len,
+                           &addr, send_sock),
+                       &server->timer_handle_);
+  } else {
+    server->Process(reinterpret_cast<const uint8_t *>(message), message_len,
+                    &addr, send_sock);
+  }
+}
+
+void TestStunServer::SetActive(bool active) {
+  active_ = active;
+}
+
+void TestStunServer::SetDelay(uint32_t delay_ms) {
+  delay_ms_ = delay_ms;
+}
+
+void TestStunServer::SetDropInitialPackets(uint32_t count) {
+  initial_ct_ = count;
+}
+
+nsresult TestStunServer::SetResponseAddr(nr_transport_addr *addr) {
+  delete response_addr_;
+
+  response_addr_ = new nr_transport_addr();
+
+  int r = nr_transport_addr_copy(response_addr_, addr);
+  if (r)
+    return NS_ERROR_FAILURE;
+
+  return NS_OK;
+}
+
+nsresult TestStunServer::SetResponseAddr(const std::string& addr,
+                                         uint16_t port) {
+  nr_transport_addr addr2;
+
+  int r = nr_str_port_to_transport_addr(addr.c_str(),
+                                        port, IPPROTO_UDP,
+                                        &addr2);
+  if (r)
+    return NS_ERROR_FAILURE;
+
+  return SetResponseAddr(&addr2);
+}
+
+void TestStunServer::Reset() {
+  delay_ms_ = 0;
+  if (timer_handle_) {
+    NR_async_timer_cancel(timer_handle_);
+    timer_handle_ = nullptr;
+  }
+  delete response_addr_;
+  response_addr_ = nullptr;
+  received_ct_.clear();
+}
+
+
+// TestStunTcpServer
+
+void TestStunTcpServer::ConfigurePort(uint16_t port) {
+  instance_port = port;
+}
+
+TestStunTcpServer* TestStunTcpServer::GetInstance(int address_family) {
+  switch (address_family) {
+    case AF_INET:
+      if (!instance)
+        instance = Create(address_family).release();
+
+      MOZ_ASSERT(instance);
+      return instance;
+    case AF_INET6:
+      if (!instance6)
+        instance6 = Create(address_family).release();
+
+      return instance6;
+    default:
+      MOZ_CRASH();
+  }
+}
+
+void TestStunTcpServer::ShutdownInstance() {
+  delete instance;
+  instance = nullptr;
+  delete instance6;
+  instance6 = nullptr;
+}
+
+int TestStunTcpServer::TryOpenListenSocket(nr_local_addr *addr, uint16_t port) {
+
+  addr->addr.protocol=IPPROTO_TCP;
+
+  int r = SetInternalPort(addr, port);
+
+  if (r)
+    return r;
+
+  nr_socket *sock;
+  if (nr_socket_local_create(nullptr, &addr->addr, &sock)) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't create listen tcp socket");
+    return R_ALREADY;
+  }
+
+  if (nr_socket_buffered_stun_create(sock, 2048, TURN_TCP_FRAMING, &listen_sock_)) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't create listen tcp socket");
+    return R_ALREADY;
+  }
+
+  if(nr_socket_listen(listen_sock_, 10)) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't listen on socket");
+    return R_ALREADY;
+  }
+
+  return 0;
+}
+
+nr_socket* TestStunTcpServer::GetReceivingSocket(NR_SOCKET s) {
+  return connections_[s];
+}
+
+nr_socket* TestStunTcpServer::GetSendingSocket(nr_socket *sock) {
+  return sock;
+}
+
+void TestStunTcpServer::accept_cb(NR_SOCKET s, int how, void *cb_arg) {
+  TestStunTcpServer *server = static_cast<TestStunTcpServer*>(cb_arg);
+  nr_socket *newsock, *bufsock, *wrapsock;
+  nr_transport_addr remote_addr;
+  NR_SOCKET fd;
+
+  /* rearm */
+  NR_ASYNC_WAIT(s, NR_ASYNC_WAIT_READ, &TestStunTcpServer::accept_cb, cb_arg);
+
+  /* accept */
+  if (nr_socket_accept(server->listen_sock_, &remote_addr, &newsock)) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't accept incoming tcp connection");
+    return;
+  }
+
+  if(nr_socket_buffered_stun_create(newsock, 2048, TURN_TCP_FRAMING, &bufsock)) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't create connected tcp socket");
+    nr_socket_destroy(&newsock);
+    return;
+  }
+
+  nr_socket_buffered_set_connected_to(bufsock, &remote_addr);
+
+  if(nr_socket_wrapped_create(bufsock, &wrapsock)) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't wrap connected tcp socket");
+    nr_socket_destroy(&bufsock);
+    return;
+  }
+
+  if(nr_socket_getfd(wrapsock, &fd)) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't get fd from connected tcp socket");
+    nr_socket_destroy(&wrapsock);
+    return;
+  }
+
+  server->connections_[fd] = wrapsock;
+
+  NR_ASYNC_WAIT(fd, NR_ASYNC_WAIT_READ, &TestStunServer::readable_cb, server);
+}
+
+  UniquePtr<TestStunTcpServer> TestStunTcpServer::Create(int address_family) {
+  NR_reg_init(NR_REG_MODE_LOCAL);
+
+  UniquePtr<TestStunTcpServer> server(new TestStunTcpServer());
+
+  if (server->Initialize(address_family)) {
+    return nullptr;
+  }
+
+  NR_SOCKET fd;
+  if(nr_socket_getfd(server->listen_sock_, &fd)) {
+    MOZ_MTLOG(ML_ERROR, "Couldn't get tcp fd");
+    return nullptr;
+  }
+
+  NR_ASYNC_WAIT(fd, NR_ASYNC_WAIT_READ, &TestStunTcpServer::accept_cb, server.get());
+
+  return server;
+}
+
+TestStunTcpServer::~TestStunTcpServer() {
+  for (auto it = connections_.begin(); it != connections_.end();) {
+    NR_ASYNC_CANCEL(it->first, NR_ASYNC_WAIT_READ);
+    nr_socket_destroy(&it->second);
+    connections_.erase(it++);
+  }
+}
+
+}  // close namespace
diff --git a/media/mtransport/test/stunserver.h b/media/mtransport/test/stunserver.h
new file mode 100644
index 000000000..33f1b2a31
--- /dev/null
+++ b/media/mtransport/test/stunserver.h
@@ -0,0 +1,123 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: ekr@rtfm.com
+
+#ifndef stunserver_h__
+#define stunserver_h__
+
+#include <map>
+#include <string>
+#include "prio.h"
+#include "nsError.h"
+#include "mozilla/UniquePtr.h"
+
+typedef struct nr_stun_server_ctx_ nr_stun_server_ctx;
+typedef struct nr_socket_ nr_socket;
+typedef struct nr_local_addr_ nr_local_addr;
+
+
+namespace mozilla {
+
+class TestStunServer {
+ public:
+  // Generally, you should only call API in this class from the same thread that
+  // the initial |GetInstance| call was made from.
+  static TestStunServer *GetInstance(int address_family = AF_INET);
+  static void ShutdownInstance();
+  // |ConfigurePort| will only have an effect if called before the first call
+  // to |GetInstance| (possibly following a |ShutdownInstance| call)
+  static void ConfigurePort(uint16_t port);
+  // AF_INET, AF_INET6
+  static UniquePtr<TestStunServer> Create(int address_family);
+
+  virtual ~TestStunServer();
+
+  void SetActive(bool active);
+  void SetDelay(uint32_t delay_ms);
+  void SetDropInitialPackets(uint32_t count);
+  const std::string& addr() const { return listen_addr_; }
+  uint16_t port() const { return listen_port_; }
+
+  // These should only be called from the same thread as the initial
+  // |GetInstance| call.
+  nsresult SetResponseAddr(nr_transport_addr *addr);
+  nsresult SetResponseAddr(const std::string& addr, uint16_t port);
+
+  void Reset();
+
+  static const size_t max_stun_message_size = 4096;
+
+  virtual nr_socket* GetReceivingSocket(NR_SOCKET s);
+  virtual nr_socket* GetSendingSocket(nr_socket *sock);
+
+ protected:
+  TestStunServer()
+      : listen_port_(0),
+        listen_sock_(nullptr),
+        send_sock_(nullptr),
+        stun_server_(nullptr),
+        active_(true),
+        delay_ms_(0),
+        initial_ct_(0),
+        response_addr_(nullptr),
+        timer_handle_(nullptr) {}
+
+  int SetInternalPort(nr_local_addr *addr, uint16_t port);
+  int Initialize(int address_family);
+
+  static void readable_cb(NR_SOCKET sock, int how, void *cb_arg);
+
+ private:
+  void Process(const uint8_t *msg, size_t len, nr_transport_addr *addr_in, nr_socket *sock);
+  virtual int TryOpenListenSocket(nr_local_addr *addr, uint16_t port);
+  static void process_cb(NR_SOCKET sock, int how, void *cb_arg);
+
+ protected:
+  std::string listen_addr_;
+  uint16_t listen_port_;
+  nr_socket *listen_sock_;
+  nr_socket *send_sock_;
+  nr_stun_server_ctx *stun_server_;
+ private:
+  bool active_;
+  uint32_t delay_ms_;
+  uint32_t initial_ct_;
+  nr_transport_addr *response_addr_;
+  void *timer_handle_;
+  std::map<std::string, uint32_t> received_ct_;
+
+  static TestStunServer *instance;
+  static TestStunServer *instance6;
+  static uint16_t instance_port;
+};
+
+class TestStunTcpServer: public TestStunServer {
+ public:
+  static TestStunTcpServer *GetInstance(int address_family);
+  static void ShutdownInstance();
+  static void ConfigurePort(uint16_t port);
+  virtual ~TestStunTcpServer();
+
+  virtual nr_socket* GetReceivingSocket(NR_SOCKET s);
+  virtual nr_socket* GetSendingSocket(nr_socket *sock);
+
+ protected:
+  TestStunTcpServer() {}
+  static void accept_cb(NR_SOCKET sock, int how, void *cb_arg);
+
+ private:
+  virtual int TryOpenListenSocket(nr_local_addr *addr, uint16_t port);
+  static UniquePtr<TestStunTcpServer> Create(int address_family);
+
+  static TestStunTcpServer *instance;
+  static TestStunTcpServer *instance6;
+  static uint16_t instance_port;
+
+  std::map<NR_SOCKET, nr_socket*> connections_;
+};
+} // End of namespace mozilla
+#endif
diff --git a/media/mtransport/test/test_nr_socket_unittest.cpp b/media/mtransport/test/test_nr_socket_unittest.cpp
new file mode 100644
index 000000000..5e0a396d3
--- /dev/null
+++ b/media/mtransport/test/test_nr_socket_unittest.cpp
@@ -0,0 +1,878 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: bcampen@mozilla.com
+
+extern "C" {
+#include "stun_msg.h" // for NR_STUN_MAX_MESSAGE_SIZE
+#include "stun_util.h"
+#include "nr_api.h"
+#include "async_wait.h"
+#include "nr_socket.h"
+#include "nr_socket_local.h"
+#include "stun_hint.h"
+#include "local_addr.h"
+#include "registry.h"
+}
+
+#include "test_nr_socket.h"
+
+#include "nsCOMPtr.h"
+#include "nsNetCID.h"
+#include "nsServiceManagerUtils.h"
+#include "nsAutoPtr.h"
+#include "runnable_utils.h"
+
+#include <vector>
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+#define DATA_BUF_SIZE 1024
+
+namespace mozilla {
+
+class TestNrSocketTest : public MtransportTest {
+ public:
+  TestNrSocketTest() :
+    MtransportTest(),
+    wait_done_for_main_(false),
+    sts_(),
+    public_addrs_(),
+    private_addrs_(),
+    nats_() {
+  }
+
+  void SetUp() override {
+    MtransportTest::SetUp();
+
+    // Get the transport service as a dispatch target
+    nsresult rv;
+    sts_ = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+    EXPECT_TRUE(NS_SUCCEEDED(rv)) << "Failed to get STS: " << (int)rv;
+  }
+
+  void TearDown() override {
+    sts_->Dispatch(WrapRunnable(this, &TestNrSocketTest::TearDown_s),
+                   NS_DISPATCH_SYNC);
+
+    MtransportTest::TearDown();
+  }
+
+  void TearDown_s() {
+    public_addrs_.clear();
+    private_addrs_.clear();
+    nats_.clear();
+    sts_ = nullptr;
+  }
+
+  RefPtr<TestNrSocket> CreateTestNrSocket_s(const char *ip_str,
+                                            int proto,
+                                            TestNat *nat) {
+    // If no nat is supplied, we create a default NAT which is disabled. This
+    // is how we simulate a non-natted socket.
+    RefPtr<TestNrSocket> sock(new TestNrSocket(nat ? nat : new TestNat));
+    nr_transport_addr address;
+    nr_str_port_to_transport_addr(ip_str, 0, proto, &address);
+    int r = sock->create(&address);
+    if (r) {
+      return nullptr;
+    }
+    return sock;
+  }
+
+  void CreatePublicAddrs(size_t count,
+                         const char *ip_str = "127.0.0.1",
+                         int proto = IPPROTO_UDP) {
+    sts_->Dispatch(
+        WrapRunnable(this,
+                     &TestNrSocketTest::CreatePublicAddrs_s,
+                     count,
+                     ip_str,
+                     proto),
+        NS_DISPATCH_SYNC);
+  }
+
+  void CreatePublicAddrs_s(size_t count, const char* ip_str, int proto) {
+    while (count--) {
+      auto sock = CreateTestNrSocket_s(ip_str, proto, nullptr);
+      ASSERT_TRUE(sock) << "Failed to create socket";
+      public_addrs_.push_back(sock);
+    }
+  }
+
+  RefPtr<TestNat> CreatePrivateAddrs(size_t size,
+                                     const char* ip_str = "127.0.0.1",
+                                     int proto = IPPROTO_UDP) {
+    RefPtr<TestNat> result;
+    sts_->Dispatch(
+        WrapRunnableRet(&result,
+                        this,
+                        &TestNrSocketTest::CreatePrivateAddrs_s,
+                        size,
+                        ip_str,
+                        proto),
+        NS_DISPATCH_SYNC);
+    return result;
+  }
+
+  RefPtr<TestNat> CreatePrivateAddrs_s(size_t count,
+                                       const char* ip_str,
+                                       int proto) {
+    RefPtr<TestNat> nat(new TestNat);
+    while (count--) {
+      auto sock = CreateTestNrSocket_s(ip_str, proto, nat);
+      if (!sock) {
+        EXPECT_TRUE(false) << "Failed to create socket";
+        break;
+      }
+      private_addrs_.push_back(sock);
+    }
+    nat->enabled_ = true;
+    nats_.push_back(nat);
+    return nat;
+  }
+
+  bool CheckConnectivityVia(
+      TestNrSocket *from,
+      TestNrSocket *to,
+      const nr_transport_addr &via,
+      nr_transport_addr *sender_external_address = nullptr) {
+    MOZ_ASSERT(from);
+
+    if (!WaitForWriteable(from)) {
+      return false;
+    }
+
+    int result = 0;
+    sts_->Dispatch(WrapRunnableRet(&result,
+                                   this,
+                                   &TestNrSocketTest::SendData_s,
+                                   from,
+                                   via),
+                   NS_DISPATCH_SYNC);
+    if (result) {
+      return false;
+    }
+
+    if (!WaitForReadable(to)) {
+      return false;
+    }
+
+    nr_transport_addr dummy_outparam;
+    if (!sender_external_address) {
+      sender_external_address = &dummy_outparam;
+    }
+
+    MOZ_ASSERT(to);
+    sts_->Dispatch(WrapRunnableRet(&result,
+                                   this,
+                                   &TestNrSocketTest::RecvData_s,
+                                   to,
+                                   sender_external_address),
+                   NS_DISPATCH_SYNC);
+
+    return !result;
+  }
+
+  bool CheckConnectivity(
+      TestNrSocket *from,
+      TestNrSocket *to,
+      nr_transport_addr *sender_external_address = nullptr) {
+    nr_transport_addr destination_address;
+    int r = GetAddress(to, &destination_address);
+    if (r) {
+      return false;
+    }
+
+    return CheckConnectivityVia(from,
+                                to,
+                                destination_address,
+                                sender_external_address);
+  }
+
+  bool CheckTcpConnectivity(TestNrSocket *from, TestNrSocket *to) {
+    NrSocketBase *accepted_sock;
+    if (!Connect(from, to, &accepted_sock)) {
+      std::cerr << "Connect failed" << std::endl;
+      return false;
+    }
+
+    // write on |from|, recv on |accepted_sock|
+    if (!WaitForWriteable(from)) {
+      std::cerr << __LINE__ << "WaitForWriteable (1) failed" << std::endl;
+      return false;
+    }
+
+    int r;
+    sts_->Dispatch(WrapRunnableRet(&r,
+                                   this,
+                                   &TestNrSocketTest::SendDataTcp_s,
+                                   from),
+                   NS_DISPATCH_SYNC);
+    if (r) {
+      std::cerr << "SendDataTcp_s (1) failed" << std::endl;
+      return false;
+    }
+
+    if (!WaitForReadable(accepted_sock)) {
+      std::cerr << __LINE__ << "WaitForReadable (1) failed" << std::endl;
+      return false;
+    }
+
+    sts_->Dispatch(WrapRunnableRet(&r,
+                                   this,
+                                   &TestNrSocketTest::RecvDataTcp_s,
+                                   accepted_sock),
+                   NS_DISPATCH_SYNC);
+    if (r) {
+      std::cerr << "RecvDataTcp_s (1) failed" << std::endl;
+      return false;
+    }
+
+    if (!WaitForWriteable(accepted_sock)) {
+      std::cerr << __LINE__ << "WaitForWriteable (2) failed" << std::endl;
+      return false;
+    }
+
+    sts_->Dispatch(WrapRunnableRet(&r,
+                                   this,
+                                   &TestNrSocketTest::SendDataTcp_s,
+                                   accepted_sock),
+                   NS_DISPATCH_SYNC);
+    if (r) {
+      std::cerr << "SendDataTcp_s (2) failed" << std::endl;
+      return false;
+    }
+
+    if (!WaitForReadable(from)) {
+      std::cerr << __LINE__ << "WaitForReadable (2) failed" << std::endl;
+      return false;
+    }
+
+    sts_->Dispatch(WrapRunnableRet(&r,
+                                   this,
+                                   &TestNrSocketTest::RecvDataTcp_s,
+                                   from),
+                   NS_DISPATCH_SYNC);
+    if (r) {
+      std::cerr << "RecvDataTcp_s (2) failed" << std::endl;
+      return false;
+    }
+
+    return true;
+  }
+
+  int GetAddress(TestNrSocket *sock, nr_transport_addr_ *address) {
+    MOZ_ASSERT(sock);
+    MOZ_ASSERT(address);
+    int r;
+    sts_->Dispatch(WrapRunnableRet(&r,
+                                   this,
+                                   &TestNrSocketTest::GetAddress_s,
+                                   sock,
+                                   address),
+                   NS_DISPATCH_SYNC);
+    return r;
+  }
+
+  int GetAddress_s(TestNrSocket *sock, nr_transport_addr *address) {
+    return sock->getaddr(address);
+  }
+
+  int SendData_s(TestNrSocket *from, const nr_transport_addr &to) {
+    // It is up to caller to ensure that |from| is writeable.
+    const char buf[] = "foobajooba";
+    return from->sendto(buf, sizeof(buf), 0,
+        // TODO(bug 1170299): Remove const_cast when no longer necessary
+        const_cast<nr_transport_addr*>(&to));
+  }
+
+  int SendDataTcp_s(NrSocketBase *from) {
+    // It is up to caller to ensure that |from| is writeable.
+    const char buf[] = "foobajooba";
+    size_t written;
+    return from->write(buf, sizeof(buf), &written);
+  }
+
+  int RecvData_s(TestNrSocket *to, nr_transport_addr *from) {
+    // It is up to caller to ensure that |to| is readable
+    char buf[DATA_BUF_SIZE];
+    size_t len;
+    // Maybe check that data matches?
+    int r = to->recvfrom(buf, sizeof(buf), &len, 0, from);
+    if (!r && (len == 0)) {
+      r = R_INTERNAL;
+    }
+    return r;
+  }
+
+  int RecvDataTcp_s(NrSocketBase *to) {
+    // It is up to caller to ensure that |to| is readable
+    char buf[DATA_BUF_SIZE];
+    size_t len;
+    // Maybe check that data matches?
+    int r = to->read(buf, sizeof(buf), &len);
+    if (!r && (len == 0)) {
+      r = R_INTERNAL;
+    }
+    return r;
+  }
+
+  int Listen_s(TestNrSocket *to) {
+    // listen on |to|
+    int r = to->listen(1);
+    if (r) {
+      return r;
+    }
+    return 0;
+  }
+
+  int Connect_s(TestNrSocket *from, TestNrSocket *to) {
+    // connect on |from|
+    nr_transport_addr destination_address;
+    int r = to->getaddr(&destination_address);
+    if (r) {
+      return r;
+    }
+
+    r = from->connect(&destination_address);
+    if (r) {
+      return r;
+    }
+
+    return 0;
+  }
+
+  int Accept_s(TestNrSocket *to, NrSocketBase **accepted_sock) {
+    nr_socket *sock;
+    nr_transport_addr source_address;
+    int r = to->accept(&source_address, &sock);
+    if (r) {
+      return r;
+    }
+
+    *accepted_sock = reinterpret_cast<NrSocketBase*>(sock->obj);
+    return 0;
+  }
+
+  bool Connect(TestNrSocket *from,
+               TestNrSocket *to,
+               NrSocketBase **accepted_sock) {
+    int r;
+    sts_->Dispatch(WrapRunnableRet(&r,
+                                   this,
+                                   &TestNrSocketTest::Listen_s,
+                                   to),
+                   NS_DISPATCH_SYNC);
+    if (r) {
+      std::cerr << "Listen_s failed: " << r << std::endl;
+      return false;
+    }
+
+    sts_->Dispatch(WrapRunnableRet(&r,
+                                   this,
+                                   &TestNrSocketTest::Connect_s,
+                                   from,
+                                   to),
+                   NS_DISPATCH_SYNC);
+    if (r && r != R_WOULDBLOCK) {
+      std::cerr << "Connect_s failed: " << r << std::endl;
+      return false;
+    }
+
+    if (!WaitForReadable(to)) {
+      std::cerr << "WaitForReadable failed" << std::endl;
+      return false;
+    }
+
+    sts_->Dispatch(WrapRunnableRet(&r,
+                                   this,
+                                   &TestNrSocketTest::Accept_s,
+                                   to,
+                                   accepted_sock),
+                   NS_DISPATCH_SYNC);
+
+    if (r) {
+      std::cerr << "Accept_s failed: " << r << std::endl;
+      return false;
+    }
+    return true;
+  }
+
+
+  bool WaitForSocketState(NrSocketBase *sock, int state) {
+    MOZ_ASSERT(sock);
+    sts_->Dispatch(WrapRunnable(this,
+                                &TestNrSocketTest::WaitForSocketState_s,
+                                sock,
+                                state),
+                   NS_DISPATCH_SYNC);
+
+    bool res;
+    WAIT_(wait_done_for_main_, 500, res);
+    wait_done_for_main_ = false;
+
+    if (!res) {
+      sts_->Dispatch(WrapRunnable(this,
+                                  &TestNrSocketTest::CancelWait_s,
+                                  sock,
+                                  state),
+                     NS_DISPATCH_SYNC);
+    }
+
+    return res;
+  }
+
+  void WaitForSocketState_s(NrSocketBase *sock, int state) {
+     NR_ASYNC_WAIT(sock, state, &WaitDone, this);
+  }
+
+  void CancelWait_s(NrSocketBase *sock, int state) {
+     sock->cancel(state);
+  }
+
+  bool WaitForReadable(NrSocketBase *sock) {
+    return WaitForSocketState(sock, NR_ASYNC_WAIT_READ);
+  }
+
+  bool WaitForWriteable(NrSocketBase *sock) {
+    return WaitForSocketState(sock, NR_ASYNC_WAIT_WRITE);
+  }
+
+  static void WaitDone(void *sock, int how, void *test_fixture) {
+    TestNrSocketTest *test = static_cast<TestNrSocketTest*>(test_fixture);
+    test->wait_done_for_main_ = true;
+  }
+
+  // Simple busywait boolean for the test cases to spin on.
+  Atomic<bool> wait_done_for_main_;
+
+  nsCOMPtr<nsIEventTarget> sts_;
+  std::vector<RefPtr<TestNrSocket>> public_addrs_;
+  std::vector<RefPtr<TestNrSocket>> private_addrs_;
+  std::vector<RefPtr<TestNat>> nats_;
+};
+
+} // namespace mozilla
+
+using mozilla::TestNrSocketTest;
+using mozilla::TestNat;
+
+TEST_F(TestNrSocketTest, PublicConnectivity) {
+  CreatePublicAddrs(2);
+
+  ASSERT_TRUE(CheckConnectivity(public_addrs_[0], public_addrs_[1]));
+  ASSERT_TRUE(CheckConnectivity(public_addrs_[1], public_addrs_[0]));
+  ASSERT_TRUE(CheckConnectivity(public_addrs_[0], public_addrs_[0]));
+  ASSERT_TRUE(CheckConnectivity(public_addrs_[1], public_addrs_[1]));
+}
+
+TEST_F(TestNrSocketTest, PrivateConnectivity) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(2));
+  nat->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0], private_addrs_[1]));
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[1], private_addrs_[0]));
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0], private_addrs_[0]));
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[1], private_addrs_[1]));
+}
+
+TEST_F(TestNrSocketTest, NoConnectivityWithoutPinhole) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(1));
+  nat->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  CreatePublicAddrs(1);
+
+  ASSERT_FALSE(CheckConnectivity(public_addrs_[0], private_addrs_[0]));
+}
+
+TEST_F(TestNrSocketTest, NoConnectivityBetweenSubnets) {
+  RefPtr<TestNat> nat1(CreatePrivateAddrs(1));
+  nat1->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat1->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  RefPtr<TestNat> nat2(CreatePrivateAddrs(1));
+  nat2->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat2->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+
+  ASSERT_FALSE(CheckConnectivity(private_addrs_[0], private_addrs_[1]));
+  ASSERT_FALSE(CheckConnectivity(private_addrs_[1], private_addrs_[0]));
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0], private_addrs_[0]));
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[1], private_addrs_[1]));
+}
+
+TEST_F(TestNrSocketTest, FullConeAcceptIngress) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(1));
+  nat->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  CreatePublicAddrs(2);
+
+  nr_transport_addr sender_external_address;
+  // Open pinhole to public IP 0
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[0],
+                                &sender_external_address));
+
+  // Verify that return traffic works
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[0],
+                                   private_addrs_[0],
+                                   sender_external_address));
+
+  // Verify that other public IP can use the pinhole
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[1],
+                                   private_addrs_[0],
+                                   sender_external_address));
+}
+
+TEST_F(TestNrSocketTest, FullConeOnePinhole) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(1));
+  nat->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  CreatePublicAddrs(2);
+
+  nr_transport_addr sender_external_address;
+  // Open pinhole to public IP 0
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[0],
+                                &sender_external_address));
+
+  // Verify that return traffic works
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[0],
+                                   private_addrs_[0],
+                                   sender_external_address));
+
+  // Send traffic to other public IP, verify that it uses the same pinhole
+  nr_transport_addr sender_external_address2;
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[1],
+                                &sender_external_address2));
+  ASSERT_FALSE(nr_transport_addr_cmp(&sender_external_address,
+                                     &sender_external_address2,
+                                     NR_TRANSPORT_ADDR_CMP_MODE_ALL))
+    << "addr1: " << sender_external_address.as_string << " addr2: "
+    << sender_external_address2.as_string;
+}
+
+// OS 10.6 doesn't seem to allow us to open ports on 127.0.0.2, and while linux
+// does allow this, it has other behavior (see below) that prevents this test
+// from working.
+TEST_F(TestNrSocketTest, DISABLED_AddressRestrictedCone) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(1));
+  nat->filtering_type_ = TestNat::ADDRESS_DEPENDENT;
+  nat->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  CreatePublicAddrs(2, "127.0.0.1");
+  CreatePublicAddrs(1, "127.0.0.2");
+
+  nr_transport_addr sender_external_address;
+  // Open pinhole to public IP 0
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[0],
+                                &sender_external_address));
+
+  // Verify that return traffic works
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[0],
+                                   private_addrs_[0],
+                                   sender_external_address));
+
+  // Verify that another address on the same host can use the pinhole
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[1],
+                                   private_addrs_[0],
+                                   sender_external_address));
+
+  // Linux has a tendency to monkey around with source addresses, doing
+  // stuff like substituting 127.0.0.1 for packets sent by 127.0.0.2, and even
+  // going as far as substituting localhost for a packet sent from a real IP
+  // address when the destination is localhost. The only way to make this test
+  // work on linux is to have two real IP addresses.
+#ifndef __linux__
+  // Verify that an address on a different host can't use the pinhole
+  ASSERT_FALSE(CheckConnectivityVia(public_addrs_[2],
+                                   private_addrs_[0],
+                                   sender_external_address));
+#endif
+
+  // Send traffic to other public IP, verify that it uses the same pinhole
+  nr_transport_addr sender_external_address2;
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[1],
+                                &sender_external_address2));
+  ASSERT_FALSE(nr_transport_addr_cmp(&sender_external_address,
+                                     &sender_external_address2,
+                                     NR_TRANSPORT_ADDR_CMP_MODE_ALL))
+    << "addr1: " << sender_external_address.as_string << " addr2: "
+    << sender_external_address2.as_string;
+
+  // Verify that the other public IP can now use the pinhole
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[1],
+                                   private_addrs_[0],
+                                   sender_external_address2));
+
+  // Send traffic to other public IP, verify that it uses the same pinhole
+  nr_transport_addr sender_external_address3;
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[2],
+                                &sender_external_address3));
+  ASSERT_FALSE(nr_transport_addr_cmp(&sender_external_address,
+                                     &sender_external_address3,
+                                     NR_TRANSPORT_ADDR_CMP_MODE_ALL))
+    << "addr1: " << sender_external_address.as_string << " addr2: "
+    << sender_external_address3.as_string;
+
+  // Verify that the other public IP can now use the pinhole
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[2],
+                                   private_addrs_[0],
+                                   sender_external_address3));
+}
+
+TEST_F(TestNrSocketTest, RestrictedCone) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(1));
+  nat->filtering_type_ = TestNat::PORT_DEPENDENT;
+  nat->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  CreatePublicAddrs(2);
+
+  nr_transport_addr sender_external_address;
+  // Open pinhole to public IP 0
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[0],
+                                &sender_external_address));
+
+  // Verify that return traffic works
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[0],
+                                   private_addrs_[0],
+                                   sender_external_address));
+
+  // Verify that other public IP cannot use the pinhole
+  ASSERT_FALSE(CheckConnectivityVia(public_addrs_[1],
+                                    private_addrs_[0],
+                                    sender_external_address));
+
+  // Send traffic to other public IP, verify that it uses the same pinhole
+  nr_transport_addr sender_external_address2;
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[1],
+                                &sender_external_address2));
+  ASSERT_FALSE(nr_transport_addr_cmp(&sender_external_address,
+                                     &sender_external_address2,
+                                     NR_TRANSPORT_ADDR_CMP_MODE_ALL))
+    << "addr1: " << sender_external_address.as_string << " addr2: "
+    << sender_external_address2.as_string;
+
+  // Verify that the other public IP can now use the pinhole
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[1],
+                                   private_addrs_[0],
+                                   sender_external_address2));
+}
+
+TEST_F(TestNrSocketTest, PortDependentMappingFullCone) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(1));
+  nat->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_type_ = TestNat::PORT_DEPENDENT;
+  CreatePublicAddrs(2);
+
+  nr_transport_addr sender_external_address0;
+  // Open pinhole to public IP 0
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[0],
+                                &sender_external_address0));
+
+  // Verify that return traffic works
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[0],
+                                   private_addrs_[0],
+                                   sender_external_address0));
+
+  // Verify that other public IP can use the pinhole
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[1],
+                                   private_addrs_[0],
+                                   sender_external_address0));
+
+  // Send traffic to other public IP, verify that it uses a different pinhole
+  nr_transport_addr sender_external_address1;
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[1],
+                                &sender_external_address1));
+  ASSERT_TRUE(nr_transport_addr_cmp(&sender_external_address0,
+                                    &sender_external_address1,
+                                    NR_TRANSPORT_ADDR_CMP_MODE_ALL))
+    << "addr1: " << sender_external_address0.as_string << " addr2: "
+    << sender_external_address1.as_string;
+
+  // Verify that return traffic works
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[1],
+                                   private_addrs_[0],
+                                   sender_external_address1));
+
+  // Verify that other public IP can use the original pinhole
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[0],
+                                   private_addrs_[0],
+                                   sender_external_address1));
+}
+
+TEST_F(TestNrSocketTest, Symmetric) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(1));
+  nat->filtering_type_ = TestNat::PORT_DEPENDENT;
+  nat->mapping_type_ = TestNat::PORT_DEPENDENT;
+  CreatePublicAddrs(2);
+
+  nr_transport_addr sender_external_address;
+  // Open pinhole to public IP 0
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[0],
+                                &sender_external_address));
+
+  // Verify that return traffic works
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[0],
+                                   private_addrs_[0],
+                                   sender_external_address));
+
+  // Verify that other public IP cannot use the pinhole
+  ASSERT_FALSE(CheckConnectivityVia(public_addrs_[1],
+                                    private_addrs_[0],
+                                    sender_external_address));
+
+  // Send traffic to other public IP, verify that it uses a new pinhole
+  nr_transport_addr sender_external_address2;
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[1],
+                                &sender_external_address2));
+  ASSERT_TRUE(nr_transport_addr_cmp(&sender_external_address,
+                                    &sender_external_address2,
+                                    NR_TRANSPORT_ADDR_CMP_MODE_ALL));
+
+  // Verify that the other public IP can use the new pinhole
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[1],
+                                   private_addrs_[0],
+                                   sender_external_address2));
+}
+
+TEST_F(TestNrSocketTest, BlockUdp) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(2));
+  nat->block_udp_ = true;
+  CreatePublicAddrs(1);
+
+  nr_transport_addr sender_external_address;
+  ASSERT_FALSE(CheckConnectivity(private_addrs_[0],
+                                 public_addrs_[0],
+                                 &sender_external_address));
+
+  // Make sure UDP behind the NAT still works
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                private_addrs_[1]));
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[1],
+                                private_addrs_[0]));
+}
+
+TEST_F(TestNrSocketTest, DenyHairpinning) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(2));
+  nat->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  CreatePublicAddrs(1);
+
+  nr_transport_addr sender_external_address;
+  // Open pinhole to public IP 0
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[0],
+                                &sender_external_address));
+
+  // Verify that hairpinning is disallowed
+  ASSERT_FALSE(CheckConnectivityVia(private_addrs_[1],
+                                    private_addrs_[0],
+                                    sender_external_address));
+}
+
+TEST_F(TestNrSocketTest, AllowHairpinning) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(2));
+  nat->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_timeout_ = 30000;
+  nat->allow_hairpinning_ = true;
+  CreatePublicAddrs(1);
+
+  nr_transport_addr sender_external_address;
+  // Open pinhole to public IP 0, obtain external address
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[0],
+                                &sender_external_address));
+
+  // Verify that hairpinning is allowed
+  ASSERT_TRUE(CheckConnectivityVia(private_addrs_[1],
+                                   private_addrs_[0],
+                                   sender_external_address));
+}
+
+TEST_F(TestNrSocketTest, FullConeTimeout) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(1));
+  nat->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_timeout_ = 200;
+  CreatePublicAddrs(2);
+
+  nr_transport_addr sender_external_address;
+  // Open pinhole to public IP 0
+  ASSERT_TRUE(CheckConnectivity(private_addrs_[0],
+                                public_addrs_[0],
+                                &sender_external_address));
+
+  // Verify that return traffic works
+  ASSERT_TRUE(CheckConnectivityVia(public_addrs_[0],
+                                   private_addrs_[0],
+                                   sender_external_address));
+
+  PR_Sleep(201);
+
+  // Verify that return traffic does not work
+  ASSERT_FALSE(CheckConnectivityVia(public_addrs_[0],
+                                    private_addrs_[0],
+                                    sender_external_address));
+}
+
+TEST_F(TestNrSocketTest, PublicConnectivityTcp)
+{
+  CreatePublicAddrs(2, "127.0.0.1", IPPROTO_TCP);
+
+  ASSERT_TRUE(CheckTcpConnectivity(public_addrs_[0], public_addrs_[1]));
+}
+
+TEST_F(TestNrSocketTest, PrivateConnectivityTcp) {
+  RefPtr<TestNat> nat(CreatePrivateAddrs(2, "127.0.0.1", IPPROTO_TCP));
+  nat->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+
+  ASSERT_TRUE(CheckTcpConnectivity(private_addrs_[0], private_addrs_[1]));
+}
+
+TEST_F(TestNrSocketTest, PrivateToPublicConnectivityTcp)
+{
+  RefPtr<TestNat> nat(CreatePrivateAddrs(1, "127.0.0.1", IPPROTO_TCP));
+  nat->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  CreatePublicAddrs(1, "127.0.0.1", IPPROTO_TCP);
+
+  ASSERT_TRUE(CheckTcpConnectivity(private_addrs_[0], public_addrs_[0]));
+}
+
+TEST_F(TestNrSocketTest, NoConnectivityBetweenSubnetsTcp)
+{
+  RefPtr<TestNat> nat1(CreatePrivateAddrs(1, "127.0.0.1", IPPROTO_TCP));
+  nat1->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat1->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  RefPtr<TestNat> nat2(CreatePrivateAddrs(1, "127.0.0.1", IPPROTO_TCP));
+  nat2->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat2->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+
+  ASSERT_FALSE(CheckTcpConnectivity(private_addrs_[0], private_addrs_[1]));
+}
+
+TEST_F(TestNrSocketTest, NoConnectivityPublicToPrivateTcp)
+{
+  RefPtr<TestNat> nat(CreatePrivateAddrs(1, "127.0.0.1", IPPROTO_TCP));
+  nat->filtering_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  nat->mapping_type_ = TestNat::ENDPOINT_INDEPENDENT;
+  CreatePublicAddrs(1, "127.0.0.1", IPPROTO_TCP);
+
+  ASSERT_FALSE(CheckTcpConnectivity(public_addrs_[0], private_addrs_[0]));
+}
diff --git a/media/mtransport/test/transport_unittests.cpp b/media/mtransport/test/transport_unittests.cpp
new file mode 100644
index 000000000..b0be39f06
--- /dev/null
+++ b/media/mtransport/test/transport_unittests.cpp
@@ -0,0 +1,1344 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: ekr@rtfm.com
+
+#include <iostream>
+#include <string>
+#include <map>
+#include <algorithm>
+
+#include "mozilla/UniquePtr.h"
+
+#include "sigslot.h"
+
+#include "logging.h"
+#include "nspr.h"
+#include "nss.h"
+#include "ssl.h"
+#include "sslproto.h"
+
+#include "nsThreadUtils.h"
+#include "nsXPCOM.h"
+
+#include "databuffer.h"
+#include "dtlsidentity.h"
+#include "nricectxhandler.h"
+#include "nricemediastream.h"
+#include "transportflow.h"
+#include "transportlayer.h"
+#include "transportlayerdtls.h"
+#include "transportlayerice.h"
+#include "transportlayerlog.h"
+#include "transportlayerloopback.h"
+
+#include "runnable_utils.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+using namespace mozilla;
+MOZ_MTLOG_MODULE("mtransport")
+
+
+const uint8_t kTlsChangeCipherSpecType = 0x14;
+const uint8_t kTlsHandshakeType =        0x16;
+
+const uint8_t kTlsHandshakeCertificate = 0x0b;
+const uint8_t kTlsHandshakeServerKeyExchange = 0x0c;
+
+const uint8_t kTlsFakeChangeCipherSpec[] = {
+  kTlsChangeCipherSpecType,  // Type
+  0xfe, 0xff, // Version
+  0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x10, // Fictitious sequence #
+  0x00, 0x01, // Length
+  0x01 // Value
+};
+
+// Layer class which can't be initialized.
+class TransportLayerDummy : public TransportLayer {
+ public:
+  TransportLayerDummy(bool allow_init, bool *destroyed)
+      : allow_init_(allow_init),
+        destroyed_(destroyed) {
+    *destroyed_ = false;
+  }
+
+  virtual ~TransportLayerDummy() {
+    *destroyed_ = true;
+  }
+
+  virtual nsresult InitInternal() {
+    return allow_init_ ? NS_OK : NS_ERROR_FAILURE;
+  }
+
+  virtual TransportResult SendPacket(const unsigned char *data, size_t len) {
+    MOZ_CRASH();  // Should never be called.
+    return 0;
+  }
+
+  TRANSPORT_LAYER_ID("lossy")
+
+ private:
+  bool allow_init_;
+  bool *destroyed_;
+};
+
+class Inspector {
+ public:
+  virtual ~Inspector() {}
+
+  virtual void Inspect(TransportLayer* layer,
+                       const unsigned char *data, size_t len) = 0;
+};
+
+// Class to simulate various kinds of network lossage
+class TransportLayerLossy : public TransportLayer {
+ public:
+  TransportLayerLossy() : loss_mask_(0), packet_(0), inspector_(nullptr) {}
+  ~TransportLayerLossy () {}
+
+  virtual TransportResult SendPacket(const unsigned char *data, size_t len) {
+    MOZ_MTLOG(ML_NOTICE, LAYER_INFO << "SendPacket(" << len << ")");
+
+    if (loss_mask_ & (1 << (packet_ % 32))) {
+      MOZ_MTLOG(ML_NOTICE, "Dropping packet");
+      ++packet_;
+      return len;
+    }
+    if (inspector_) {
+      inspector_->Inspect(this, data, len);
+    }
+
+    ++packet_;
+
+    return downward_->SendPacket(data, len);
+  }
+
+  void SetLoss(uint32_t packet) {
+    loss_mask_ |= (1 << (packet & 32));
+  }
+
+  void SetInspector(UniquePtr<Inspector> inspector) {
+    inspector_ = Move(inspector);
+  }
+
+  void StateChange(TransportLayer *layer, State state) {
+    TL_SET_STATE(state);
+  }
+
+  void PacketReceived(TransportLayer *layer, const unsigned char *data,
+                      size_t len) {
+    SignalPacketReceived(this, data, len);
+  }
+
+  TRANSPORT_LAYER_ID("lossy")
+
+ protected:
+  virtual void WasInserted() {
+    downward_->SignalPacketReceived.
+        connect(this,
+                &TransportLayerLossy::PacketReceived);
+    downward_->SignalStateChange.
+        connect(this,
+                &TransportLayerLossy::StateChange);
+
+    TL_SET_STATE(downward_->state());
+  }
+
+ private:
+  uint32_t loss_mask_;
+  uint32_t packet_;
+  UniquePtr<Inspector> inspector_;
+};
+
+// Process DTLS Records
+#define CHECK_LENGTH(expected) \
+  do { \
+    EXPECT_GE(remaining(), expected); \
+    if (remaining() < expected) return false; \
+  } while(0)
+
+class TlsParser {
+ public:
+  TlsParser(const unsigned char *data, size_t len)
+      : buffer_(data, len), offset_(0) {}
+
+  bool Read(unsigned char* val) {
+    if (remaining() < 1) {
+      return false;
+    }
+    *val = *ptr();
+    consume(1);
+    return true;
+  }
+
+  // Read an integral type of specified width.
+  bool Read(uint32_t *val, size_t len) {
+    if (len > sizeof(uint32_t))
+      return false;
+
+    *val = 0;
+
+    for (size_t i=0; i<len; ++i) {
+      unsigned char tmp;
+
+      if (!Read(&tmp))
+        return false;
+
+      (*val) = ((*val) << 8) + tmp;
+    }
+
+    return true;
+  }
+
+  bool Read(unsigned char* val, size_t len) {
+    if (remaining() < len) {
+      return false;
+    }
+
+    if (val) {
+      memcpy(val, ptr(), len);
+    }
+    consume(len);
+
+    return true;
+  }
+
+ private:
+  size_t remaining() const { return buffer_.len() - offset_; }
+  const uint8_t *ptr() const { return buffer_.data() + offset_; }
+  void consume(size_t len) { offset_ += len; }
+
+  DataBuffer buffer_;
+  size_t offset_;
+};
+
+class DtlsRecordParser {
+ public:
+  DtlsRecordParser(const unsigned char *data, size_t len)
+      : buffer_(data, len), offset_(0) {}
+
+  bool NextRecord(uint8_t* ct, nsAutoPtr<DataBuffer>* buffer) {
+    if (!remaining())
+      return false;
+
+    CHECK_LENGTH(13U);
+    const uint8_t *ctp = reinterpret_cast<const uint8_t *>(ptr());
+    consume(11); // ct + version + length
+
+    const uint16_t *tmp = reinterpret_cast<const uint16_t*>(ptr());
+    size_t length = ntohs(*tmp);
+    consume(2);
+
+    CHECK_LENGTH(length);
+    DataBuffer* db = new DataBuffer(ptr(), length);
+    consume(length);
+
+    *ct = *ctp;
+    *buffer = db;
+
+    return true;
+  }
+
+ private:
+  size_t remaining() const { return buffer_.len() - offset_; }
+  const uint8_t *ptr() const { return buffer_.data() + offset_; }
+  void consume(size_t len) { offset_ += len; }
+
+  DataBuffer buffer_;
+  size_t offset_;
+};
+
+
+// Inspector that parses out DTLS records and passes
+// them on.
+class DtlsRecordInspector : public Inspector {
+ public:
+  virtual void Inspect(TransportLayer* layer,
+                       const unsigned char *data, size_t len) {
+    DtlsRecordParser parser(data, len);
+
+    uint8_t ct;
+    nsAutoPtr<DataBuffer> buf;
+    while(parser.NextRecord(&ct, &buf)) {
+      OnRecord(layer, ct, buf->data(), buf->len());
+    }
+  }
+
+  virtual void OnRecord(TransportLayer* layer,
+                        uint8_t content_type,
+                        const unsigned char *record,
+                        size_t len) = 0;
+};
+
+// Inspector that injects arbitrary packets based on
+// DTLS records of various types.
+class DtlsInspectorInjector : public DtlsRecordInspector {
+ public:
+  DtlsInspectorInjector(uint8_t packet_type, uint8_t handshake_type,
+                    const unsigned char *data, size_t len) :
+      packet_type_(packet_type),
+      handshake_type_(handshake_type),
+      injected_(false) {
+    data_.reset(new unsigned char[len]);
+    memcpy(data_.get(), data, len);
+    len_ = len;
+  }
+
+  virtual void OnRecord(TransportLayer* layer,
+                        uint8_t content_type,
+                        const unsigned char *data, size_t len) {
+    // Only inject once.
+    if (injected_) {
+      return;
+    }
+
+    // Check that the first byte is as requested.
+    if (content_type != packet_type_) {
+      return;
+    }
+
+    if (handshake_type_ != 0xff) {
+      // Check that the packet is plausibly long enough.
+      if (len < 1) {
+        return;
+      }
+
+      // Check that the handshake type is as requested.
+      if (data[0] != handshake_type_) {
+        return;
+      }
+    }
+
+    layer->SendPacket(data_.get(), len_);
+  }
+
+ private:
+  uint8_t packet_type_;
+  uint8_t handshake_type_;
+  bool injected_;
+  UniquePtr<unsigned char[]> data_;
+  size_t len_;
+};
+
+// Make a copy of the first instance of a message.
+class DtlsInspectorRecordHandshakeMessage : public DtlsRecordInspector {
+ public:
+  explicit DtlsInspectorRecordHandshakeMessage(uint8_t handshake_type)
+      : handshake_type_(handshake_type),
+        buffer_() {}
+
+  virtual void OnRecord(TransportLayer* layer,
+                        uint8_t content_type,
+                        const unsigned char *data, size_t len) {
+    // Only do this once.
+    if (buffer_.len()) {
+      return;
+    }
+
+    // Check that the first byte is as requested.
+    if (content_type != kTlsHandshakeType) {
+      return;
+    }
+
+    TlsParser parser(data, len);
+    unsigned char message_type;
+    // Read the handshake message type.
+    if (!parser.Read(&message_type)) {
+      return;
+    }
+    if (message_type != handshake_type_) {
+      return;
+    }
+
+    uint32_t length;
+    if (!parser.Read(&length, 3)) {
+      return;
+    }
+
+    uint32_t message_seq;
+    if (!parser.Read(&message_seq, 2)) {
+      return;
+    }
+
+    uint32_t fragment_offset;
+    if (!parser.Read(&fragment_offset, 3)) {
+      return;
+    }
+
+    uint32_t fragment_length;
+    if (!parser.Read(&fragment_length, 3)) {
+      return;
+    }
+
+    if ((fragment_offset != 0) || (fragment_length != length)) {
+      // This shouldn't happen because all current tests where we
+      // are using this code don't fragment.
+      return;
+    }
+
+    buffer_.Allocate(length);
+    if (!parser.Read(buffer_.data(), length)) {
+      return;
+    }
+  }
+
+  const DataBuffer& buffer() { return buffer_; }
+
+ private:
+  uint8_t handshake_type_;
+  DataBuffer buffer_;
+};
+
+class TlsServerKeyExchangeECDHE {
+ public:
+  bool Parse(const unsigned char* data, size_t len) {
+    TlsParser parser(data, len);
+
+    uint8_t curve_type;
+    if (!parser.Read(&curve_type)) {
+      return false;
+    }
+
+    if (curve_type != 3) {  // named_curve
+      return false;
+    }
+
+    uint32_t named_curve;
+    if (!parser.Read(&named_curve, 2)) {
+      return false;
+    }
+
+    uint32_t point_length;
+    if (!parser.Read(&point_length, 1)) {
+      return false;
+    }
+
+    public_key_.Allocate(point_length);
+    if (!parser.Read(public_key_.data(), point_length)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  DataBuffer public_key_;
+};
+
+namespace {
+class TransportTestPeer : public sigslot::has_slots<> {
+ public:
+  TransportTestPeer(nsCOMPtr<nsIEventTarget> target, std::string name, MtransportTestUtils* utils)
+      : name_(name), target_(target),
+        received_packets_(0),received_bytes_(0),flow_(new TransportFlow(name)),
+        loopback_(new TransportLayerLoopback()),
+        logging_(new TransportLayerLogging()),
+        lossy_(new TransportLayerLossy()),
+        dtls_(new TransportLayerDtls()),
+        identity_(DtlsIdentity::Generate()),
+        ice_ctx_(NrIceCtxHandler::Create(name,
+                                         name == "P2" ?
+                                         TransportLayerDtls::CLIENT :
+                                         TransportLayerDtls::SERVER)),
+        streams_(), candidates_(),
+        peer_(nullptr),
+        gathering_complete_(false),
+        enabled_cipersuites_(),
+        disabled_cipersuites_(),
+        reuse_dhe_key_(false),
+        test_utils_(utils) {
+    std::vector<NrIceStunServer> stun_servers;
+    UniquePtr<NrIceStunServer> server(NrIceStunServer::Create(
+        std::string((char *)"stun.services.mozilla.com"), 3478));
+    stun_servers.push_back(*server);
+    EXPECT_TRUE(NS_SUCCEEDED(ice_ctx_->ctx()->SetStunServers(stun_servers)));
+
+    dtls_->SetIdentity(identity_);
+    dtls_->SetRole(name == "P2" ?
+                   TransportLayerDtls::CLIENT :
+                   TransportLayerDtls::SERVER);
+
+    nsresult res = identity_->ComputeFingerprint("sha-1",
+                                             fingerprint_,
+                                             sizeof(fingerprint_),
+                                             &fingerprint_len_);
+    EXPECT_TRUE(NS_SUCCEEDED(res));
+    EXPECT_EQ(20u, fingerprint_len_);
+  }
+
+  ~TransportTestPeer() {
+    test_utils_->sts_target()->Dispatch(
+      WrapRunnable(this, &TransportTestPeer::DestroyFlow),
+      NS_DISPATCH_SYNC);
+  }
+
+
+  void DestroyFlow() {
+    if (flow_) {
+      loopback_->Disconnect();
+      flow_ = nullptr;
+    }
+    ice_ctx_ = nullptr;
+  }
+
+  void DisconnectDestroyFlow() {
+    loopback_->Disconnect();
+    disconnect_all();  // Disconnect from the signals;
+     flow_ = nullptr;
+  }
+
+  void SetDtlsAllowAll() {
+    nsresult res = dtls_->SetVerificationAllowAll();
+    ASSERT_TRUE(NS_SUCCEEDED(res));
+  }
+
+  void SetAlpn(std::string str, bool withDefault, std::string extra = "") {
+    std::set<std::string> alpn;
+    alpn.insert(str); // the one we want to select
+    if (!extra.empty()) {
+      alpn.insert(extra);
+    }
+    nsresult res = dtls_->SetAlpn(alpn, withDefault ? str : "");
+    ASSERT_EQ(NS_OK, res);
+  }
+
+  const std::string& GetAlpn() const {
+    return dtls_->GetNegotiatedAlpn();
+  }
+
+  void SetDtlsPeer(TransportTestPeer *peer, int digests, unsigned int damage) {
+    unsigned int mask = 1;
+
+    for (int i=0; i<digests; i++) {
+      unsigned char fingerprint_to_set[TransportLayerDtls::kMaxDigestLength];
+
+      memcpy(fingerprint_to_set,
+             peer->fingerprint_,
+             peer->fingerprint_len_);
+      if (damage & mask)
+        fingerprint_to_set[0]++;
+
+      nsresult res = dtls_->SetVerificationDigest(
+          "sha-1",
+          fingerprint_to_set,
+          peer->fingerprint_len_);
+
+      ASSERT_TRUE(NS_SUCCEEDED(res));
+
+      mask <<= 1;
+    }
+  }
+
+  void SetupSrtp() {
+    // this mimics the setup we do elsewhere
+    std::vector<uint16_t> srtp_ciphers;
+    srtp_ciphers.push_back(SRTP_AES128_CM_HMAC_SHA1_80);
+    srtp_ciphers.push_back(SRTP_AES128_CM_HMAC_SHA1_32);
+
+    SetSrtpCiphers(srtp_ciphers);
+ }
+
+  void SetSrtpCiphers(std::vector<uint16_t>& srtp_ciphers) {
+    ASSERT_TRUE(NS_SUCCEEDED(dtls_->SetSrtpCiphers(srtp_ciphers)));
+  }
+
+  void ConnectSocket_s(TransportTestPeer *peer) {
+    nsresult res;
+    res = loopback_->Init();
+    ASSERT_EQ((nsresult)NS_OK, res);
+
+    loopback_->Connect(peer->loopback_);
+
+    ASSERT_EQ((nsresult)NS_OK, flow_->PushLayer(loopback_));
+    ASSERT_EQ((nsresult)NS_OK, flow_->PushLayer(logging_));
+    ASSERT_EQ((nsresult)NS_OK, flow_->PushLayer(lossy_));
+    ASSERT_EQ((nsresult)NS_OK, flow_->PushLayer(dtls_));
+
+    if (dtls_->state() != TransportLayer::TS_ERROR) {
+      // Don't execute these blocks if DTLS didn't initialize.
+      TweakCiphers(dtls_->internal_fd());
+      if (reuse_dhe_key_) {
+        // TransportLayerDtls automatically sets this pref to false
+        // so set it back for test.
+        // This is pretty gross. Dig directly into the NSS FD. The problem
+        // is that we are testing a feature which TransaportLayerDtls doesn't
+        // expose.
+        SECStatus rv = SSL_OptionSet(dtls_->internal_fd(),
+                                     SSL_REUSE_SERVER_ECDHE_KEY, PR_TRUE);
+        ASSERT_EQ(SECSuccess, rv);
+      }
+    }
+
+    flow_->SignalPacketReceived.connect(this, &TransportTestPeer::PacketReceived);
+  }
+
+  void TweakCiphers(PRFileDesc* fd) {
+    for (auto it = enabled_cipersuites_.begin();
+         it != enabled_cipersuites_.end(); ++it) {
+      SSL_CipherPrefSet(fd, *it, PR_TRUE);
+    }
+    for (auto it = disabled_cipersuites_.begin();
+         it != disabled_cipersuites_.end(); ++it) {
+      SSL_CipherPrefSet(fd, *it, PR_FALSE);
+    }
+  }
+
+  void ConnectSocket(TransportTestPeer *peer) {
+    RUN_ON_THREAD(test_utils_->sts_target(),
+                  WrapRunnable(this, & TransportTestPeer::ConnectSocket_s,
+                               peer),
+                  NS_DISPATCH_SYNC);
+  }
+
+  void InitIce() {
+    nsresult res;
+
+    // Attach our slots
+    ice_ctx_->ctx()->SignalGatheringStateChange.
+        connect(this, &TransportTestPeer::GatheringStateChange);
+
+    char name[100];
+    snprintf(name, sizeof(name), "%s:stream%d", name_.c_str(),
+             (int)streams_.size());
+
+    // Create the media stream
+    RefPtr<NrIceMediaStream> stream =
+        ice_ctx_->CreateStream(static_cast<char *>(name), 1);
+
+    ASSERT_TRUE(stream != nullptr);
+    ice_ctx_->ctx()->SetStream(streams_.size(), stream);
+    streams_.push_back(stream);
+
+    // Listen for candidates
+    stream->SignalCandidate.
+        connect(this, &TransportTestPeer::GotCandidate);
+
+    // Create the transport layer
+    ice_ = new TransportLayerIce(name);
+    ice_->SetParameters(ice_ctx_->ctx(), stream, 1);
+
+    // Assemble the stack
+    nsAutoPtr<std::queue<mozilla::TransportLayer *> > layers(
+      new std::queue<mozilla::TransportLayer *>);
+    layers->push(ice_);
+    layers->push(dtls_);
+
+    test_utils_->sts_target()->Dispatch(
+      WrapRunnableRet(&res, flow_, &TransportFlow::PushLayers, layers),
+      NS_DISPATCH_SYNC);
+
+    ASSERT_EQ((nsresult)NS_OK, res);
+
+    // Listen for media events
+    flow_->SignalPacketReceived.connect(this, &TransportTestPeer::PacketReceived);
+    flow_->SignalStateChange.connect(this, &TransportTestPeer::StateChanged);
+
+    // Start gathering
+    test_utils_->sts_target()->Dispatch(
+        WrapRunnableRet(&res,
+                        ice_ctx_->ctx(),
+                        &NrIceCtx::StartGathering,
+                        false,
+                        false),
+        NS_DISPATCH_SYNC);
+    ASSERT_TRUE(NS_SUCCEEDED(res));
+  }
+
+  void ConnectIce(TransportTestPeer *peer) {
+    peer_ = peer;
+
+    // If gathering is already complete, push the candidates over
+    if (gathering_complete_)
+      GatheringComplete();
+  }
+
+  // New candidate
+  void GotCandidate(NrIceMediaStream *stream, const std::string &candidate) {
+    std::cerr << "Got candidate " << candidate << std::endl;
+    candidates_[stream->name()].push_back(candidate);
+  }
+
+  void GatheringStateChange(NrIceCtx* ctx,
+                            NrIceCtx::GatheringState state) {
+    (void)ctx;
+    if (state == NrIceCtx::ICE_CTX_GATHER_COMPLETE) {
+      GatheringComplete();
+    }
+  }
+
+  // Gathering complete, so send our candidates and start
+  // connecting on the other peer.
+  void GatheringComplete() {
+    nsresult res;
+
+    // Don't send to the other side
+    if (!peer_) {
+      gathering_complete_ = true;
+      return;
+    }
+
+    // First send attributes
+    test_utils_->sts_target()->Dispatch(
+      WrapRunnableRet(&res, peer_->ice_ctx_->ctx(),
+                      &NrIceCtx::ParseGlobalAttributes,
+                      ice_ctx_->ctx()->GetGlobalAttributes()),
+      NS_DISPATCH_SYNC);
+    ASSERT_TRUE(NS_SUCCEEDED(res));
+
+    for (size_t i=0; i<streams_.size(); ++i) {
+      test_utils_->sts_target()->Dispatch(
+        WrapRunnableRet(&res, peer_->streams_[i], &NrIceMediaStream::ParseAttributes,
+                        candidates_[streams_[i]->name()]), NS_DISPATCH_SYNC);
+
+      ASSERT_TRUE(NS_SUCCEEDED(res));
+    }
+
+    // Start checks on the other peer.
+    test_utils_->sts_target()->Dispatch(
+      WrapRunnableRet(&res, peer_->ice_ctx_->ctx(), &NrIceCtx::StartChecks),
+      NS_DISPATCH_SYNC);
+    ASSERT_TRUE(NS_SUCCEEDED(res));
+  }
+
+  TransportResult SendPacket(const unsigned char* data, size_t len) {
+    TransportResult ret;
+    test_utils_->sts_target()->Dispatch(
+      WrapRunnableRet(&ret, flow_, &TransportFlow::SendPacket, data, len),
+      NS_DISPATCH_SYNC);
+
+    return ret;
+  }
+
+
+  void StateChanged(TransportFlow *flow, TransportLayer::State state) {
+    if (state == TransportLayer::TS_OPEN) {
+      std::cerr << "Now connected" << std::endl;
+    }
+  }
+
+  void PacketReceived(TransportFlow * flow, const unsigned char* data,
+                      size_t len) {
+    std::cerr << "Received " << len << " bytes" << std::endl;
+    ++received_packets_;
+    received_bytes_ += len;
+  }
+
+  void SetLoss(uint32_t loss) {
+    lossy_->SetLoss(loss);
+  }
+
+  void SetCombinePackets(bool combine) {
+    loopback_->CombinePackets(combine);
+  }
+
+  void SetInspector(UniquePtr<Inspector> inspector) {
+    lossy_->SetInspector(Move(inspector));
+  }
+
+  void SetInspector(Inspector* in) {
+    UniquePtr<Inspector> inspector(in);
+
+    lossy_->SetInspector(Move(inspector));
+  }
+
+  void SetCipherSuiteChanges(const std::vector<uint16_t>& enableThese,
+                             const std::vector<uint16_t>& disableThese) {
+    disabled_cipersuites_ = disableThese;
+    enabled_cipersuites_ = enableThese;
+  }
+
+  void SetReuseECDHEKey() {
+    reuse_dhe_key_ = true;
+  }
+
+  TransportLayer::State state() {
+    TransportLayer::State tstate;
+
+    RUN_ON_THREAD(test_utils_->sts_target(),
+                  WrapRunnableRet(&tstate, flow_, &TransportFlow::state));
+
+    return tstate;
+  }
+
+  bool connected() {
+    return state() == TransportLayer::TS_OPEN;
+  }
+
+  bool failed() {
+    return state() == TransportLayer::TS_ERROR;
+  }
+
+  size_t receivedPackets() { return received_packets_; }
+
+  size_t receivedBytes() { return received_bytes_; }
+
+  uint16_t cipherSuite() const {
+    nsresult rv;
+    uint16_t cipher;
+    RUN_ON_THREAD(test_utils_->sts_target(),
+                  WrapRunnableRet(&rv, dtls_, &TransportLayerDtls::GetCipherSuite,
+                                  &cipher));
+
+    if (NS_FAILED(rv)) {
+      return TLS_NULL_WITH_NULL_NULL; // i.e., not good
+    }
+    return cipher;
+  }
+
+  uint16_t srtpCipher() const {
+    nsresult rv;
+    uint16_t cipher;
+    RUN_ON_THREAD(test_utils_->sts_target(),
+                  WrapRunnableRet(&rv, dtls_, &TransportLayerDtls::GetSrtpCipher,
+                                  &cipher));
+    if (NS_FAILED(rv)) {
+      return 0; // the SRTP equivalent of TLS_NULL_WITH_NULL_NULL
+    }
+    return cipher;
+  }
+
+ private:
+  std::string name_;
+  nsCOMPtr<nsIEventTarget> target_;
+  size_t received_packets_;
+  size_t received_bytes_;
+    RefPtr<TransportFlow> flow_;
+  TransportLayerLoopback *loopback_;
+  TransportLayerLogging *logging_;
+  TransportLayerLossy *lossy_;
+  TransportLayerDtls *dtls_;
+  TransportLayerIce *ice_;
+  RefPtr<DtlsIdentity> identity_;
+  RefPtr<NrIceCtxHandler> ice_ctx_;
+  std::vector<RefPtr<NrIceMediaStream> > streams_;
+  std::map<std::string, std::vector<std::string> > candidates_;
+  TransportTestPeer *peer_;
+  bool gathering_complete_;
+  unsigned char fingerprint_[TransportLayerDtls::kMaxDigestLength];
+  size_t fingerprint_len_;
+  std::vector<uint16_t> enabled_cipersuites_;
+  std::vector<uint16_t> disabled_cipersuites_;
+  bool reuse_dhe_key_;
+  MtransportTestUtils* test_utils_;
+};
+
+
+class TransportTest : public MtransportTest {
+ public:
+  TransportTest() {
+    fds_[0] = nullptr;
+    fds_[1] = nullptr;
+  }
+
+  void TearDown() override {
+    delete p1_;
+    delete p2_;
+
+    //    Can't detach these
+    //    PR_Close(fds_[0]);
+    //    PR_Close(fds_[1]);
+    MtransportTest::TearDown();
+  }
+
+  void DestroyPeerFlows() {
+    p1_->DisconnectDestroyFlow();
+    p2_->DisconnectDestroyFlow();
+  }
+
+  void SetUp() override {
+    MtransportTest::SetUp();
+
+    nsresult rv;
+    target_ = do_GetService(NS_SOCKETTRANSPORTSERVICE_CONTRACTID, &rv);
+    ASSERT_TRUE(NS_SUCCEEDED(rv));
+
+    Reset();
+  }
+
+  void Reset() {
+    p1_ = new TransportTestPeer(target_, "P1", test_utils_);
+    p2_ = new TransportTestPeer(target_, "P2", test_utils_);
+  }
+
+  void SetupSrtp() {
+    p1_->SetupSrtp();
+    p2_->SetupSrtp();
+  }
+
+  void SetDtlsPeer(int digests = 1, unsigned int damage = 0) {
+    p1_->SetDtlsPeer(p2_, digests, damage);
+    p2_->SetDtlsPeer(p1_, digests, damage);
+  }
+
+  void SetDtlsAllowAll() {
+    p1_->SetDtlsAllowAll();
+    p2_->SetDtlsAllowAll();
+  }
+
+  void SetAlpn(std::string first, std::string second,
+               bool withDefaults = true) {
+    if (!first.empty()) {
+      p1_->SetAlpn(first, withDefaults, "bogus");
+    }
+    if (!second.empty()) {
+      p2_->SetAlpn(second, withDefaults);
+    }
+  }
+
+  void CheckAlpn(std::string first, std::string second) {
+    ASSERT_EQ(first, p1_->GetAlpn());
+    ASSERT_EQ(second, p2_->GetAlpn());
+  }
+
+  void ConnectSocket() {
+    ConnectSocketInternal();
+    ASSERT_TRUE_WAIT(p1_->connected(), 10000);
+    ASSERT_TRUE_WAIT(p2_->connected(), 10000);
+
+    ASSERT_EQ(p1_->cipherSuite(), p2_->cipherSuite());
+    ASSERT_EQ(p1_->srtpCipher(), p2_->srtpCipher());
+  }
+
+  void ConnectSocketExpectFail() {
+    ConnectSocketInternal();
+    ASSERT_TRUE_WAIT(p1_->failed(), 10000);
+    ASSERT_TRUE_WAIT(p2_->failed(), 10000);
+  }
+
+  void ConnectSocketExpectState(TransportLayer::State s1,
+                                TransportLayer::State s2) {
+    ConnectSocketInternal();
+    ASSERT_EQ_WAIT(s1, p1_->state(), 10000);
+    ASSERT_EQ_WAIT(s2, p2_->state(), 10000);
+  }
+
+  void InitIce() {
+    p1_->InitIce();
+    p2_->InitIce();
+  }
+
+  void ConnectIce() {
+    p1_->InitIce();
+    p2_->InitIce();
+    p1_->ConnectIce(p2_);
+    p2_->ConnectIce(p1_);
+    ASSERT_TRUE_WAIT(p1_->connected(), 10000);
+    ASSERT_TRUE_WAIT(p2_->connected(), 10000);
+  }
+
+  void TransferTest(size_t count, size_t bytes = 1024) {
+    unsigned char buf[bytes];
+
+    for (size_t i= 0; i<count; ++i) {
+      memset(buf, count & 0xff, sizeof(buf));
+      TransportResult rv = p1_->SendPacket(buf, sizeof(buf));
+      ASSERT_TRUE(rv > 0);
+    }
+
+    std::cerr << "Received == " << p2_->receivedPackets() << " packets" << std::endl;
+    ASSERT_TRUE_WAIT(count == p2_->receivedPackets(), 10000);
+    ASSERT_TRUE((count * sizeof(buf)) == p2_->receivedBytes());
+  }
+
+ protected:
+  void ConnectSocketInternal() {
+    test_utils_->sts_target()->Dispatch(
+      WrapRunnable(p1_, &TransportTestPeer::ConnectSocket, p2_),
+      NS_DISPATCH_SYNC);
+    test_utils_->sts_target()->Dispatch(
+      WrapRunnable(p2_, &TransportTestPeer::ConnectSocket, p1_),
+      NS_DISPATCH_SYNC);
+  }
+
+  PRFileDesc *fds_[2];
+  TransportTestPeer *p1_;
+  TransportTestPeer *p2_;
+  nsCOMPtr<nsIEventTarget> target_;
+};
+
+
+TEST_F(TransportTest, TestNoDtlsVerificationSettings) {
+  ConnectSocketExpectFail();
+}
+
+static void DisableChaCha(TransportTestPeer* peer) {
+  // On ARM, ChaCha20Poly1305 might be preferred; disable it for the tests that
+  // want to check the cipher suite.  It doesn't matter which peer disables the
+  // suite, disabling on either side has the same effect.
+  std::vector<uint16_t> chachaSuites;
+  chachaSuites.push_back(TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305_SHA256);
+  chachaSuites.push_back(TLS_ECDHE_RSA_WITH_CHACHA20_POLY1305_SHA256);
+  peer->SetCipherSuiteChanges(std::vector<uint16_t>(), chachaSuites);
+}
+
+TEST_F(TransportTest, TestConnect) {
+  SetDtlsPeer();
+  DisableChaCha(p1_);
+  ConnectSocket();
+
+  // check that we got the right suite
+  ASSERT_EQ(TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, p1_->cipherSuite());
+
+  // no SRTP on this one
+  ASSERT_EQ(0, p1_->srtpCipher());
+}
+
+TEST_F(TransportTest, TestConnectSrtp) {
+  SetupSrtp();
+  SetDtlsPeer();
+  DisableChaCha(p2_);
+  ConnectSocket();
+
+  ASSERT_EQ(TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, p1_->cipherSuite());
+
+  // SRTP is on
+  ASSERT_EQ(SRTP_AES128_CM_HMAC_SHA1_80, p1_->srtpCipher());
+}
+
+
+TEST_F(TransportTest, TestConnectDestroyFlowsMainThread) {
+  SetDtlsPeer();
+  ConnectSocket();
+  DestroyPeerFlows();
+}
+
+TEST_F(TransportTest, TestConnectAllowAll) {
+  SetDtlsAllowAll();
+  ConnectSocket();
+}
+
+TEST_F(TransportTest, TestConnectAlpn) {
+  SetDtlsPeer();
+  SetAlpn("a", "a");
+  ConnectSocket();
+  CheckAlpn("a", "a");
+}
+
+TEST_F(TransportTest, TestConnectAlpnMismatch) {
+  SetDtlsPeer();
+  SetAlpn("something", "different");
+  ConnectSocketExpectFail();
+}
+
+TEST_F(TransportTest, TestConnectAlpnServerDefault) {
+  SetDtlsPeer();
+  SetAlpn("def", "");
+  // server allows default, client doesn't support
+  ConnectSocket();
+  CheckAlpn("def", "");
+}
+
+TEST_F(TransportTest, TestConnectAlpnClientDefault) {
+  SetDtlsPeer();
+  SetAlpn("", "clientdef");
+  // client allows default, but server will ignore the extension
+  ConnectSocket();
+  CheckAlpn("", "clientdef");
+}
+
+TEST_F(TransportTest, TestConnectClientNoAlpn) {
+  SetDtlsPeer();
+  // Here the server has ALPN, but no default is allowed.
+  // Reminder: p1 == server, p2 == client
+  SetAlpn("server-nodefault", "", false);
+  // The server doesn't see the extension, so negotiates without it.
+  // But then the server is forced to close when it discovers that ALPN wasn't
+  // negotiated; the client sees a close.
+  ConnectSocketExpectState(TransportLayer::TS_ERROR,
+                           TransportLayer::TS_CLOSED);
+}
+
+TEST_F(TransportTest, TestConnectServerNoAlpn) {
+  SetDtlsPeer();
+  SetAlpn("", "client-nodefault", false);
+  // The client aborts; the server doesn't realize this is a problem and just
+  // sees the close.
+  ConnectSocketExpectState(TransportLayer::TS_CLOSED,
+                           TransportLayer::TS_ERROR);
+}
+
+TEST_F(TransportTest, TestConnectNoDigest) {
+  SetDtlsPeer(0, 0);
+
+  ConnectSocketExpectFail();
+}
+
+TEST_F(TransportTest, TestConnectBadDigest) {
+  SetDtlsPeer(1, 1);
+
+  ConnectSocketExpectFail();
+}
+
+TEST_F(TransportTest, TestConnectTwoDigests) {
+  SetDtlsPeer(2, 0);
+
+  ConnectSocket();
+}
+
+TEST_F(TransportTest, TestConnectTwoDigestsFirstBad) {
+  SetDtlsPeer(2, 1);
+
+  ConnectSocket();
+}
+
+TEST_F(TransportTest, TestConnectTwoDigestsSecondBad) {
+  SetDtlsPeer(2, 2);
+
+  ConnectSocket();
+}
+
+TEST_F(TransportTest, TestConnectTwoDigestsBothBad) {
+  SetDtlsPeer(2, 3);
+
+  ConnectSocketExpectFail();
+}
+
+TEST_F(TransportTest, TestConnectInjectCCS) {
+  SetDtlsPeer();
+  p2_->SetInspector(MakeUnique<DtlsInspectorInjector>(
+      kTlsHandshakeType,
+      kTlsHandshakeCertificate,
+      kTlsFakeChangeCipherSpec,
+      sizeof(kTlsFakeChangeCipherSpec)));
+
+  ConnectSocket();
+}
+
+
+TEST_F(TransportTest, TestConnectVerifyNewECDHE) {
+  SetDtlsPeer();
+  DtlsInspectorRecordHandshakeMessage *i1 = new
+    DtlsInspectorRecordHandshakeMessage(kTlsHandshakeServerKeyExchange);
+  p1_->SetInspector(i1);
+  ConnectSocket();
+  TlsServerKeyExchangeECDHE dhe1;
+  ASSERT_TRUE(dhe1.Parse(i1->buffer().data(), i1->buffer().len()));
+
+  Reset();
+  SetDtlsPeer();
+  DtlsInspectorRecordHandshakeMessage *i2 = new
+    DtlsInspectorRecordHandshakeMessage(kTlsHandshakeServerKeyExchange);
+  p1_->SetInspector(i2);
+  ConnectSocket();
+  TlsServerKeyExchangeECDHE dhe2;
+  ASSERT_TRUE(dhe2.Parse(i2->buffer().data(), i2->buffer().len()));
+
+  // Now compare these two to see if they are the same.
+  ASSERT_FALSE((dhe1.public_key_.len() == dhe2.public_key_.len()) &&
+               (!memcmp(dhe1.public_key_.data(), dhe2.public_key_.data(),
+                        dhe1.public_key_.len())));
+}
+
+TEST_F(TransportTest, TestConnectVerifyReusedECDHE) {
+  SetDtlsPeer();
+  DtlsInspectorRecordHandshakeMessage *i1 = new
+    DtlsInspectorRecordHandshakeMessage(kTlsHandshakeServerKeyExchange);
+  p1_->SetInspector(i1);
+  p1_->SetReuseECDHEKey();
+  ConnectSocket();
+  TlsServerKeyExchangeECDHE dhe1;
+  ASSERT_TRUE(dhe1.Parse(i1->buffer().data(), i1->buffer().len()));
+
+  Reset();
+  SetDtlsPeer();
+  DtlsInspectorRecordHandshakeMessage *i2 = new
+    DtlsInspectorRecordHandshakeMessage(kTlsHandshakeServerKeyExchange);
+
+  p1_->SetInspector(i2);
+  p1_->SetReuseECDHEKey();
+
+  ConnectSocket();
+  TlsServerKeyExchangeECDHE dhe2;
+  ASSERT_TRUE(dhe2.Parse(i2->buffer().data(), i2->buffer().len()));
+
+  // Now compare these two to see if they are the same.
+  ASSERT_EQ(dhe1.public_key_.len(), dhe2.public_key_.len());
+  ASSERT_TRUE(!memcmp(dhe1.public_key_.data(), dhe2.public_key_.data(),
+                      dhe1.public_key_.len()));
+}
+
+TEST_F(TransportTest, TestTransfer) {
+  SetDtlsPeer();
+  ConnectSocket();
+  TransferTest(1);
+}
+
+TEST_F(TransportTest, TestTransferMaxSize) {
+  SetDtlsPeer();
+  ConnectSocket();
+  /* transportlayerdtls uses a 9216 bytes buffer - as this test uses the
+   * loopback implementation it does not have to take into account the extra
+   * bytes added by the DTLS layer below. */
+  TransferTest(1, 9216);
+}
+
+TEST_F(TransportTest, TestTransferMultiple) {
+  SetDtlsPeer();
+  ConnectSocket();
+  TransferTest(3);
+}
+
+TEST_F(TransportTest, TestTransferCombinedPackets) {
+  SetDtlsPeer();
+  ConnectSocket();
+  p2_->SetCombinePackets(true);
+  TransferTest(3);
+}
+
+TEST_F(TransportTest, TestConnectLoseFirst) {
+  SetDtlsPeer();
+  p1_->SetLoss(0);
+  ConnectSocket();
+  TransferTest(1);
+}
+
+TEST_F(TransportTest, TestConnectIce) {
+  SetDtlsPeer();
+  ConnectIce();
+}
+
+TEST_F(TransportTest, TestTransferIceMaxSize) {
+  SetDtlsPeer();
+  ConnectIce();
+  /* nICEr and transportlayerdtls both use 9216 bytes buffers. But the DTLS
+   * layer add extra bytes to the packet, which size depends on chosen cipher
+   * etc. Sending more then 9216 bytes works, but on the receiving side the call
+   * to PR_recvfrom() will truncate any packet bigger then nICEr's buffer size
+   * of 9216 bytes, which then results in the DTLS layer discarding the packet.
+   * Therefore we leave some headroom (according to
+   * https://bugzilla.mozilla.org/show_bug.cgi?id=1214269#c29 256 bytes should
+   * be save choice) here for the DTLS bytes to make it safely into the
+   * receiving buffer in nICEr. */
+  TransferTest(1, 8960);
+}
+
+TEST_F(TransportTest, TestTransferIceMultiple) {
+  SetDtlsPeer();
+  ConnectIce();
+  TransferTest(3);
+}
+
+TEST_F(TransportTest, TestTransferIceCombinedPackets) {
+  SetDtlsPeer();
+  ConnectIce();
+  p2_->SetCombinePackets(true);
+  TransferTest(3);
+}
+
+// test the default configuration against a peer that supports only
+// one of the mandatory-to-implement suites, which should succeed
+static void ConfigureOneCipher(TransportTestPeer* peer, uint16_t suite) {
+  std::vector<uint16_t> justOne;
+  justOne.push_back(suite);
+  std::vector<uint16_t> everythingElse(SSL_GetImplementedCiphers(),
+                                       SSL_GetImplementedCiphers()
+                                       + SSL_GetNumImplementedCiphers());
+  std::remove(everythingElse.begin(), everythingElse.end(), suite);
+  peer->SetCipherSuiteChanges(justOne, everythingElse);
+}
+
+TEST_F(TransportTest, TestCipherMismatch) {
+  SetDtlsPeer();
+  ConfigureOneCipher(p1_, TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256);
+  ConfigureOneCipher(p2_, TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA);
+  ConnectSocketExpectFail();
+}
+
+TEST_F(TransportTest, TestCipherMandatoryOnlyGcm) {
+  SetDtlsPeer();
+  ConfigureOneCipher(p1_, TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256);
+  ConnectSocket();
+  ASSERT_EQ(TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256, p1_->cipherSuite());
+}
+
+TEST_F(TransportTest, TestCipherMandatoryOnlyCbc) {
+  SetDtlsPeer();
+  ConfigureOneCipher(p1_, TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA);
+  ConnectSocket();
+  ASSERT_EQ(TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA, p1_->cipherSuite());
+}
+
+TEST_F(TransportTest, TestSrtpMismatch) {
+  std::vector<uint16_t> setA;
+  setA.push_back(SRTP_AES128_CM_HMAC_SHA1_80);
+  std::vector<uint16_t> setB;
+  setB.push_back(SRTP_AES128_CM_HMAC_SHA1_32);
+
+  p1_->SetSrtpCiphers(setA);
+  p2_->SetSrtpCiphers(setB);
+  SetDtlsPeer();
+  ConnectSocket();
+
+  ASSERT_EQ(0, p1_->srtpCipher());
+  ASSERT_EQ(0, p2_->srtpCipher());
+}
+
+// NSS doesn't support DHE suites on the server end.
+// This checks to see if we barf when that's the only option available.
+TEST_F(TransportTest, TestDheOnlyFails) {
+  SetDtlsPeer();
+
+  // p2_ is the client
+  // setting this on p1_ (the server) causes NSS to assert
+  ConfigureOneCipher(p2_, TLS_DHE_RSA_WITH_AES_128_CBC_SHA);
+  ConnectSocketExpectFail();
+}
+
+TEST(PushTests, LayerFail) {
+  RefPtr<TransportFlow> flow = new TransportFlow();
+  nsresult rv;
+  bool destroyed1, destroyed2;
+
+  rv = flow->PushLayer(new TransportLayerDummy(true, &destroyed1));
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+
+  rv = flow->PushLayer(new TransportLayerDummy(false, &destroyed2));
+  ASSERT_TRUE(NS_FAILED(rv));
+
+  ASSERT_EQ(TransportLayer::TS_ERROR, flow->state());
+  ASSERT_EQ(true, destroyed1);
+  ASSERT_EQ(true, destroyed2);
+
+  rv = flow->PushLayer(new TransportLayerDummy(true, &destroyed1));
+  ASSERT_TRUE(NS_FAILED(rv));
+  ASSERT_EQ(true, destroyed1);
+}
+
+TEST(PushTests, LayersFail) {
+  RefPtr<TransportFlow> flow = new TransportFlow();
+  nsresult rv;
+  bool destroyed1, destroyed2, destroyed3;
+
+  rv = flow->PushLayer(new TransportLayerDummy(true, &destroyed1));
+  ASSERT_TRUE(NS_SUCCEEDED(rv));
+
+  nsAutoPtr<std::queue<TransportLayer *> > layers(
+      new std::queue<TransportLayer *>());
+
+  layers->push(new TransportLayerDummy(true, &destroyed2));
+  layers->push(new TransportLayerDummy(false, &destroyed3));
+
+  rv = flow->PushLayers(layers);
+  ASSERT_TRUE(NS_FAILED(rv));
+
+  ASSERT_EQ(TransportLayer::TS_ERROR, flow->state());
+  ASSERT_EQ(true, destroyed1);
+  ASSERT_EQ(true, destroyed2);
+  ASSERT_EQ(true, destroyed3);
+
+  layers = new std::queue<TransportLayer *>();
+  layers->push(new TransportLayerDummy(true, &destroyed2));
+  layers->push(new TransportLayerDummy(true, &destroyed3));
+  rv = flow->PushLayers(layers);
+
+  ASSERT_TRUE(NS_FAILED(rv));
+  ASSERT_EQ(true, destroyed2);
+  ASSERT_EQ(true, destroyed3);
+}
+
+}  // end namespace
diff --git a/media/mtransport/test/turn_unittest.cpp b/media/mtransport/test/turn_unittest.cpp
new file mode 100644
index 000000000..19fe8515c
--- /dev/null
+++ b/media/mtransport/test/turn_unittest.cpp
@@ -0,0 +1,487 @@
+/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- */
+/* vim: set ts=2 et sw=2 tw=80: */
+/* This Source Code Form is subject to the terms of the Mozilla Public
+ * License, v. 2.0. If a copy of the MPL was not distributed with this file,
+ * You can obtain one at http://mozilla.org/MPL/2.0/. */
+
+// Original author: ekr@rtfm.com
+
+// Some code copied from nICEr. License is:
+/*
+Copyright (c) 2007, Adobe Systems, Incorporated
+All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above copyright
+  notice, this list of conditions and the following disclaimer in the
+  documentation and/or other materials provided with the distribution.
+
+* Neither the name of Adobe Systems, Network Resonance nor the names of its
+  contributors may be used to endorse or promote products derived from
+  this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+*/
+
+#include <stdlib.h>
+#include <iostream>
+
+#include "sigslot.h"
+
+#include "logging.h"
+#include "nspr.h"
+#include "nss.h"
+#include "ssl.h"
+
+#include "nsThreadUtils.h"
+#include "nsXPCOM.h"
+
+#include "runnable_utils.h"
+
+#define GTEST_HAS_RTTI 0
+#include "gtest/gtest.h"
+#include "gtest_utils.h"
+
+#define USE_TURN
+
+// nICEr includes
+extern "C" {
+#include "nr_api.h"
+#include "registry.h"
+#include "async_timer.h"
+#include "r_crc32.h"
+#include "ice_util.h"
+#include "transport_addr.h"
+#include "nr_crypto.h"
+#include "nr_socket.h"
+#include "nr_socket_local.h"
+#include "nr_socket_buffered_stun.h"
+#include "stun_client_ctx.h"
+#include "turn_client_ctx.h"
+}
+
+#include "nricemediastream.h"
+#include "nricectxhandler.h"
+
+
+using namespace mozilla;
+
+static std::string kDummyTurnServer("192.0.2.1");  // From RFC 5737
+
+class TurnClient : public MtransportTest {
+ public:
+  TurnClient()
+      : MtransportTest(),
+        real_socket_(nullptr),
+        net_socket_(nullptr),
+        buffered_socket_(nullptr),
+        net_fd_(nullptr),
+        turn_ctx_(nullptr),
+        allocated_(false),
+        received_(0),
+        protocol_(IPPROTO_UDP) {
+  }
+
+  ~TurnClient() {
+  }
+
+  static void SetUpTestCase() {
+    NrIceCtx::InitializeGlobals(false, false, false);
+  }
+
+  void SetTcp() {
+    protocol_ = IPPROTO_TCP;
+  }
+
+  void Init_s() {
+    int r;
+    nr_transport_addr addr;
+    r = nr_ip4_port_to_transport_addr(0, 0, protocol_, &addr);
+    ASSERT_EQ(0, r);
+
+    r = nr_socket_local_create(nullptr, &addr, &real_socket_);
+    ASSERT_EQ(0, r);
+
+    if (protocol_ == IPPROTO_TCP) {
+      int r =
+          nr_socket_buffered_stun_create(real_socket_, 100000, TURN_TCP_FRAMING,
+                                         &buffered_socket_);
+      ASSERT_EQ(0, r);
+      net_socket_ = buffered_socket_;
+    } else {
+      net_socket_ = real_socket_;
+    }
+
+    r = nr_str_port_to_transport_addr(turn_server_.c_str(), 3478,
+      protocol_, &addr);
+    ASSERT_EQ(0, r);
+
+    std::vector<unsigned char> password_vec(
+        turn_password_.begin(), turn_password_.end());
+    Data password;
+    INIT_DATA(password, &password_vec[0], password_vec.size());
+    r = nr_turn_client_ctx_create("test", net_socket_,
+                                  turn_user_.c_str(),
+                                  &password,
+                                  &addr, &turn_ctx_);
+    ASSERT_EQ(0, r);
+
+    r = nr_socket_getfd(net_socket_, &net_fd_);
+    ASSERT_EQ(0, r);
+
+    NR_ASYNC_WAIT(net_fd_, NR_ASYNC_WAIT_READ, socket_readable_cb,
+        (void *)this);
+  }
+
+  void TearDown_s() {
+    nr_turn_client_ctx_destroy(&turn_ctx_);
+    if (net_fd_) {
+      NR_ASYNC_CANCEL(net_fd_, NR_ASYNC_WAIT_READ);
+    }
+
+    nr_socket_destroy(&buffered_socket_);
+  }
+
+  void TearDown() {
+    RUN_ON_THREAD(test_utils_->sts_target(),
+                  WrapRunnable(this, &TurnClient::TearDown_s),
+                  NS_DISPATCH_SYNC);
+  }
+
+  void Allocate_s() {
+    Init_s();
+    ASSERT_TRUE(turn_ctx_);
+
+    int r = nr_turn_client_allocate(turn_ctx_,
+                                    allocate_success_cb,
+                                    this);
+    ASSERT_EQ(0, r);
+  }
+
+  void Allocate(bool expect_success=true) {
+    RUN_ON_THREAD(test_utils_->sts_target(),
+                  WrapRunnable(this, &TurnClient::Allocate_s),
+                  NS_DISPATCH_SYNC);
+
+    if (expect_success) {
+      ASSERT_TRUE_WAIT(allocated_, 5000);
+    }
+    else {
+      PR_Sleep(10000);
+      ASSERT_FALSE(allocated_);
+    }
+  }
+
+  void Allocated() {
+    if (turn_ctx_->state!=NR_TURN_CLIENT_STATE_ALLOCATED) {
+      std::cerr << "Allocation failed" << std::endl;
+      return;
+    }
+    allocated_ = true;
+
+    int r;
+    nr_transport_addr addr;
+
+    r = nr_turn_client_get_relayed_address(turn_ctx_, &addr);
+    ASSERT_EQ(0, r);
+
+    relay_addr_ = addr.as_string;
+
+    std::cerr << "Allocation succeeded with addr=" << relay_addr_ << std::endl;
+  }
+
+  void Deallocate_s() {
+    ASSERT_TRUE(turn_ctx_);
+
+    std::cerr << "De-Allocating..." << std::endl;
+    int r = nr_turn_client_deallocate(turn_ctx_);
+    ASSERT_EQ(0, r);
+  }
+
+  void Deallocate() {
+    RUN_ON_THREAD(test_utils_->sts_target(),
+                  WrapRunnable(this, &TurnClient::Deallocate_s),
+                  NS_DISPATCH_SYNC);
+  }
+
+  void RequestPermission_s(const std::string& target) {
+    nr_transport_addr addr;
+    int r;
+
+    // Expected pattern here is "IP4:127.0.0.1:3487"
+    ASSERT_EQ(0, target.compare(0, 4, "IP4:"));
+
+    size_t offset = target.rfind(':');
+    ASSERT_NE(std::string::npos, offset);
+
+    std::string host = target.substr(4, offset - 4);
+    std::string port = target.substr(offset + 1);
+
+    r = nr_str_port_to_transport_addr(host.c_str(),
+                                      atoi(port.c_str()),
+                                      IPPROTO_UDP,
+                                      &addr);
+    ASSERT_EQ(0, r);
+
+    r = nr_turn_client_ensure_perm(turn_ctx_, &addr);
+    ASSERT_EQ(0, r);
+  }
+
+  void RequestPermission(const std::string& target) {
+    RUN_ON_THREAD(test_utils_->sts_target(),
+                  WrapRunnable(this, &TurnClient::RequestPermission_s, target),
+                  NS_DISPATCH_SYNC);
+
+  }
+
+  void Readable(NR_SOCKET s, int how, void *arg) {
+    // Re-arm
+    std::cerr << "Socket is readable" << std::endl;
+    NR_ASYNC_WAIT(s, how, socket_readable_cb, arg);
+
+    UCHAR buf[8192];
+    size_t len_s;
+    nr_transport_addr addr;
+
+    int r = nr_socket_recvfrom(net_socket_, buf, sizeof(buf), &len_s, 0, &addr);
+    if (r) {
+      std::cerr << "Error reading from socket" << std::endl;
+      return;
+    }
+
+    ASSERT_LT(len_s, (size_t)INT_MAX);
+    int len = (int)len_s;
+
+    if (nr_is_stun_response_message(buf, len)) {
+      std::cerr << "STUN response" << std::endl;
+      r = nr_turn_client_process_response(turn_ctx_, buf, len, &addr);
+
+      if (r && r != R_REJECTED && r != R_RETRY) {
+        std::cerr << "Error processing STUN: " << r << std::endl;
+      }
+    } else if (nr_is_stun_indication_message(buf, len)) {
+      std::cerr << "STUN indication" << std::endl;
+
+      /* Process the indication */
+      unsigned char data[NR_STUN_MAX_MESSAGE_SIZE];
+      size_t datal;
+      nr_transport_addr remote_addr;
+
+      r = nr_turn_client_parse_data_indication(turn_ctx_, &addr,
+                                               buf, len,
+                                               data, &datal, sizeof(data),
+                                               &remote_addr);
+      ASSERT_EQ(0, r);
+      std::cerr << "Received " << datal << " bytes from "
+                << remote_addr.as_string << std::endl;
+
+      received_ += datal;
+
+      for (size_t i=0; i < datal; i++) {
+        ASSERT_EQ(i & 0xff, data[i]);
+      }
+    }
+    else {
+      if (nr_is_stun_message(buf, len)) {
+        std::cerr << "STUN message of unexpected type" << std::endl;
+      } else {
+        std::cerr << "Not a STUN message" << std::endl;
+      }
+      return;
+    }
+  }
+
+  void SendTo_s(const std::string& target, int expect_return) {
+    nr_transport_addr addr;
+    int r;
+
+    // Expected pattern here is "IP4:127.0.0.1:3487"
+    ASSERT_EQ(0, target.compare(0, 4, "IP4:"));
+
+    size_t offset = target.rfind(':');
+    ASSERT_NE(std::string::npos, offset);
+
+    std::string host = target.substr(4, offset - 4);
+    std::string port = target.substr(offset + 1);
+
+    r = nr_str_port_to_transport_addr(host.c_str(),
+                                      atoi(port.c_str()),
+                                      IPPROTO_UDP,
+                                      &addr);
+    ASSERT_EQ(0, r);
+
+    unsigned char test[100];
+    for (size_t i=0; i<sizeof(test); i++) {
+      test[i] = i & 0xff;
+    }
+
+    std::cerr << "Sending test message to " << target << " ..." << std::endl;
+
+    r = nr_turn_client_send_indication(turn_ctx_,
+                                            test, sizeof(test), 0,
+                                            &addr);
+    if (expect_return >= 0) {
+      ASSERT_EQ(expect_return, r);
+    }
+  }
+
+  void SendTo(const std::string& target, int expect_return=0) {
+    RUN_ON_THREAD(test_utils_->sts_target(),
+                  WrapRunnable(this, &TurnClient::SendTo_s, target,
+                               expect_return),
+                  NS_DISPATCH_SYNC);
+  }
+
+  int received() const { return received_; }
+
+  static void socket_readable_cb(NR_SOCKET s, int how, void *arg) {
+    static_cast<TurnClient *>(arg)->Readable(s, how, arg);
+  }
+
+  static void allocate_success_cb(NR_SOCKET s, int how, void *arg){
+    static_cast<TurnClient *>(arg)->Allocated();
+  }
+
+ protected:
+  std::string turn_server_;
+  nr_socket *real_socket_;
+  nr_socket *net_socket_;
+  nr_socket *buffered_socket_;
+  NR_SOCKET net_fd_;
+  nr_turn_client_ctx *turn_ctx_;
+  std::string relay_addr_;
+  bool allocated_;
+  int received_;
+  int protocol_;
+};
+
+TEST_F(TurnClient, Allocate) {
+  if (WarnIfTurnNotConfigured())
+    return;
+
+  Allocate();
+}
+
+TEST_F(TurnClient, AllocateTcp) {
+  if (WarnIfTurnNotConfigured())
+    return;
+
+  SetTcp();
+  Allocate();
+}
+
+TEST_F(TurnClient, AllocateAndHold) {
+  if (WarnIfTurnNotConfigured())
+    return;
+
+  Allocate();
+  PR_Sleep(20000);
+  ASSERT_TRUE(turn_ctx_->state == NR_TURN_CLIENT_STATE_ALLOCATED);
+}
+
+TEST_F(TurnClient, SendToSelf) {
+  if (WarnIfTurnNotConfigured())
+    return;
+
+  Allocate();
+  SendTo(relay_addr_);
+  ASSERT_TRUE_WAIT(received() == 100, 5000);
+  SendTo(relay_addr_);
+  ASSERT_TRUE_WAIT(received() == 200, 1000);
+}
+
+
+TEST_F(TurnClient, SendToSelfTcp) {
+  if (WarnIfTurnNotConfigured())
+    return;
+
+  SetTcp();
+  Allocate();
+  SendTo(relay_addr_);
+  ASSERT_TRUE_WAIT(received() == 100, 5000);
+  SendTo(relay_addr_);
+  ASSERT_TRUE_WAIT(received() == 200, 1000);
+}
+
+TEST_F(TurnClient, PermissionDenied) {
+  if (WarnIfTurnNotConfigured())
+    return;
+
+  Allocate();
+  RequestPermission(relay_addr_);
+  PR_Sleep(1000);
+
+  /* Fake a 403 response */
+  nr_turn_permission *perm;
+  perm = STAILQ_FIRST(&turn_ctx_->permissions);
+  ASSERT_TRUE(perm);
+  while (perm) {
+    perm->stun->last_error_code = 403;
+    std::cerr << "Set 403's on permission" << std::endl;
+    perm = STAILQ_NEXT(perm, entry);
+  }
+
+  SendTo(relay_addr_, R_NOT_PERMITTED);
+  ASSERT_TRUE(received() == 0);
+
+  //TODO: We should check if we can still send to a second destination, but
+  //      we would need a second TURN client as one client can only handle one
+  //      allocation (maybe as part of bug 1128128 ?).
+}
+
+TEST_F(TurnClient, DeallocateReceiveFailure) {
+  if (WarnIfTurnNotConfigured())
+    return;
+
+  Allocate();
+  SendTo(relay_addr_);
+  ASSERT_TRUE_WAIT(received() == 100, 5000);
+  Deallocate();
+  turn_ctx_->state = NR_TURN_CLIENT_STATE_ALLOCATED;
+  SendTo(relay_addr_);
+  PR_Sleep(1000);
+  ASSERT_TRUE(received() == 100);
+}
+
+TEST_F(TurnClient, DeallocateReceiveFailureTcp) {
+  if (WarnIfTurnNotConfigured())
+    return;
+
+  SetTcp();
+  Allocate();
+  SendTo(relay_addr_);
+  ASSERT_TRUE_WAIT(received() == 100, 5000);
+  Deallocate();
+  turn_ctx_->state = NR_TURN_CLIENT_STATE_ALLOCATED;
+  /* Either the connection got closed by the TURN server already, then the send
+   * is going to fail, which we simply ignore. Or the connection is still alive
+   * and we cand send the data, but it should not get forwarded to us. In either
+   * case we should not receive more data. */
+  SendTo(relay_addr_, -1);
+  PR_Sleep(1000);
+  ASSERT_TRUE(received() == 100);
+}
+
+TEST_F(TurnClient, AllocateDummyServer) {
+  if (WarnIfTurnNotConfigured())
+    return;
+
+  turn_server_ = kDummyTurnServer;
+  Allocate(false);
+}