Add a platform implementation of QuicTest and QuicTestWithParam

net/quic/test_tools/simulator/simulator_test.cc

 // Copyright (c) 2012 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "net/quic/test_tools/simulator/simulator.h"
 
 #include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_ptr_util.h"
+#include "net/quic/platform/api/quic_test.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simulator/alarm_factory.h"
 #include "net/quic/test_tools/simulator/link.h"
 #include "net/quic/test_tools/simulator/packet_filter.h"
 #include "net/quic/test_tools/simulator/queue.h"
 #include "net/quic/test_tools/simulator/switch.h"
 #include "net/quic/test_tools/simulator/traffic_policer.h"
-#include "testing/gmock/include/gmock/gmock.h"
-#include "testing/gtest/include/gtest/gtest.h"
 
 using std::string;
 using testing::_;
 using testing::Return;
 using testing::StrictMock;
 
 namespace net {
 namespace simulator {
 
 // A simple counter that increments its value by 1 every specified period.
@@ skipping 12 matching lines @@
     QUIC_DVLOG(1) << name_ << " has value " << value_ << " at time "
                   << clock_->Now().ToDebuggingValue();
     Schedule(clock_->Now() + period_);
   }
 
  private:
   int value_;
   QuicTime::Delta period_;
 };
 
+class SimulatorTest : public QuicTest {};
+
 // Test that the basic event handling works.
-TEST(SimulatorTest, Counters) {
+TEST_F(SimulatorTest, Counters) {
   Simulator simulator;
   Counter fast_counter(&simulator, "fast_counter",
                        QuicTime::Delta::FromSeconds(3));
   Counter slow_counter(&simulator, "slow_counter",
                        QuicTime::Delta::FromSeconds(10));
 
   simulator.RunUntil(
       [&slow_counter]() { return slow_counter.get_value() >= 10; });
 
   EXPECT_EQ(10, slow_counter.get_value());
@@ skipping 93 matching lines @@
 
   ConstrainedPortInterface* tx_port_;
   CounterPort rx_port_;
 
   QuicByteCount bytes_transmitted_;
   QuicPacketCount packets_transmitted_;
 };
 
 // Saturate a symmetric link and verify that the number of packets sent and
 // received is correct.
-TEST(SimulatorTest, DirectLinkSaturation) {
+TEST_F(SimulatorTest, DirectLinkSaturation) {
   Simulator simulator;
   LinkSaturator saturator_a(&simulator, "Saturator A", 1000, "Saturator B");
   LinkSaturator saturator_b(&simulator, "Saturator B", 100, "Saturator A");
   SymmetricLink link(&saturator_a, &saturator_b,
                      QuicBandwidth::FromKBytesPerSecond(1000),
                      QuicTime::Delta::FromMilliseconds(100) +
                          QuicTime::Delta::FromMicroseconds(1));
 
   const QuicTime start_time = simulator.GetClock()->Now();
   const QuicTime after_first_50_ms =
@@ skipping 57 matching lines @@
     return QuicTime::Delta::Zero();
   }
 
   std::vector<std::unique_ptr<Packet>>* packets() { return &packets_; }
 
  private:
   std::vector<std::unique_ptr<Packet>> packets_;
 };
 
 // Ensure the queue behaves correctly with accepting packets.
-TEST(SimulatorTest, Queue) {
+TEST_F(SimulatorTest, Queue) {
   Simulator simulator;
   Queue queue(&simulator, "Queue", 1000);
   PacketAcceptor acceptor;
   queue.set_tx_port(&acceptor);
 
   EXPECT_EQ(0u, queue.bytes_queued());
   EXPECT_EQ(0u, queue.packets_queued());
   EXPECT_EQ(0u, acceptor.packets()->size());
 
   auto first_packet = QuicMakeUnique<Packet>();
@@ skipping 22 matching lines @@
   simulator.RunUntil([]() { return false; });
   EXPECT_EQ(0u, queue.bytes_queued());
   EXPECT_EQ(0u, queue.packets_queued());
   ASSERT_EQ(2u, acceptor.packets()->size());
   EXPECT_EQ(600u, acceptor.packets()->at(0)->size);
   EXPECT_EQ(400u, acceptor.packets()->at(1)->size);
 }
 
 // Simulate a situation where the bottleneck link is 10 times slower than the
 // uplink, and they are separated by a queue.
-TEST(SimulatorTest, QueueBottleneck) {
+TEST_F(SimulatorTest, QueueBottleneck) {
   const QuicBandwidth local_bandwidth =
       QuicBandwidth::FromKBytesPerSecond(1000);
   const QuicBandwidth bottleneck_bandwidth = 0.1f * local_bandwidth;
   const QuicTime::Delta local_propagation_delay =
       QuicTime::Delta::FromMilliseconds(1);
   const QuicTime::Delta bottleneck_propagation_delay =
       QuicTime::Delta::FromMilliseconds(20);
   const QuicByteCount bdp =
       bottleneck_bandwidth *
       (local_propagation_delay + bottleneck_propagation_delay);
@@ skipping 16 matching lines @@
   simulator.RunUntil(
       [&counter]() { return counter.packets() == packets_received; });
   const double loss_ratio =
       1 -
       static_cast<double>(packets_received) / saturator.packets_transmitted();
   EXPECT_NEAR(loss_ratio, 0.9, 0.001);
 }
 
 // Verify that the queue of exactly one packet allows the transmission to
 // actually go through.
-TEST(SimulatorTest, OnePacketQueue) {
+TEST_F(SimulatorTest, OnePacketQueue) {
   const QuicBandwidth local_bandwidth =
       QuicBandwidth::FromKBytesPerSecond(1000);
   const QuicBandwidth bottleneck_bandwidth = 0.1f * local_bandwidth;
   const QuicTime::Delta local_propagation_delay =
       QuicTime::Delta::FromMilliseconds(1);
   const QuicTime::Delta bottleneck_propagation_delay =
       QuicTime::Delta::FromMilliseconds(20);
 
   Simulator simulator;
   LinkSaturator saturator(&simulator, "Saturator", 1000, "Counter");
@@ skipping 15 matching lines @@
       simulator.GetClock()->Now() + QuicTime::Delta::FromSeconds(10);
   simulator.RunUntil([&simulator, &counter, deadline]() {
     return counter.packets() == packets_received ||
            simulator.GetClock()->Now() > deadline;
   });
   ASSERT_EQ(packets_received, counter.packets());
 }
 
 // Simulate a network where three endpoints are connected to a switch and they
 // are sending traffic in circle (1 -> 2, 2 -> 3, 3 -> 1).
-TEST(SimulatorTest, SwitchedNetwork) {
+TEST_F(SimulatorTest, SwitchedNetwork) {
   const QuicBandwidth bandwidth = QuicBandwidth::FromBytesPerSecond(10000);
   const QuicTime::Delta base_propagation_delay =
       QuicTime::Delta::FromMilliseconds(50);
 
   Simulator simulator;
   LinkSaturator saturator1(&simulator, "Saturator 1", 1000, "Saturator 2");
   LinkSaturator saturator2(&simulator, "Saturator 2", 1000, "Saturator 3");
   LinkSaturator saturator3(&simulator, "Saturator 3", 1000, "Saturator 1");
   Switch network_switch(&simulator, "Switch", 8,
                         bandwidth * base_propagation_delay * 10);
@@ skipping 104 matching lines @@
   explicit CounterDelegate(size_t* counter) : counter_(counter) {}
 
   void OnAlarm() override { *counter_ += 1; }
 
  private:
   size_t* counter_;
 };
 
 // Verifies that the alarms work correctly, even when they are repeatedly
 // toggled.
-TEST(SimulatorTest, Alarms) {
+TEST_F(SimulatorTest, Alarms) {
   Simulator simulator;
   QuicAlarmFactory* alarm_factory = simulator.GetAlarmFactory();
 
   size_t fast_alarm_counter = 0;
   size_t slow_alarm_counter = 0;
   std::unique_ptr<QuicAlarm> alarm_fast(
       alarm_factory->CreateAlarm(new CounterDelegate(&fast_alarm_counter)));
   std::unique_ptr<QuicAlarm> alarm_slow(
       alarm_factory->CreateAlarm(new CounterDelegate(&slow_alarm_counter)));
 
   const QuicTime start_time = simulator.GetClock()->Now();
   alarm_fast->Set(start_time + QuicTime::Delta::FromMilliseconds(100));
   alarm_slow->Set(start_time + QuicTime::Delta::FromMilliseconds(750));
   AlarmToggler toggler(&simulator, "Toggler", alarm_slow.get(),
                        QuicTime::Delta::FromMilliseconds(100));
 
   const QuicTime end_time =
       start_time + QuicTime::Delta::FromMilliseconds(1000);
   EXPECT_FALSE(simulator.RunUntil([&simulator, end_time]() {
     return simulator.GetClock()->Now() >= end_time;
   }));
   EXPECT_EQ(1u, slow_alarm_counter);
   EXPECT_EQ(1u, fast_alarm_counter);
 
   EXPECT_EQ(4, toggler.times_set());
   EXPECT_EQ(4, toggler.times_cancelled());
 }
 
 // Verifies that a cancelled alarm is never fired.
-TEST(SimulatorTest, AlarmCancelling) {
+TEST_F(SimulatorTest, AlarmCancelling) {
   Simulator simulator;
   QuicAlarmFactory* alarm_factory = simulator.GetAlarmFactory();
 
   size_t alarm_counter = 0;
   std::unique_ptr<QuicAlarm> alarm(
       alarm_factory->CreateAlarm(new CounterDelegate(&alarm_counter)));
 
   const QuicTime start_time = simulator.GetClock()->Now();
   const QuicTime alarm_at = start_time + QuicTime::Delta::FromMilliseconds(300);
   const QuicTime end_time = start_time + QuicTime::Delta::FromMilliseconds(400);
 
   alarm->Set(alarm_at);
   alarm->Cancel();
   EXPECT_FALSE(alarm->IsSet());
 
   EXPECT_FALSE(simulator.RunUntil([&simulator, end_time]() {
     return simulator.GetClock()->Now() >= end_time;
   }));
 
   EXPECT_FALSE(alarm->IsSet());
   EXPECT_EQ(0u, alarm_counter);
 }
 
 // Tests Simulator::RunUntilOrTimeout() interface.
-TEST(SimulatorTest, RunUntilOrTimeout) {
+TEST_F(SimulatorTest, RunUntilOrTimeout) {
   Simulator simulator;
   bool simulation_result;
 
   // Count the number of seconds since the beginning of the simulation.
   Counter counter(&simulator, "counter", QuicTime::Delta::FromSeconds(1));
 
   // Ensure that the counter reaches the value of 10 given a 20 second deadline.
   simulation_result = simulator.RunUntilOrTimeout(
       [&counter]() { return counter.get_value() == 10; },
       QuicTime::Delta::FromSeconds(20));
   ASSERT_TRUE(simulation_result);
 
   // Ensure that the counter will not reach the value of 100 given that the
   // starting value is 10 and the deadline is 20 seconds.
   simulation_result = simulator.RunUntilOrTimeout(
       [&counter]() { return counter.get_value() == 100; },
       QuicTime::Delta::FromSeconds(20));
   ASSERT_FALSE(simulation_result);
 }
 
 // Tests Simulator::RunFor() interface.
-TEST(SimulatorTest, RunFor) {
+TEST_F(SimulatorTest, RunFor) {
   Simulator simulator;
 
   Counter counter(&simulator, "counter", QuicTime::Delta::FromSeconds(3));
 
   simulator.RunFor(QuicTime::Delta::FromSeconds(100));
 
   EXPECT_EQ(33, counter.get_value());
 }
 
 class MockPacketFilter : public PacketFilter {
  public:
   MockPacketFilter(Simulator* simulator, string name, Endpoint* endpoint)
       : PacketFilter(simulator, name, endpoint) {}
   MOCK_METHOD1(FilterPacket, bool(const Packet&));
 };
 
 // Set up two trivial packet filters, one allowing any packets, and one dropping
 // all of them.
-TEST(SimulatorTest, PacketFilter) {
+TEST_F(SimulatorTest, PacketFilter) {
   const QuicBandwidth bandwidth =
       QuicBandwidth::FromBytesPerSecond(1024 * 1024);
   const QuicTime::Delta base_propagation_delay =
       QuicTime::Delta::FromMilliseconds(5);
 
   Simulator simulator;
   LinkSaturator saturator_a(&simulator, "Saturator A", 1000, "Saturator B");
   LinkSaturator saturator_b(&simulator, "Saturator B", 1000, "Saturator A");
 
   // Attach packets to the switch to create a delay between the point at which
@@ skipping 18 matching lines @@
 
   // Run the simulation for a while, and expect that only B will receive any
   // packets.
   simulator.RunFor(QuicTime::Delta::FromSeconds(10));
   EXPECT_GE(saturator_b.counter()->packets(), 1u);
   EXPECT_EQ(saturator_a.counter()->packets(), 0u);
 }
 
 // Set up a traffic policer in one direction that throttles at 25% of link
 // bandwidth, and put two link saturators at each endpoint.
-TEST(SimulatorTest, TrafficPolicer) {
+TEST_F(SimulatorTest, TrafficPolicer) {
   const QuicBandwidth bandwidth =
       QuicBandwidth::FromBytesPerSecond(1024 * 1024);
   const QuicTime::Delta base_propagation_delay =
       QuicTime::Delta::FromMilliseconds(5);
   const QuicTime::Delta timeout = QuicTime::Delta::FromSeconds(10);
 
   Simulator simulator;
   LinkSaturator saturator1(&simulator, "Saturator 1", 1000, "Saturator 2");
   LinkSaturator saturator2(&simulator, "Saturator 2", 1000, "Saturator 1");
   Switch network_switch(&simulator, "Switch", 8,
@@ skipping 37 matching lines @@
 
   // Check that only one direction is throttled.
   test::ExpectApproxEq(saturator1.bytes_transmitted() / 4,
                        saturator2.counter()->bytes(), 0.1f);
   test::ExpectApproxEq(saturator2.bytes_transmitted(),
                        saturator1.counter()->bytes(), 0.1f);
 }
 
 // Ensure that a larger burst is allowed when the policed saturator exits
 // quiescence.
-TEST(SimulatorTest, TrafficPolicerBurst) {
+TEST_F(SimulatorTest, TrafficPolicerBurst) {
   const QuicBandwidth bandwidth =
       QuicBandwidth::FromBytesPerSecond(1024 * 1024);
   const QuicTime::Delta base_propagation_delay =
       QuicTime::Delta::FromMilliseconds(5);
   const QuicTime::Delta timeout = QuicTime::Delta::FromSeconds(10);
 
   Simulator simulator;
   LinkSaturator saturator1(&simulator, "Saturator 1", 1000, "Saturator 2");
   LinkSaturator saturator2(&simulator, "Saturator 2", 1000, "Saturator 1");
   Switch network_switch(&simulator, "Switch", 8,
@@ skipping 34 matching lines @@
                        saturator2.counter()->bytes(), 0.1f);
 
   // Expect subsequent traffic to be policed.
   saturator1.Resume();
   simulator.RunFor(QuicTime::Delta::FromSeconds(10));
   test::ExpectApproxEq(saturator1.bytes_transmitted() / 4,
                        saturator2.counter()->bytes(), 0.1f);
 }
 
 // Test that the packet aggregation support in queues work.
-TEST(SimulatorTest, PacketAggregation) {
+TEST_F(SimulatorTest, PacketAggregation) {
   // Model network where the delays are dominated by transfer delay.
   const QuicBandwidth bandwidth = QuicBandwidth::FromBytesPerSecond(1000);
   const QuicTime::Delta base_propagation_delay =
       QuicTime::Delta::FromMicroseconds(1);
   const QuicByteCount aggregation_threshold = 1000;
   const QuicTime::Delta aggregation_timeout = QuicTime::Delta::FromSeconds(30);
 
   Simulator simulator;
   LinkSaturator saturator1(&simulator, "Saturator 1", 10, "Saturator 2");
   LinkSaturator saturator2(&simulator, "Saturator 2", 10, "Saturator 1");
@@ skipping 56 matching lines @@
   EXPECT_EQ(500u, queue->bytes_queued());
 
   // Time out again.
   simulator.RunFor(aggregation_timeout);
   EXPECT_EQ(6900u, saturator2.counter()->bytes());
   EXPECT_EQ(0u, queue->bytes_queued());
 }
 
 }  // namespace simulator
 }  // namespace net