Add a platform implementation of QuicTest and QuicTestWithParam

net/quic/core/crypto/strike_register_test.cc

 // Copyright (c) 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/quic/core/crypto/strike_register.h"
 
 #include <cstdint>
 #include <memory>
 #include <set>
 #include <string>
 
 #include "base/rand_util.h"
+#include "net/quic/platform/api/quic_test.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 
 namespace {
 
 using std::string;
 
 const uint8_t kOrbit[8] = {1, 2, 3, 4, 5, 6, 7, 8};
 
 // StrikeRegisterTests don't look at the random bytes so this function can
 // simply set the random bytes to 0.
 void SetNonce(uint8_t nonce[32], unsigned time, const uint8_t orbit[8]) {
   nonce[0] = time >> 24;
   nonce[1] = time >> 16;
   nonce[2] = time >> 8;
   nonce[3] = time;
   memcpy(nonce + 4, orbit, 8);
   memset(nonce + 12, 0, 20);
 }
 
-TEST(StrikeRegisterTest, SimpleHorizon) {
+class StrikeRegisterTest : public QuicTest {};
+
+TEST_F(StrikeRegisterTest, SimpleHorizon) {
   // The set must reject values created on or before its own creation time.
   StrikeRegister set(10 /* max size */, 1000 /* current time */,
                      100 /* window secs */, kOrbit,
                      StrikeRegister::DENY_REQUESTS_AT_STARTUP);
   uint8_t nonce[32];
   SetNonce(nonce, 999, kOrbit);
   EXPECT_EQ(NONCE_INVALID_TIME_FAILURE, set.Insert(nonce, 1000));
   SetNonce(nonce, 1000, kOrbit);
   EXPECT_EQ(NONCE_INVALID_TIME_FAILURE, set.Insert(nonce, 1000));
 
   EXPECT_EQ(0u, set.GetCurrentValidWindowSecs(1000 /* current time */));
   EXPECT_EQ(0u, set.GetCurrentValidWindowSecs(1100 /* current time */));
   EXPECT_EQ(1u, set.GetCurrentValidWindowSecs(1101 /* current time */));
   EXPECT_EQ(50u, set.GetCurrentValidWindowSecs(1150 /* current time */));
   EXPECT_EQ(100u, set.GetCurrentValidWindowSecs(1200 /* current time */));
   EXPECT_EQ(101u, set.GetCurrentValidWindowSecs(1300 /* current time */));
 }
 
-TEST(StrikeRegisterTest, NoStartupMode) {
+TEST_F(StrikeRegisterTest, NoStartupMode) {
   // Check that a strike register works immediately if NO_STARTUP_PERIOD_NEEDED
   // is specified.
   StrikeRegister set(10 /* max size */, 1000 /* current time */,
                      100 /* window secs */, kOrbit,
                      StrikeRegister::NO_STARTUP_PERIOD_NEEDED);
   uint8_t nonce[32];
   SetNonce(nonce, 1000, kOrbit);
   EXPECT_EQ(NONCE_OK, set.Insert(nonce, 1000));
   EXPECT_EQ(NONCE_NOT_UNIQUE_FAILURE, set.Insert(nonce, 1000));
 
   EXPECT_EQ(101u, set.GetCurrentValidWindowSecs(1000 /* current time */));
   EXPECT_EQ(101u, set.GetCurrentValidWindowSecs(1050 /* current time */));
   EXPECT_EQ(101u, set.GetCurrentValidWindowSecs(1100 /* current time */));
   EXPECT_EQ(101u, set.GetCurrentValidWindowSecs(1200 /* current time */));
   EXPECT_EQ(101u, set.GetCurrentValidWindowSecs(1300 /* current time */));
 }
 
-TEST(StrikeRegisterTest, WindowFuture) {
+TEST_F(StrikeRegisterTest, WindowFuture) {
   // The set must reject values outside the window.
   StrikeRegister set(10 /* max size */, 1000 /* current time */,
                      100 /* window secs */, kOrbit,
                      StrikeRegister::DENY_REQUESTS_AT_STARTUP);
   uint8_t nonce[32];
   SetNonce(nonce, 1101, kOrbit);
   EXPECT_EQ(NONCE_INVALID_TIME_FAILURE, set.Insert(nonce, 1000));
   SetNonce(nonce, 999, kOrbit);
   EXPECT_EQ(NONCE_INVALID_TIME_FAILURE, set.Insert(nonce, 1100));
 }
 
-TEST(StrikeRegisterTest, BadOrbit) {
+TEST_F(StrikeRegisterTest, BadOrbit) {
   // The set must reject values with the wrong orbit
   StrikeRegister set(10 /* max size */, 1000 /* current time */,
                      100 /* window secs */, kOrbit,
                      StrikeRegister::DENY_REQUESTS_AT_STARTUP);
   uint8_t nonce[32];
   static const uint8_t kBadOrbit[8] = {0, 0, 0, 0, 1, 1, 1, 1};
   SetNonce(nonce, 1101, kBadOrbit);
   EXPECT_EQ(NONCE_INVALID_ORBIT_FAILURE, set.Insert(nonce, 1100));
 }
 
-TEST(StrikeRegisterTest, OneValue) {
+TEST_F(StrikeRegisterTest, OneValue) {
   StrikeRegister set(10 /* max size */, 1000 /* current time */,
                      100 /* window secs */, kOrbit,
                      StrikeRegister::DENY_REQUESTS_AT_STARTUP);
   uint8_t nonce[32];
   SetNonce(nonce, 1101, kOrbit);
   EXPECT_EQ(NONCE_OK, set.Insert(nonce, 1101));
 }
 
-TEST(StrikeRegisterTest, RejectDuplicate) {
+TEST_F(StrikeRegisterTest, RejectDuplicate) {
   // The set must reject values with the wrong orbit
   StrikeRegister set(10 /* max size */, 1000 /* current time */,
                      100 /* window secs */, kOrbit,
                      StrikeRegister::DENY_REQUESTS_AT_STARTUP);
   uint8_t nonce[32];
   SetNonce(nonce, 1101, kOrbit);
   EXPECT_EQ(NONCE_OK, set.Insert(nonce, 1101));
   EXPECT_EQ(NONCE_NOT_UNIQUE_FAILURE, set.Insert(nonce, 1101));
 }
 
-TEST(StrikeRegisterTest, HorizonUpdating) {
+TEST_F(StrikeRegisterTest, HorizonUpdating) {
   StrikeRegister::StartupType startup_types[] = {
       StrikeRegister::DENY_REQUESTS_AT_STARTUP,
       StrikeRegister::NO_STARTUP_PERIOD_NEEDED};
 
   for (size_t type_idx = 0; type_idx < arraysize(startup_types); ++type_idx) {
     StrikeRegister set(5 /* max size */, 500 /* current time */,
                        100 /* window secs */, kOrbit, startup_types[type_idx]);
     uint8_t nonce[6][32];
     for (unsigned i = 0; i < 5; i++) {
       SetNonce(nonce[i], 1101 + i, kOrbit);
@@ skipping 31 matching lines @@
     nonce[5][31] = 1;
     EXPECT_EQ(NONCE_OK, set.Insert(nonce[5], 1110));
 
     // This should be beyond the upper valid range now:
     SetNonce(nonce[5], 1116, kOrbit);
     nonce[5][31] = 2;
     EXPECT_EQ(NONCE_INVALID_TIME_FAILURE, set.Insert(nonce[5], 1110));
   }
 }
 
-TEST(StrikeRegisterTest, InsertMany) {
+TEST_F(StrikeRegisterTest, InsertMany) {
   StrikeRegister set(5000 /* max size */, 1000 /* current time */,
                      500 /* window secs */, kOrbit,
                      StrikeRegister::DENY_REQUESTS_AT_STARTUP);
 
   uint8_t nonce[32];
   SetNonce(nonce, 1101, kOrbit);
   for (unsigned i = 0; i < 100000; i++) {
     SetNonce(nonce, 1101 + i / 500, kOrbit);
     memcpy(nonce + 12, &i, sizeof(i));
     EXPECT_EQ(NONCE_INVALID_TIME_FAILURE, set.Insert(nonce, 1100));
@@ skipping 99 matching lines @@
 
   const unsigned max_entries_;
   const unsigned window_secs_;
   const uint32_t creation_time_;
   uint8_t orbit_[8];
   uint32_t horizon_;
 
   std::set<std::pair<uint32_t, string>> nonces_;
 };
 
-class StrikeRegisterStressTest : public ::testing::Test {};
+class StrikeRegisterStressTest : public QuicTest {};
 
 TEST_F(StrikeRegisterStressTest, InOrderInsertion) {
   // Fixed seed gives reproducibility for this test.
   srand(42);
 
   unsigned max_entries = 64;
   uint32_t current_time = 10000, window = 200;
   std::unique_ptr<StrikeRegister> s1(
       new StrikeRegister(max_entries, current_time, window, kOrbit,
                          StrikeRegister::DENY_REQUESTS_AT_STARTUP));
@@ skipping 99 matching lines @@
   }
 
   if (i != kMaxIterations) {
     FAIL() << "Failed after " << i << " iterations";
   }
 }
 
 }  // namespace
 
 }  // namespace net