Add a platform implementation of QuicTest and QuicTestWithParam

net/quic/core/congestion_control/bbr_sender_test.cc

 // Copyright 2016 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/core/congestion_control/bbr_sender.h"
 
 #include <algorithm>
 #include <map>
 #include <memory>
 
 #include "net/quic/core/congestion_control/rtt_stats.h"
 #include "net/quic/core/quic_packets.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_logging.h"
+#include "net/quic/platform/api/quic_test.h"
 #include "net/quic/test_tools/mock_clock.h"
 #include "net/quic/test_tools/quic_config_peer.h"
 #include "net/quic/test_tools/quic_connection_peer.h"
 #include "net/quic/test_tools/quic_sent_packet_manager_peer.h"
 #include "net/quic/test_tools/quic_test_utils.h"
 #include "net/quic/test_tools/simulator/quic_endpoint.h"
 #include "net/quic/test_tools/simulator/simulator.h"
 #include "net/quic/test_tools/simulator/switch.h"
-#include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace test {
 
 // Use the initial CWND of 10, as 32 is too much for the test network.
 const uint32_t kInitialCongestionWindowPackets = 10;
 const uint32_t kDefaultWindowTCP =
     kInitialCongestionWindowPackets * kDefaultTCPMSS;
 
 // Test network parameters.  Here, the topology of the network is:
@@ skipping 23 matching lines @@
     QuicTime::Delta::FromMilliseconds(30);
 const QuicTime::Delta kLocalPropagationDelay =
     QuicTime::Delta::FromMilliseconds(2);
 const QuicTime::Delta kTestTransferTime =
     kTestLinkBandwidth.TransferTime(kMaxPacketSize) +
     kLocalLinkBandwidth.TransferTime(kMaxPacketSize);
 const QuicTime::Delta kTestRtt =
     (kTestPropagationDelay + kLocalPropagationDelay + kTestTransferTime) * 2;
 const QuicByteCount kTestBdp = kTestRtt * kTestLinkBandwidth;
 
-class BbrSenderTest : public ::testing::Test {
+class BbrSenderTest : public QuicTest {
  protected:
   BbrSenderTest()
       : simulator_(),
         bbr_sender_(&simulator_,
                     "BBR sender",
                     "Receiver",
                     Perspective::IS_CLIENT,
                     /*connection_id=*/42),
         competing_sender_(&simulator_,
                           "Competing sender",
@@ skipping 41 matching lines @@
   std::unique_ptr<simulator::SymmetricLink> bbr_sender_link_;
   std::unique_ptr<simulator::SymmetricLink> competing_sender_link_;
   std::unique_ptr<simulator::SymmetricLink> receiver_link_;
 
   SimpleRandom random_;
 
   // Owned by different components of the connection.
   const QuicClock* clock_;
   const RttStats* rtt_stats_;
   BbrSender* sender_;
-  QuicFlagSaver flags_;
 
   // Enables BBR on |endpoint| and returns the associated BBR congestion
   // controller.
   BbrSender* SetupBbrSender(simulator::QuicEndpoint* endpoint) {
     const RttStats* rtt_stats =
         endpoint->connection()->sent_packet_manager().GetRttStats();
     // Ownership of the sender will be overtaken by the endpoint.
     BbrSender* sender = new BbrSender(
         rtt_stats,
         QuicSentPacketManagerPeer::GetUnackedPacketMap(
@@ skipping 679 matching lines @@
   sender_->ResumeConnectionState(params, false);
   EXPECT_EQ(kTestLinkBandwidth, sender_->ExportDebugState().max_bandwidth);
   EXPECT_EQ(kTestLinkBandwidth, sender_->BandwidthEstimate());
   ExpectApproxEq(kTestRtt, sender_->ExportDebugState().min_rtt, 0.01f);
 
   DriveOutOfStartup();
 }
 
 }  // namespace test
 }  // namespace net