Use fake clock in some more networks tests.

webrtc/p2p/base/stunport_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 40 matching lines @@
         ss_(new rtc::VirtualSocketServer(pss_.get())),
         ss_scope_(ss_.get()),
         network_("unittest", "unittest", rtc::IPAddress(INADDR_ANY), 32),
         socket_factory_(rtc::Thread::Current()),
         stun_server_1_(cricket::TestStunServer::Create(rtc::Thread::Current(),
                                                        kStunAddr1)),
         stun_server_2_(cricket::TestStunServer::Create(rtc::Thread::Current(),
                                                        kStunAddr2)),
         done_(false),
         error_(false),
-        stun_keepalive_delay_(0),
+        stun_keepalive_delay_(1),
         stun_keepalive_lifetime_(-1) {}
 
   cricket::UDPPort* port() const { return stun_port_.get(); }
   bool done() const { return done_; }
   bool error() const { return error_; }
 
   void SetNetworkType(rtc::AdapterType adapter_type) {
     network_.set_type(adapter_type);
   }
 
@@ skipping 81 matching lines @@
     stun_keepalive_lifetime_ = lifetime;
   }
 
   cricket::TestStunServer* stun_server_1() {
     return stun_server_1_.get();
   }
   cricket::TestStunServer* stun_server_2() {
     return stun_server_2_.get();
   }
 
+  rtc::FakeClock& fake_clock() { return fake_clock_; }
+
  private:
+  rtc::ScopedFakeClock fake_clock_;
   std::unique_ptr<rtc::PhysicalSocketServer> pss_;
   std::unique_ptr<rtc::VirtualSocketServer> ss_;
   rtc::SocketServerScope ss_scope_;
   rtc::Network network_;
   rtc::BasicPacketSocketFactory socket_factory_;
   std::unique_ptr<cricket::UDPPort> stun_port_;
   std::unique_ptr<cricket::TestStunServer> stun_server_1_;
   std::unique_ptr<cricket::TestStunServer> stun_server_2_;
   std::unique_ptr<rtc::AsyncPacketSocket> socket_;
   bool done_;
@@ skipping 13 matching lines @@
 TEST_F(StunPortTest, TestCreateUdpPort) {
   CreateSharedUdpPort(kStunAddr1);
   EXPECT_EQ("local", port()->Type());
   EXPECT_EQ(0U, port()->Candidates().size());
 }
 
 // Test that we can get an address from a STUN server.
 TEST_F(StunPortTest, TestPrepareAddress) {
   CreateStunPort(kStunAddr1);
   PrepareAddress();
-  EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+  EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock());
   ASSERT_EQ(1U, port()->Candidates().size());
   EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
 
   // TODO: Add IPv6 tests here, once either physicalsocketserver supports
   // IPv6, or this test is changed to use VirtualSocketServer.
 }
 
 // Test that we fail properly if we can't get an address.
 TEST_F(StunPortTest, TestPrepareAddressFail) {
   CreateStunPort(kBadAddr);
   PrepareAddress();
-  EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+  EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock());
   EXPECT_TRUE(error());
   EXPECT_EQ(0U, port()->Candidates().size());
 }
 
 // Test that we can get an address from a STUN server specified by a hostname.
 TEST_F(StunPortTest, TestPrepareAddressHostname) {
   CreateStunPort(kStunHostnameAddr);
   PrepareAddress();
-  EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+  EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock());
   ASSERT_EQ(1U, port()->Candidates().size());
   EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
   EXPECT_EQ(kStunCandidatePriority, port()->Candidates()[0].priority());
 }
 
 // Test that we handle hostname lookup failures properly.
 TEST_F(StunPortTest, TestPrepareAddressHostnameFail) {
   CreateStunPort(kBadHostnameAddr);
   PrepareAddress();
-  EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+  EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock());
   EXPECT_TRUE(error());
   EXPECT_EQ(0U, port()->Candidates().size());
 }
 
 // This test verifies keepalive response messages don't result in
 // additional candidate generation.
 TEST_F(StunPortTest, TestKeepAliveResponse) {
   SetKeepaliveDelay(500);  // 500ms of keepalive delay.
   CreateStunPort(kStunHostnameAddr);
   PrepareAddress();
-  EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+  EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock());
   ASSERT_EQ(1U, port()->Candidates().size());
   EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
-  // Waiting for 1 seond, which will allow us to process
-  // response for keepalive binding request. 500 ms is the keepalive delay.
-  rtc::Thread::Current()->ProcessMessages(1000);
-  ASSERT_EQ(1U, port()->Candidates().size());
+  EXPECT_EQ_SIMULATED_WAIT(1U, port()->Candidates().size(), 500, fake_clock());

[Taylor Brandstetter, 2017/02/08 01:23:59]

This should do SIMULATED_WAIT(false, 1000, fake_clock()) followed by EXPECT_EQ

[pthatcher1, 2017/02/08 08:52:24]

Done.

 }
 
 // Test that a local candidate can be generated using a shared socket.
 TEST_F(StunPortTest, TestSharedSocketPrepareAddress) {
   CreateSharedUdpPort(kStunAddr1);
   PrepareAddress();
-  EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+  EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock());
   ASSERT_EQ(1U, port()->Candidates().size());
   EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
 }
 
 // Test that we still a get a local candidate with invalid stun server hostname.
 // Also verifing that UDPPort can receive packets when stun address can't be
 // resolved.
 TEST_F(StunPortTest, TestSharedSocketPrepareAddressInvalidHostname) {
   CreateSharedUdpPort(kBadHostnameAddr);
   PrepareAddress();
-  EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+  EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock());
   ASSERT_EQ(1U, port()->Candidates().size());
   EXPECT_TRUE(kLocalAddr.EqualIPs(port()->Candidates()[0].address()));
 
   // Send data to port after it's ready. This is to make sure, UDP port can
   // handle data with unresolved stun server address.
   std::string data = "some random data, sending to cricket::Port.";
   SendData(data.c_str(), data.length());
   // No crash is success.
 }
 
 // Test that the same address is added only once if two STUN servers are in use.
 TEST_F(StunPortTest, TestNoDuplicatedAddressWithTwoStunServers) {
   ServerAddresses stun_servers;
   stun_servers.insert(kStunAddr1);
   stun_servers.insert(kStunAddr2);
   CreateStunPort(stun_servers);
   EXPECT_EQ("stun", port()->Type());
   PrepareAddress();
-  EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+  EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock());
   EXPECT_EQ(1U, port()->Candidates().size());
   EXPECT_EQ(port()->Candidates()[0].relay_protocol(), "");
 }
 
 // Test that candidates can be allocated for multiple STUN servers, one of which
 // is not reachable.
 TEST_F(StunPortTest, TestMultipleStunServersWithBadServer) {
   ServerAddresses stun_servers;
   stun_servers.insert(kStunAddr1);
   stun_servers.insert(kBadAddr);
   CreateStunPort(stun_servers);
   EXPECT_EQ("stun", port()->Type());
   PrepareAddress();
-  EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+  EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock());
   EXPECT_EQ(1U, port()->Candidates().size());
 }
 
 // Test that two candidates are allocated if the two STUN servers return
 // different mapped addresses.
 TEST_F(StunPortTest, TestTwoCandidatesWithTwoStunServersAcrossNat) {
   const SocketAddress kStunMappedAddr1("77.77.77.77", 0);
   const SocketAddress kStunMappedAddr2("88.77.77.77", 0);
   stun_server_1()->set_fake_stun_addr(kStunMappedAddr1);
   stun_server_2()->set_fake_stun_addr(kStunMappedAddr2);
 
   ServerAddresses stun_servers;
   stun_servers.insert(kStunAddr1);
   stun_servers.insert(kStunAddr2);
   CreateStunPort(stun_servers);
   EXPECT_EQ("stun", port()->Type());
   PrepareAddress();
-  EXPECT_TRUE_WAIT(done(), kTimeoutMs);
+  EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock());
   EXPECT_EQ(2U, port()->Candidates().size());
   EXPECT_EQ(port()->Candidates()[0].relay_protocol(), "");
   EXPECT_EQ(port()->Candidates()[1].relay_protocol(), "");
 }
 
 // Test that the stun_keepalive_lifetime is set correctly based on the network
 // type on a STUN port. Also test that it will be updated if the network type
 // changes.
 TEST_F(StunPortTest, TestStunPortGetStunKeepaliveLifetime) {
   // Lifetime for the default (unknown) network type is |kInfiniteLifetime|.
@@ skipping 28 matching lines @@
   EXPECT_EQ(kInfiniteLifetime, port()->stun_keepalive_lifetime());
 }
 
 // Test that STUN binding requests will be stopped shortly if the keep-alive
 // lifetime is short.
 TEST_F(StunPortTest, TestStunBindingRequestShortLifetime) {
   SetKeepaliveDelay(101);
   SetKeepaliveLifetime(100);
   CreateStunPort(kStunAddr1);
   PrepareAddress();
-  EXPECT_TRUE_WAIT(done(), kTimeoutMs);
-  EXPECT_TRUE_WAIT(!port()->HasPendingRequest(cricket::STUN_BINDING_REQUEST),
-                   2000);
+  EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock());
+  EXPECT_TRUE_SIMULATED_WAIT(
+      !port()->HasPendingRequest(cricket::STUN_BINDING_REQUEST), 2000,
+      fake_clock());
 }
 
 // Test that by default, the STUN binding requests will last for a long time.
 TEST_F(StunPortTest, TestStunBindingRequestLongLifetime) {
   SetKeepaliveDelay(101);
   CreateStunPort(kStunAddr1);
   PrepareAddress();
-  EXPECT_TRUE_WAIT(done(), kTimeoutMs);
-  rtc::Thread::Current()->ProcessMessages(1000);
-  EXPECT_TRUE(port()->HasPendingRequest(cricket::STUN_BINDING_REQUEST));
+  EXPECT_TRUE_SIMULATED_WAIT(done(), kTimeoutMs, fake_clock());
+  EXPECT_TRUE_SIMULATED_WAIT(
+      port()->HasPendingRequest(cricket::STUN_BINDING_REQUEST), 1000,
+      fake_clock());
 }