Update VirtualSocketServerTest to use a fake clock.

webrtc/base/virtualsocket_unittest.cc

 /*
  *  Copyright 2006 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.
  */
 
 #include <math.h>
 #include <time.h>
 #if defined(WEBRTC_POSIX)
 #include <netinet/in.h>
 #endif
 
 #include <memory>
 
 #include "webrtc/base/arraysize.h"
+#include "webrtc/base/fakeclock.h"
 #include "webrtc/base/gunit.h"
 #include "webrtc/base/logging.h"
 #include "webrtc/base/ptr_util.h"
 #include "webrtc/base/testclient.h"
 #include "webrtc/base/testutils.h"
 #include "webrtc/base/thread.h"
 #include "webrtc/base/timeutils.h"
 #include "webrtc/base/virtualsocketserver.h"
 
 using namespace rtc;
@@ skipping 106 matching lines @@
   std::unique_ptr<AsyncUDPSocket> socket;
   uint32_t bandwidth;
   bool done;
   size_t count;
   size_t sec_count;
   double sum;
   double sum_sq;
   uint32_t samples;
 };
 
+// Note: This test uses a fake clock in addition to a virtual network.
 class VirtualSocketServerTest : public testing::Test {
  public:
   VirtualSocketServerTest()
-      : thread_(&ss_),
+      : ss_(&fake_clock_),
+        thread_(&ss_),
         kIPv4AnyAddress(IPAddress(INADDR_ANY), 0),
         kIPv6AnyAddress(IPAddress(in6addr_any), 0) {}
 
   void CheckPortIncrementalization(const SocketAddress& post,
                                    const SocketAddress& pre) {
     EXPECT_EQ(post.port(), pre.port() + 1);
     IPAddress post_ip = post.ipaddr();
     IPAddress pre_ip = pre.ipaddr();
     EXPECT_EQ(pre_ip.family(), post_ip.family());
     if (post_ip.family() == AF_INET) {
@@ skipping 14 matching lines @@
   // to the default route.
   void TestDefaultRoute(const IPAddress& default_route) {
     ss_.SetDefaultRoute(default_route);
 
     // Create client1 bound to the any address.
     AsyncSocket* socket =
         ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
     socket->Bind(EmptySocketAddressWithFamily(default_route.family()));
     SocketAddress client1_any_addr = socket->GetLocalAddress();
     EXPECT_TRUE(client1_any_addr.IsAnyIP());
-    auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket));
+    auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket),
+                                          &fake_clock_);
 
     // Create client2 bound to the default route.
     AsyncSocket* socket2 =
         ss_.CreateAsyncSocket(default_route.family(), SOCK_DGRAM);
     socket2->Bind(SocketAddress(default_route, 0));
     SocketAddress client2_addr = socket2->GetLocalAddress();
     EXPECT_FALSE(client2_addr.IsAnyIP());
-    auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2));
+    auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2),
+                                          &fake_clock_);
 
     // Client1 sends to client2, client2 should see the default route as
     // client1's address.
     SocketAddress client1_addr;
     EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
     EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
     EXPECT_EQ(client1_addr,
               SocketAddress(default_route, client1_any_addr.port()));
 
     // Client2 can send back to client1's default route address.
     EXPECT_EQ(3, client2->SendTo("foo", 3, client1_addr));
     EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
   }
 
   void BasicTest(const SocketAddress& initial_addr) {
     AsyncSocket* socket =
         ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
     socket->Bind(initial_addr);
     SocketAddress server_addr = socket->GetLocalAddress();
     // Make sure VSS didn't switch families on us.
     EXPECT_EQ(server_addr.family(), initial_addr.family());
 
-    auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket));
+    auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket),
+                                          &fake_clock_);
     AsyncSocket* socket2 =
         ss_.CreateAsyncSocket(initial_addr.family(), SOCK_DGRAM);
-    auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2));
+    auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2),
+                                          &fake_clock_);
 
     SocketAddress client2_addr;
     EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
     EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
 
     SocketAddress client1_addr;
     EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
     EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
     EXPECT_EQ(client1_addr, server_addr);
 
     SocketAddress empty = EmptySocketAddressWithFamily(initial_addr.family());
     for (int i = 0; i < 10; i++) {
       client2 = MakeUnique<TestClient>(
-          WrapUnique(AsyncUDPSocket::Create(&ss_, empty)));
+          WrapUnique(AsyncUDPSocket::Create(&ss_, empty)), &fake_clock_);
 
       SocketAddress next_client2_addr;
       EXPECT_EQ(3, client2->SendTo("foo", 3, server_addr));
       EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &next_client2_addr));
       CheckPortIncrementalization(next_client2_addr, client2_addr);
       // EXPECT_EQ(next_client2_addr.port(), client2_addr.port() + 1);
 
       SocketAddress server_addr2;
       EXPECT_EQ(6, client1->SendTo("bizbaz", 6, next_client2_addr));
       EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &server_addr2));
@@ skipping 434 matching lines @@
     EXPECT_EQ(recv_socket->GetLocalAddress().family(), initial_addr.family());
     ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
 
     uint32_t bandwidth = 64 * 1024;
     ss_.set_bandwidth(bandwidth);
 
     Thread* pthMain = Thread::Current();
     Sender sender(pthMain, send_socket, 80 * 1024);
     Receiver receiver(pthMain, recv_socket, bandwidth);
 
-    pthMain->ProcessMessages(5000);
+    // Allow the sender to run for 5 (simulated) seconds, then be stopped for 5
+    // seconds.
+    SIMULATED_WAIT(false, 5000, fake_clock_);
     sender.done = true;
-    pthMain->ProcessMessages(5000);
+    SIMULATED_WAIT(false, 5000, fake_clock_);
 
-    ASSERT_TRUE(receiver.count >= 5 * 3 * bandwidth / 4);
-    ASSERT_TRUE(receiver.count <= 6 * bandwidth);  // queue could drain for 1s
+    // Ensure the observed bandwidth fell within a reasonable margin of error.
+    EXPECT_TRUE(receiver.count >= 5 * 3 * bandwidth / 4);
+    EXPECT_TRUE(receiver.count <= 6 * bandwidth);  // queue could drain for 1s
 
     ss_.set_bandwidth(0);
   }
 
   // It is important that initial_addr's port has to be 0 such that the
   // incremental port behavior could ensure the 2 Binds result in different
   // address.
   void DelayTest(const SocketAddress& initial_addr) {
     time_t seed = ::time(nullptr);
     LOG(LS_VERBOSE) << "seed = " << seed;
@@ skipping 15 matching lines @@
     EXPECT_EQ(send_socket->GetLocalAddress().family(), initial_addr.family());
     EXPECT_EQ(recv_socket->GetLocalAddress().family(), initial_addr.family());
     ASSERT_EQ(0, send_socket->Connect(recv_socket->GetLocalAddress()));
 
     Thread* pthMain = Thread::Current();
     // Avg packet size is 2K, so at 200KB/s for 10s, we should see about
     // 1000 packets, which is necessary to get a good distribution.
     Sender sender(pthMain, send_socket, 100 * 2 * 1024);
     Receiver receiver(pthMain, recv_socket, 0);
 
-    pthMain->ProcessMessages(10000);
+    // Simulate 10 seconds of packets being sent, then check the observed delay
+    // distribution.
+    SIMULATED_WAIT(false, 10000, fake_clock_);
     sender.done = receiver.done = true;
     ss_.ProcessMessagesUntilIdle();
 
     const double sample_mean = receiver.sum / receiver.samples;
     double num =
         receiver.samples * receiver.sum_sq - receiver.sum * receiver.sum;
     double den = receiver.samples * (receiver.samples - 1);
     const double sample_stddev = sqrt(num / den);
     LOG(LS_VERBOSE) << "mean=" << sample_mean << " stddev=" << sample_stddev;
 
@@ skipping 61 matching lines @@
 
   // Test cross-family datagram sending between a client bound to client_addr
   // and a server bound to server_addr. shouldSucceed indicates if sending is
   // expected to succeed or not.
   void CrossFamilyDatagramTest(const SocketAddress& client_addr,
                                const SocketAddress& server_addr,
                                bool shouldSucceed) {
     AsyncSocket* socket = ss_.CreateAsyncSocket(SOCK_DGRAM);
     socket->Bind(server_addr);
     SocketAddress bound_server_addr = socket->GetLocalAddress();
-    auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket));
+    auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket),
+                                          &fake_clock_);
 
     AsyncSocket* socket2 = ss_.CreateAsyncSocket(SOCK_DGRAM);
     socket2->Bind(client_addr);
-    auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2));
+    auto client2 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket2),
+                                          &fake_clock_);
     SocketAddress client2_addr;
 
     if (shouldSucceed) {
       EXPECT_EQ(3, client2->SendTo("foo", 3, bound_server_addr));
       EXPECT_TRUE(client1->CheckNextPacket("foo", 3, &client2_addr));
       SocketAddress client1_addr;
       EXPECT_EQ(6, client1->SendTo("bizbaz", 6, client2_addr));
       EXPECT_TRUE(client2->CheckNextPacket("bizbaz", 6, &client1_addr));
       EXPECT_EQ(client1_addr, bound_server_addr);
     } else {
       EXPECT_EQ(-1, client2->SendTo("foo", 3, bound_server_addr));
       EXPECT_TRUE(client1->CheckNoPacket());
     }
   }
 
  protected:
+  rtc::ScopedFakeClock fake_clock_;
   VirtualSocketServer ss_;
   AutoSocketServerThread thread_;
   const SocketAddress kIPv4AnyAddress;
   const SocketAddress kIPv6AnyAddress;
 };
 
 TEST_F(VirtualSocketServerTest, basic_v4) {
   SocketAddress ipv4_test_addr(IPAddress(INADDR_ANY), 5000);
   BasicTest(ipv4_test_addr);
 }
@@ skipping 64 matching lines @@
 }
 
 TEST_F(VirtualSocketServerTest, bandwidth_v4) {
   BandwidthTest(kIPv4AnyAddress);
 }
 
 TEST_F(VirtualSocketServerTest, bandwidth_v6) {
   BandwidthTest(kIPv6AnyAddress);
 }
 
-// Disabled on iOS simulator since it's a test that relies on being able to
-// process packets fast enough in real time, which isn't the case in the
-// simulator.
-#if defined(TARGET_IPHONE_SIMULATOR)
-#define MAYBE_delay_v4 DISABLED_delay_v4
-#else
-#define MAYBE_delay_v4 delay_v4
-#endif
-TEST_F(VirtualSocketServerTest, MAYBE_delay_v4) {
+TEST_F(VirtualSocketServerTest, delay_v4) {
   DelayTest(kIPv4AnyAddress);
 }
 
-// See: https://code.google.com/p/webrtc/issues/detail?id=2409
-TEST_F(VirtualSocketServerTest, DISABLED_delay_v6) {
+TEST_F(VirtualSocketServerTest, delay_v6) {
   DelayTest(kIPv6AnyAddress);
 }
 
 // Works, receiving socket sees 127.0.0.2.
 TEST_F(VirtualSocketServerTest, CanConnectFromMappedIPv6ToIPv4Any) {
   CrossFamilyConnectionTest(SocketAddress("::ffff:127.0.0.2", 0),
                             SocketAddress("0.0.0.0", 5000),
                             true);
 }
 
@@ skipping 94 matching lines @@
                           true);
 }
 
 TEST_F(VirtualSocketServerTest, SetSendingBlockedWithUdpSocket) {
   AsyncSocket* socket1 =
       ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM);
   std::unique_ptr<AsyncSocket> socket2 =
       WrapUnique(ss_.CreateAsyncSocket(kIPv4AnyAddress.family(), SOCK_DGRAM));
   socket1->Bind(kIPv4AnyAddress);
   socket2->Bind(kIPv4AnyAddress);
-  auto client1 = MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket1));
+  auto client1 =
+      MakeUnique<TestClient>(MakeUnique<AsyncUDPSocket>(socket1), &fake_clock_);
 
   ss_.SetSendingBlocked(true);
   EXPECT_EQ(-1, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
   EXPECT_TRUE(socket1->IsBlocking());
   EXPECT_EQ(0, client1->ready_to_send_count());
 
   ss_.SetSendingBlocked(false);
   EXPECT_EQ(1, client1->ready_to_send_count());
   EXPECT_EQ(3, client1->SendTo("foo", 3, socket2->GetLocalAddress()));
 }
@@ skipping 76 matching lines @@
           << " N=" << kTestSamples[sidx];
         EXPECT_NEAR(kStdDev, stddev, 0.1 * kStdDev)
           << "M=" << kTestMean[midx]
           << " SD=" << kStdDev
           << " N=" << kTestSamples[sidx];
         delete f;
       }
     }
   }
 }