Add a platform implementation of QuicTest and QuicTestWithParam

net/quic/core/quic_time_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/core/quic_time.h"
+#include "net/quic/platform/api/quic_test.h"
 #include "net/quic/test_tools/mock_clock.h"
-#include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace test {
 
-TEST(QuicTimeDeltaTest, Zero) {
+class QuicTimeDeltaTest : public QuicTest {};
+
+TEST_F(QuicTimeDeltaTest, Zero) {
   EXPECT_TRUE(QuicTime::Delta::Zero().IsZero());
   EXPECT_FALSE(QuicTime::Delta::Zero().IsInfinite());
   EXPECT_FALSE(QuicTime::Delta::FromMilliseconds(1).IsZero());
 }
 
-TEST(QuicTimeDeltaTest, Infinite) {
+TEST_F(QuicTimeDeltaTest, Infinite) {
   EXPECT_TRUE(QuicTime::Delta::Infinite().IsInfinite());
   EXPECT_FALSE(QuicTime::Delta::Zero().IsInfinite());
   EXPECT_FALSE(QuicTime::Delta::FromMilliseconds(1).IsInfinite());
 }
 
-TEST(QuicTimeDeltaTest, FromTo) {
+TEST_F(QuicTimeDeltaTest, FromTo) {
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(1),
             QuicTime::Delta::FromMicroseconds(1000));
   EXPECT_EQ(QuicTime::Delta::FromSeconds(1),
             QuicTime::Delta::FromMilliseconds(1000));
   EXPECT_EQ(QuicTime::Delta::FromSeconds(1),
             QuicTime::Delta::FromMicroseconds(1000000));
 
   EXPECT_EQ(1, QuicTime::Delta::FromMicroseconds(1000).ToMilliseconds());
   EXPECT_EQ(2, QuicTime::Delta::FromMilliseconds(2000).ToSeconds());
   EXPECT_EQ(1000, QuicTime::Delta::FromMilliseconds(1).ToMicroseconds());
   EXPECT_EQ(1, QuicTime::Delta::FromMicroseconds(1000).ToMilliseconds());
   EXPECT_EQ(QuicTime::Delta::FromMilliseconds(2000).ToMicroseconds(),
             QuicTime::Delta::FromSeconds(2).ToMicroseconds());
 }
 
-TEST(QuicTimeDeltaTest, Add) {
+TEST_F(QuicTimeDeltaTest, Add) {
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2000),
             QuicTime::Delta::Zero() + QuicTime::Delta::FromMilliseconds(2));
 }
 
-TEST(QuicTimeDeltaTest, Subtract) {
+TEST_F(QuicTimeDeltaTest, Subtract) {
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(1000),
             QuicTime::Delta::FromMilliseconds(2) -
                 QuicTime::Delta::FromMilliseconds(1));
 }
 
-TEST(QuicTimeDeltaTest, Multiply) {
+TEST_F(QuicTimeDeltaTest, Multiply) {
   int i = 2;
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(4000),
             QuicTime::Delta::FromMilliseconds(2) * i);
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(4000),
             i * QuicTime::Delta::FromMilliseconds(2));
   double d = 2;
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(4000),
             QuicTime::Delta::FromMilliseconds(2) * d);
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(4000),
             d * QuicTime::Delta::FromMilliseconds(2));
 
   // Ensure we are rounding correctly within a single-bit level of precision.
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(5),
             QuicTime::Delta::FromMicroseconds(9) * 0.5);
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2),
             QuicTime::Delta::FromMicroseconds(12) * 0.2);
 }
 
-TEST(QuicTimeDeltaTest, Max) {
+TEST_F(QuicTimeDeltaTest, Max) {
   EXPECT_EQ(QuicTime::Delta::FromMicroseconds(2000),
             std::max(QuicTime::Delta::FromMicroseconds(1000),
                      QuicTime::Delta::FromMicroseconds(2000)));
 }
 
-TEST(QuicTimeDeltaTest, NotEqual) {
+TEST_F(QuicTimeDeltaTest, NotEqual) {
   EXPECT_TRUE(QuicTime::Delta::FromSeconds(0) !=
               QuicTime::Delta::FromSeconds(1));
   EXPECT_FALSE(QuicTime::Delta::FromSeconds(0) !=
                QuicTime::Delta::FromSeconds(0));
 }
 
-TEST(QuicTimeDeltaTest, DebugValue) {
+TEST_F(QuicTimeDeltaTest, DebugValue) {
   const QuicTime::Delta one_us = QuicTime::Delta::FromMicroseconds(1);
   const QuicTime::Delta one_ms = QuicTime::Delta::FromMilliseconds(1);
   const QuicTime::Delta one_s = QuicTime::Delta::FromSeconds(1);
 
   EXPECT_EQ("3s", (3 * one_s).ToDebugValue());
   EXPECT_EQ("3ms", (3 * one_ms).ToDebugValue());
   EXPECT_EQ("3us", (3 * one_us).ToDebugValue());
 
   EXPECT_EQ("3001us", (3 * one_ms + one_us).ToDebugValue());
   EXPECT_EQ("3001ms", (3 * one_s + one_ms).ToDebugValue());
   EXPECT_EQ("3000001us", (3 * one_s + one_us).ToDebugValue());
 }
 
-class QuicTimeTest : public ::testing::Test {
+class QuicTimeTest : public QuicTest {
  protected:
   MockClock clock_;
 };
 
 TEST_F(QuicTimeTest, Initialized) {
   EXPECT_FALSE(QuicTime::Zero().IsInitialized());
   EXPECT_TRUE((QuicTime::Zero() + QuicTime::Delta::FromMicroseconds(1))
                   .IsInitialized());
 }
 
@@ skipping 49 matching lines @@
   const QuicTime zero = QuicTime::Zero();
   const QuicTime one = zero + QuicTime::Delta::FromSeconds(1);
   EXPECT_TRUE(zero <= zero);
   EXPECT_TRUE(zero <= one);
   EXPECT_TRUE(one <= one);
   EXPECT_FALSE(one <= zero);
 }
 
 }  // namespace test
 }  // namespace net