Add a platform implementation of QuicTest and QuicTestWithParam

net/tools/quic/quic_server_test.cc

 // Copyright 2013 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/tools/quic/quic_server.h"
 
 #include "net/quic/core/crypto/quic_random.h"
 #include "net/quic/core/quic_utils.h"
 #include "net/quic/platform/api/quic_flags.h"
 #include "net/quic/platform/api/quic_logging.h"
 #include "net/quic/platform/api/quic_socket_address.h"
+#include "net/quic/platform/api/quic_test.h"
 #include "net/quic/test_tools/crypto_test_utils.h"
 #include "net/quic/test_tools/mock_quic_dispatcher.h"
 #include "net/tools/quic/quic_epoll_alarm_factory.h"
 #include "net/tools/quic/quic_epoll_connection_helper.h"
 #include "net/tools/quic/quic_simple_crypto_server_stream_helper.h"
 #include "net/tools/quic/test_tools/quic_server_peer.h"
-#include "testing/gtest/include/gtest/gtest.h"
 
 using ::testing::_;
 
 namespace net {
 namespace test {
 
 namespace {
 
 class MockQuicSimpleDispatcher : public QuicSimpleDispatcher {
  public:
@@ skipping 42 matching lines @@
         std::unique_ptr<QuicEpollAlarmFactory>(
             new QuicEpollAlarmFactory(epoll_server())),
         &response_cache_);
     return mock_dispatcher_;
   }
 
   MockQuicSimpleDispatcher* mock_dispatcher_;
   QuicHttpResponseCache response_cache_;
 };
 
-class QuicServerEpollInTest : public ::testing::Test {
+class QuicServerEpollInTest : public QuicTest {
  public:
   QuicServerEpollInTest()
       : port_(net::test::kTestPort),
         server_address_(QuicIpAddress::Loopback4(), port_) {}
 
   void StartListening() {
     server_.CreateUDPSocketAndListen(server_address_);
     ASSERT_TRUE(QuicServerPeer::SetSmallSocket(&server_));
 
     if (!server_.overflow_supported()) {
       QUIC_LOG(WARNING) << "Overflow not supported.  Not testing.";
       return;
     }
   }
 
  protected:
-  QuicFlagSaver saver_;
   int port_;
   QuicSocketAddress server_address_;
   TestQuicServer server_;
 };
 
 // Tests that if dispatcher has CHLOs waiting for connection creation, EPOLLIN
 // event should try to create connections for them. And set epoll mask with
 // EPOLLIN if there are still CHLOs remaining at the end of epoll event.
 TEST_F(QuicServerEpollInTest, ProcessBufferedCHLOsOnEpollin) {
   FLAGS_quic_reloadable_flag_quic_limit_num_new_sessions_per_epoll_loop = true;
@@ skipping 26 matching lines @@
                   reinterpret_cast<sockaddr*>(&storage), sizeof(storage));
   if (rc < 0) {
     QUIC_DLOG(INFO) << errno << " " << strerror(errno);
   }
 
   while (more_chlos) {
     server_.WaitForEvents();
   }
 }
 
-class QuicServerDispatchPacketTest : public ::testing::Test {
+class QuicServerDispatchPacketTest : public QuicTest {
  public:
   QuicServerDispatchPacketTest()
       : crypto_config_("blah",
                        QuicRandom::GetInstance(),
                        crypto_test_utils::ProofSourceForTesting()),
         version_manager_(AllSupportedVersions()),
         dispatcher_(
             config_,
             &crypto_config_,
             &version_manager_,
@@ skipping 42 matching lines @@
       reinterpret_cast<char*>(valid_packet), arraysize(valid_packet),
       QuicTime::Zero(), false);
 
   EXPECT_CALL(dispatcher_, ProcessPacket(_, _, _)).Times(1);
   DispatchPacket(encrypted_valid_packet);
 }
 
 }  // namespace
 }  // namespace test
 }  // namespace net