Increase STUN RTOs

webrtc/p2p/client/basicportallocator_unittest.cc

 /*
  *  Copyright 2009 The WebRTC Project Authors. All rights reserved.
  *
  *  Use of this source code is governed by a BSD-style license
  *  that can be found in the LICENSE file in the root of the source
  *  tree. An additional intellectual property rights grant can be found
  *  in the file PATENTS.  All contributing project authors may
  *  be found in the AUTHORS file in the root of the source tree.
  */
 
@@ skipping 66 matching lines @@
 static const char kIceUfrag0[] = "UF00";
 // Based on ICE_PWD_LENGTH
 static const char kIcePwd0[] = "TESTICEPWD00000000000000";
 
 static const char kContentName[] = "test content";
 
 static const int kDefaultAllocationTimeout = 3000;
 static const char kTurnUsername[] = "test";
 static const char kTurnPassword[] = "test";
 
-// STUN timeout (with all retries) is 9500ms.
+// STUN timeout (with all retries) is cricket::STUN_TOTAL_TIMEOUT.
 // Add some margin of error for slow bots.
-// TODO(deadbeef): Use simulated clock instead of just increasing timeouts to
-// fix flaky tests.
-static const int kStunTimeoutMs = 15000;
+static const int kStunTimeoutMs = cricket::STUN_TOTAL_TIMEOUT;
 
 namespace cricket {
 
 // Helper for dumping candidates
 std::ostream& operator<<(std::ostream& os,
                          const std::vector<Candidate>& candidates) {
   os << '[';
   bool first = true;
   for (const Candidate& c : candidates) {
     if (!first) {
@@ skipping 1122 matching lines @@
   EXPECT_PRED4(HasCandidate, candidates_, "local", "tcp", kClientAddr);
   // RelayPort connection timeout is 3sec. TCP connection with RelayServer
   // will be tried after about 3 seconds.
   EXPECT_EQ_SIMULATED_WAIT(6U, candidates_.size(), 3500, fake_clock);
   EXPECT_EQ(3U, ports_.size());
   EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpIntAddr);
   EXPECT_PRED4(HasCandidate, candidates_, "relay", "tcp", kRelayTcpIntAddr);
   EXPECT_PRED4(HasCandidate, candidates_, "relay", "ssltcp",
                kRelaySslTcpIntAddr);
   EXPECT_PRED4(HasCandidate, candidates_, "relay", "udp", kRelayUdpExtAddr);
-  // We wait at least for a full STUN timeout, which is currently 9.5
-  // seconds.  But since 3-3.5 seconds already passed (see above), we
-  // only need 6.5 more seconds.
-  EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_, 6500, fake_clock);
+  // We wait at least for a full STUN timeout, which
+  // cricket::STUN_TOTAL_TIMEOUT seconds.  But since 3-3.5 seconds
+  // already passed (see above), we wait 3 seconds less than that.
+  EXPECT_TRUE_SIMULATED_WAIT(candidate_allocation_done_,
+                             cricket::STUN_TOTAL_TIMEOUT - 3000, fake_clock);
 }
 
 TEST_F(BasicPortAllocatorTest, TestCandidatePriorityOfMultipleInterfaces) {
   AddInterface(kClientAddr);
   AddInterface(kClientAddr2);
   // Allocating only host UDP ports. This is done purely for testing
   // convenience.
   allocator().set_flags(PORTALLOCATOR_DISABLE_TCP | PORTALLOCATOR_DISABLE_STUN |
                         PORTALLOCATOR_DISABLE_RELAY);
   EXPECT_TRUE(CreateSession(ICE_CANDIDATE_COMPONENT_RTP));
@@ skipping 646 matching lines @@
   for (const Candidate& candidate : candidates) {
     // Expect only relay candidates now that the filter is applied.
     EXPECT_EQ(std::string(RELAY_PORT_TYPE), candidate.type());
     // Expect that the raddr is emptied due to the CF_RELAY filter.
     EXPECT_EQ(candidate.related_address(),
               rtc::EmptySocketAddressWithFamily(candidate.address().family()));
   }
 }
 
 }  // namespace cricket