--- a/media/mtransport/test/ice_unittest.cpp
+++ b/media/mtransport/test/ice_unittest.cpp
@@ -587,21 +587,20 @@ class IceTestPeer : public sigslot::has_
     if (stream >= ice_ctx_->GetStreamCount() || !ice_ctx_->GetStream(stream)) {
       EXPECT_TRUE(false) << "No such stream " << stream;
       return candidates;
     }
 
     std::vector<std::string> candidates_in =
       ice_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 << "Returning candidate: " << candidate << std::endl;
+        std::cerr << name_ << " Returning candidate: " << candidate << std::endl;
         candidates.push_back(candidate);
       }
     }
 
     return candidates;
   }
 
   void SetExpectedTypes(NrIceCandidate::Type local,
@@ -668,31 +667,32 @@ class IceTestPeer : public sigslot::has_
   void Connect_s(IceTestPeer *remote, TrickleMode trickle_mode,
                  bool start = true) {
     nsresult res;
 
     remote_ = remote;
 
     trickle_mode_ = trickle_mode;
     ice_complete_ = false;
+    ice_reached_checking_ = false;
     res = ice_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_->GetStreamCount(); ++i) {
         RefPtr<NrIceMediaStream> aStream = ice_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 << "Candidate: " + candidates[j] << std::endl;
+          std::cerr << name_ << " 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_->GetStreamCount(); ++i) {
         RefPtr<NrIceMediaStream> aStream = ice_ctx_->GetStream(i);
@@ -717,17 +717,17 @@ class IceTestPeer : public sigslot::has_
                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 << "Doing trickle for stream " << stream << std::endl;
+    std::cerr << name_ << " Doing trickle for stream " << stream << std::endl;
     // If we are in trickle deferred mode, now trickle in the candidates
     // for |stream|
 
     // The size of streams is not going to change out from under us, so should
     // be safe here.
     ASSERT_GT(remote_->ice_ctx_->GetStreamCount(), stream);
     ASSERT_TRUE(remote_->ice_ctx_->GetStream(stream).get());
 
@@ -828,24 +828,24 @@ class IceTestPeer : public sigslot::has_
               << cand.cand_addr.transport
               << tcp_type
               << " codeword="
               << cand.codeword
               << std::endl;
   }
 
   void DumpAndCheckActiveCandidates_s() {
-    std::cerr << "Active candidates:" << std::endl;
+    std::cerr << name_ << " Active candidates:" << std::endl;
     for (size_t i=0; i < ice_ctx_->GetStreamCount(); ++i) {
       if (!ice_ctx_->GetStream(i)) {
         continue;
       }
 
       for (size_t j=0; j < ice_ctx_->GetStream(i)->components(); ++j) {
-        std::cerr << "Stream " << i << " component " << j+1 << std::endl;
+        std::cerr << name_ << " Stream " << i << " component " << j+1 << std::endl;
 
         UniquePtr<NrIceCandidate> local;
         UniquePtr<NrIceCandidate> remote;
 
         nsresult res = ice_ctx_->GetStream(i)->GetActivePair(j+1, &local, &remote);
         if (res == NS_ERROR_NOT_AVAILABLE) {
           std::cerr << "Component unpaired or disabled." << std::endl;
         } else {
@@ -887,16 +887,17 @@ class IceTestPeer : public sigslot::has_
 
   void Close() {
     test_utils_->sts_target()->Dispatch(
       WrapRunnable(ice_ctx_, &NrIceCtx::destroy_peer_ctx),
       NS_DISPATCH_SYNC);
   }
 
   void Shutdown() {
+    std::cerr << name_ << " Shutdown" << std::endl;
     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;
       }
     }
 
@@ -929,17 +930,17 @@ class IceTestPeer : public sigslot::has_
     (void)ctx;
     if (state != NrIceCtx::ICE_CTX_GATHER_COMPLETE) {
       return;
     }
 
     std::cerr << "Gathering complete for " <<  name_ << std::endl;
     gathering_complete_ = true;
 
-    std::cerr << "CANDIDATES:" << std::endl;
+    std::cerr << name_ << " CANDIDATES:" << std::endl;
     for (size_t i=0; i<ice_ctx_->GetStreamCount(); ++i) {
       std::cerr << "Stream " << name_ << std::endl;
 
       if (!ice_ctx_->GetStream(i)) {
         std::cerr << "DISABLED" << std::endl;
         continue;
       }
 
@@ -969,17 +970,17 @@ class IceTestPeer : public sigslot::has_
       // we can get the corresponding stream on the remote side
       size_t index = -1;
       for (size_t i=0; i<ice_ctx_->GetStreamCount(); ++i) {
         if (ice_ctx_->GetStream(i) == stream) {
           index = i;
           break;
         }
       }
-      ASSERT_NE(index, -1);
+      ASSERT_NE(index, -1u);
 
       ASSERT_GT(remote_->ice_ctx_->GetStreamCount(), index);
       nsresult res = remote_->ice_ctx_->GetStream(index)->ParseTrickleCandidate(
           candidate);
       ASSERT_TRUE(NS_SUCCEEDED(res));
       ++trickled_;
     }
   }
@@ -1119,60 +1120,60 @@ class IceTestPeer : public sigslot::has_
     }
 
     ASSERT_TRUE(removed_pairs.empty()) << "At least one candidate pair has "
                                           "gone missing.";
   }
 
   void StreamReady(NrIceMediaStream *stream) {
     ++ready_ct_;
-    std::cerr << "Stream ready " << stream->name() << " ct=" << ready_ct_ << std::endl;
+    std::cerr << "Stream ready for " << stream->name() << " ct=" << ready_ct_ << std::endl;
     DumpCandidatePairs_s(stream);
   }
   void StreamFailed(NrIceMediaStream *stream) {
-    std::cerr << "Stream failed " << stream->name() << " ct=" << ready_ct_ << std::endl;
+    std::cerr << "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 << "ICE checking " << name_ << std::endl;
+        std::cerr << "ICE reached checking for " << name_ << std::endl;
         ice_reached_checking_ = true;
         break;
       case NrIceCtx::ICE_CTX_OPEN:
-        std::cerr << "ICE completed " << name_ << std::endl;
+        std::cerr << "ICE completed for " << name_ << std::endl;
         ice_complete_ = true;
         break;
       case NrIceCtx::ICE_CTX_FAILED:
         break;
     }
   }
 
   void PacketReceived(NrIceMediaStream *stream, int component, const unsigned char *data,
                       int len) {
-    std::cerr << "Received " << len << " bytes" << std::endl;
+    std::cerr << name_ << ": received " << len << " bytes" << std::endl;
     ++received_;
   }
 
   void SendPacket(int stream, int component, const unsigned char *data,
                   int len) {
     if (!ice_ctx_->GetStream(stream)) {
       ADD_FAILURE() << "No such stream " << stream;
       return;
     }
 
     ASSERT_TRUE(NS_SUCCEEDED(ice_ctx_->GetStream(stream)->SendPacket(component, data, len)));
 
     ++sent_;
-    std::cerr << "Sent " << len << " bytes" << std::endl;
+    std::cerr << name_ << ": sent " << len << " bytes" << std::endl;
   }
 
   void SetCandidateFilter(CandidateFilter filter) {
     candidate_filter_ = filter;
   }
 
   void ParseCandidate_s(size_t i, const std::string& candidate) {
     ASSERT_TRUE(ice_ctx_->GetStream(i).get()) << "No such stream " << i;
@@ -1455,16 +1456,17 @@ class WebRtcIceGatherTest : public StunT
  protected:
   mozilla::UniquePtr<IceTestPeer> peer_;
 };
 
 class WebRtcIceConnectTest : public StunTest {
  public:
   WebRtcIceConnectTest() :
     initted_(false),
+    test_stun_server_initedd_(false),
     use_nat_(false),
     filtering_type_(TestNat::ENDPOINT_INDEPENDENT),
     mapping_type_(TestNat::ENDPOINT_INDEPENDENT),
     block_udp_(false) {}
 
   void SetUp() override {
     StunTest::SetUp();
 
@@ -1486,89 +1488,119 @@ class WebRtcIceConnectTest : public Stun
     p2_->AddStream(components);
   }
 
   void RemoveStream(size_t index) {
     p1_->RemoveStream(index);
     p2_->RemoveStream(index);
   }
 
-  void Init(bool allow_loopback, bool enable_tcp, bool default_only = false) {
-    if (!initted_) {
-      p1_ = MakeUnique<IceTestPeer>("P1", test_utils_, true, allow_loopback,
-                                    enable_tcp, false, default_only);
-      p2_ = MakeUnique<IceTestPeer>("P2", test_utils_, false, allow_loopback,
-                                    enable_tcp, false, default_only);
+  void Init(bool allow_loopback,
+            bool enable_tcp,
+            bool default_only = false,
+            bool setupStunServers = true) {
+    if (initted_) {
+      return;
     }
+
+    p1_ = MakeUnique<IceTestPeer>("P1", test_utils_, true, allow_loopback,
+                                  enable_tcp, false, default_only);
+    p2_ = MakeUnique<IceTestPeer>("P2", test_utils_, false, allow_loopback,
+                                  enable_tcp, false, default_only);
+    InitPeer(p1_.get(), setupStunServers);
+    InitPeer(p2_.get(), setupStunServers);
+
     initted_ = true;
   }
 
-  bool Gather(unsigned int waitTime = kDefaultTimeout,
-              bool setupStunServers = true) {
-    Init(false, false);
+  void InitPeer(IceTestPeer* peer, bool setupStunServers = 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 (setupStunServers) {
-        UseTestStunServer();
+        InitTestStunServer();
+        peer->UseTestStunServer();
       }
-      p1_->UseNat();
-      p2_->UseNat();
-      p1_->SetFilteringType(filtering_type_);
-      p2_->SetFilteringType(filtering_type_);
-      p1_->SetMappingType(mapping_type_);
-      p2_->SetMappingType(mapping_type_);
-      p1_->SetBlockUdp(block_udp_);
-      p2_->SetBlockUdp(block_udp_);
+      peer->UseNat();
+      peer->SetFilteringType(filtering_type_);
+      peer->SetMappingType(mapping_type_);
+      peer->SetBlockUdp(block_udp_);
     } else if (setupStunServers) {
       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));
 
-      p1_->SetStunServers(stun_servers);
-      p2_->SetStunServers(stun_servers);
+      peer->SetStunServers(stun_servers);
     }
-
-    p1_->Gather();
-    p2_->Gather();
+  }
+
+  bool Gather(unsigned int waitTime = kDefaultTimeout) {
+    Init(false, false);
+
+    return GatherCallerAndCallee(p1_.get(), p2_.get(), waitTime);
+  }
+
+  bool GatherCallerAndCallee(IceTestPeer* caller,
+                             IceTestPeer* callee,
+                             unsigned int waitTime = kDefaultTimeout) {
+    caller->Gather();
+    callee->Gather();
 
     if (waitTime) {
-      EXPECT_TRUE_WAIT(p1_->gathering_complete(), waitTime);
-      if (!p1_->gathering_complete())
+      EXPECT_TRUE_WAIT(caller->gathering_complete(), waitTime);
+      if (!caller->gathering_complete())
         return false;
-      EXPECT_TRUE_WAIT(p2_->gathering_complete(), waitTime);
-      if (!p2_->gathering_complete())
+      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() {
+    // to be useful, this method should be called before Init
+    ASSERT_FALSE(initted_);
     block_udp_ = true;
   }
 
+  void InitTestStunServer() {
+    if (test_stun_server_initedd_) {
+      return;
+    }
+
+    std::cerr << "Resetting TestStunServer" << std::endl;
+    TestStunServer::GetInstance(AF_INET)->Reset();
+    test_stun_server_initedd_ = true;
+  }
+
   void UseTestStunServer() {
-    TestStunServer::GetInstance(AF_INET)->Reset();
+    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) {
@@ -1584,31 +1616,44 @@ class WebRtcIceConnectTest : public Stun
   void SetCandidateFilter(CandidateFilter filter, bool both=true) {
     p1_->SetCandidateFilter(filter);
     if (both) {
       p2_->SetCandidateFilter(filter);
     }
   }
 
   void Connect() {
+    ConnectCallerAndCallee(p2_.get(), p1_.get());
+  }
+
+  void ConnectCallerAndCallee(IceTestPeer* caller, IceTestPeer* callee) {
+    ASSERT_TRUE(caller->ready_ct() == 0 && 
+                caller->ice_complete() == 0 && 
+                caller->ice_reached_checking() == 0);
+    ASSERT_TRUE(callee->ready_ct() == 0 && 
+                callee->ice_complete() == 0 && 
+                callee->ice_reached_checking() == 0);
+
     // IceTestPeer::Connect grabs attributes from the first arg, and gives them
     // to |this|, meaning that p2_->Connect(p1_, ...) simulates p1 sending an
     // offer to p2. Order matters here because it determines which peer is
     // controlling.
-    p2_->Connect(p1_.get(), TRICKLE_NONE);
-    p1_->Connect(p2_.get(), TRICKLE_NONE);
-
-    ASSERT_TRUE_WAIT(p1_->ready_ct() == 1 && p2_->ready_ct() == 1,
+    caller->Connect(callee, TRICKLE_NONE);
+    callee->Connect(caller, TRICKLE_NONE);
+
+    ASSERT_TRUE_WAIT(callee->ready_ct() == 1 && caller->ready_ct() == 1,
+                     kDefaultTimeout);
+    ASSERT_TRUE_WAIT(callee->ice_complete() && caller->ice_complete(),
                      kDefaultTimeout);
-    ASSERT_TRUE_WAIT(p1_->ice_complete() && p2_->ice_complete(),
-                     kDefaultTimeout);
-    AssertCheckingReached();
-
-    p1_->DumpAndCheckActiveCandidates();
-    p2_->DumpAndCheckActiveCandidates();
+
+    ASSERT_TRUE(callee->ice_reached_checking());
+    ASSERT_TRUE(caller->ice_reached_checking());
+
+    callee->DumpAndCheckActiveCandidates();
+    caller->DumpAndCheckActiveCandidates();
   }
 
   void SetExpectedTypes(NrIceCandidate::Type local, NrIceCandidate::Type remote,
                         std::string transport = kNrIceTransportUdp) {
     p1_->SetExpectedTypes(local, remote, transport);
     p2_->SetExpectedTypes(local, remote, transport);
   }
 
@@ -1682,29 +1727,45 @@ class WebRtcIceConnectTest : public Stun
                                                     &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() {
-    //    p1_->Send(2);
+    SendReceive(p1_.get(), p2_.get());
+  }
+
+  void SendReceive(IceTestPeer *p1, IceTestPeer *p2,
+                   bool expectTxFailure = false,
+                   bool expectRxFailure = false) {
     test_utils_->sts_target()->Dispatch(
-        WrapRunnable(p1_.get(),
+        WrapRunnable(p1,
                      &IceTestPeer::SendPacket, 0, 1,
                      reinterpret_cast<const unsigned char *>("TEST"), 4),
         NS_DISPATCH_SYNC);
-    ASSERT_EQ(1u, p1_->sent());
-    ASSERT_TRUE_WAIT(p2_->received() == 1, 1000);
+    if (expectTxFailure) {
+      ASSERT_NE(1u, p1->sent());
+    } else {
+      ASSERT_EQ(1u, p1->sent());
+    }
+    if (expectRxFailure) {
+      usleep(1000);
+      ASSERT_TRUE(p2->received() == 0);
+    } else {
+      ASSERT_TRUE_WAIT(p2->received() == 1, 1000);
+    }
   }
 
  protected:
   bool initted_;
+  bool test_stun_server_initedd_;
   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_;
 };
@@ -2261,20 +2322,20 @@ TEST_F(WebRtcIceConnectTest, DISABLED_Te
   AddStream("first", 1);
   ASSERT_TRUE(Gather());
   SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
     NrIceCandidate::Type::ICE_SERVER_REFLEXIVE, kNrIceTransportTcp);
   Connect();
 }
 
 TEST_F(WebRtcIceConnectTest, TestLoopbackOnlySortOf) {
-  Init(true, false);
+  Init(true, false, false, false);
   AddStream("first", 1);
   SetCandidateFilter(IsLoopbackCandidate);
-  ASSERT_TRUE(Gather(kDefaultTimeout, false));
+  ASSERT_TRUE(Gather());
   SetExpectedRemoteCandidateAddr("127.0.0.1");
   Connect();
 }
 
 TEST_F(WebRtcIceConnectTest, TestConnectBothControllingP1Wins) {
   AddStream("first", 1);
   p1_->SetTiebreaker(1);
   p2_->SetTiebreaker(0);
@@ -2336,140 +2397,132 @@ TEST_F(WebRtcIceConnectTest, TestTrickle
   ConnectTrickle();
   SimulateTrickle(0);
   ASSERT_TRUE_WAIT(p1_->ice_complete(), 1000);
   ASSERT_TRUE_WAIT(p2_->ice_complete(), 1000);
   AssertCheckingReached();
 }
 
 TEST_F(WebRtcIceConnectTest, TestGatherFullCone) {
+  UseNat();
   AddStream("first", 1);
-  UseNat();
-  SetFilteringType(TestNat::ENDPOINT_INDEPENDENT);
-  SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
   ASSERT_TRUE(Gather());
 }
 
 TEST_F(WebRtcIceConnectTest, TestGatherFullConeAutoPrioritize) {
+  UseNat();
   Init(true, false);
   AddStream("first", 1);
-  UseNat();
-  SetFilteringType(TestNat::ENDPOINT_INDEPENDENT);
-  SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
   ASSERT_TRUE(Gather());
 }
 
 
 TEST_F(WebRtcIceConnectTest, TestConnectFullCone) {
+  UseNat();
   AddStream("first", 1);
-  UseNat();
-  SetFilteringType(TestNat::ENDPOINT_INDEPENDENT);
-  SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
   SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
                    NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
   ASSERT_TRUE(Gather());
   Connect();
 }
 
 TEST_F(WebRtcIceConnectTest, TestConnectNoNatRouteOnly) {
-  Init(false, false, true);
+  Init(false, false, true, false);
   AddStream("first", 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(kDefaultTimeout, false));
+  ASSERT_TRUE(Gather());
   Connect();
 }
 
 TEST_F(WebRtcIceConnectTest, TestConnectFullConeDefaultRouteOnly) {
+  UseNat();
   Init(false, false, true);
   AddStream("first", 1);
-  UseNat();
-  SetFilteringType(TestNat::ENDPOINT_INDEPENDENT);
-  SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
   SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
                    NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
   ASSERT_TRUE(Gather());
   Connect();
 }
 
 TEST_F(WebRtcIceConnectTest, TestGatherAddressRestrictedCone) {
-  AddStream("first", 1);
   UseNat();
   SetFilteringType(TestNat::ADDRESS_DEPENDENT);
   SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
+  AddStream("first", 1);
   ASSERT_TRUE(Gather());
 }
 
 TEST_F(WebRtcIceConnectTest, TestConnectAddressRestrictedCone) {
-  AddStream("first", 1);
   UseNat();
   SetFilteringType(TestNat::ADDRESS_DEPENDENT);
   SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
+  AddStream("first", 1);
   SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
                    NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
   ASSERT_TRUE(Gather());
   Connect();
 }
 
 TEST_F(WebRtcIceConnectTest, TestGatherPortRestrictedCone) {
-  AddStream("first", 1);
   UseNat();
   SetFilteringType(TestNat::PORT_DEPENDENT);
   SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
+  AddStream("first", 1);
   ASSERT_TRUE(Gather());
 }
 
 TEST_F(WebRtcIceConnectTest, TestConnectPortRestrictedCone) {
-  AddStream("first", 1);
   UseNat();
   SetFilteringType(TestNat::PORT_DEPENDENT);
   SetMappingType(TestNat::ENDPOINT_INDEPENDENT);
+  AddStream("first", 1);
   SetExpectedTypes(NrIceCandidate::Type::ICE_SERVER_REFLEXIVE,
                    NrIceCandidate::Type::ICE_SERVER_REFLEXIVE);
   ASSERT_TRUE(Gather());
   Connect();
 }
 
 TEST_F(WebRtcIceConnectTest, TestGatherSymmetricNat) {
-  AddStream("first", 1);
   UseNat();
   SetFilteringType(TestNat::PORT_DEPENDENT);
   SetMappingType(TestNat::PORT_DEPENDENT);
+  AddStream("first", 1);
   ASSERT_TRUE(Gather());
 }
 
 TEST_F(WebRtcIceConnectTest, TestConnectSymmetricNat) {
   if (turn_server_.empty())
     return;
 
-  AddStream("first", 1);
   UseNat();
   SetFilteringType(TestNat::PORT_DEPENDENT);
   SetMappingType(TestNat::PORT_DEPENDENT);
+  AddStream("first", 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, TestGatherNatBlocksUDP) {
   if (turn_server_.empty())
     return;
 
-  AddStream("first", 1);
   UseNat();
   BlockUdp();
+  AddStream("first", 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,
@@ -2478,19 +2531,19 @@ TEST_F(WebRtcIceConnectTest, TestGatherN
   // 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;
 
-  AddStream("first", 1);
   UseNat();
   BlockUdp();
+  AddStream("first", 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,
@@ -3041,18 +3094,19 @@ TEST_F(WebRtcIceConnectTest, TestPollCan
   r = p2_->GetCandidatePairs(0, &pairs);
   ASSERT_EQ(NS_OK, r);
   ASSERT_NE(0U, pairs.size());
   ASSERT_TRUE(p2_->CandidatePairsPriorityDescending(pairs));
   ASSERT_TRUE(ContainsSucceededPair(pairs));
 }
 
 TEST_F(WebRtcIceConnectTest, TestHostCandPairingFilter) {
+  Init(false, false, false, false);
   AddStream("first", 1);
-  ASSERT_TRUE(Gather(kDefaultTimeout, false));
+  ASSERT_TRUE(Gather(kDefaultTimeout));
   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;
   }
 
@@ -3074,16 +3128,17 @@ TEST_F(WebRtcIceConnectTest, TestHostCan
 }
 
 // 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, false);
   AddStream("first", 1);
   ASSERT_TRUE(Gather(kDefaultTimeout));
   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;