Land Recent QUIC changes

net/quic/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/crypto/strike_register.h"
 
 #include <set>
 #include <string>
 
 #include "base/basictypes.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace {
 
 using net::StrikeRegister;
 using std::set;
 using std::string;
 
-const uint8 kOrbit[8] = {1, 2, 3, 4, 5, 6, 7, 8};
+const uint8 kOrbit[8] = { 1, 2, 3, 4, 5, 6, 7, 8 };
 
 void
 NonceSetTimeAndOrbit(uint8 nonce[32], unsigned time, const uint8 orbit[8]) {
   nonce[0] = time >> 24;
   nonce[1] = time >> 16;
   nonce[2] = time >> 8;
   nonce[3] = time;
   memcpy(nonce + 4, orbit, 8);
 }
 
@@ skipping 17 matching lines @@
   ASSERT_FALSE(set.Insert(nonce, 1000));
   NonceSetTimeAndOrbit(nonce, 999, kOrbit);
   ASSERT_FALSE(set.Insert(nonce, 1100));
 }
 
 TEST(StrikeRegisterTest, BadOrbit) {
   // The set must reject values with the wrong orbit
   StrikeRegister set(10 /* max size */, 1000 /* current time */,
                      100 /* window secs */, kOrbit);
   uint8 nonce[32];
-  static const uint8 kBadOrbit[8] = {0, 0, 0, 0, 1, 1, 1, 1};
+  static const uint8 kBadOrbit[8] = { 0, 0, 0, 0, 1, 1, 1, 1 };
   NonceSetTimeAndOrbit(nonce, 1101, kBadOrbit);
   ASSERT_FALSE(set.Insert(nonce, 1100));
 }
 
 TEST(StrikeRegisterTest, OneValue) {
   StrikeRegister set(10 /* max size */, 1000 /* current time */,
                      100 /* window secs */, kOrbit);
   uint8 nonce[32];
   NonceSetTimeAndOrbit(nonce, 1101, kOrbit);
   ASSERT_TRUE(set.Insert(nonce, 1100));
@@ skipping 111 matching lines @@
   static uint32 TimeFromBytes(const uint8 d[4]) {
     return static_cast<uint32>(d[0]) << 24 |
            static_cast<uint32>(d[1]) << 16 |
            static_cast<uint32>(d[2]) << 8 |
            static_cast<uint32>(d[3]);
   }
 
   void DropOldestEntry() {
     set<string>::iterator oldest = nonces_.begin(), it;
     uint32 oldest_time =
-      TimeFromBytes(reinterpret_cast<const uint8*>(oldest->data()));
+        TimeFromBytes(reinterpret_cast<const uint8*>(oldest->data()));
 
     for (it = oldest; it != nonces_.end(); it++) {
       uint32 t = TimeFromBytes(reinterpret_cast<const uint8*>(it->data()));
       if (t < oldest_time ||
           (t == oldest_time && memcmp(it->data(), oldest->data(), 32) < 0)) {
         oldest_time = t;
         oldest = it;
       }
     }
 
     nonces_.erase(oldest);
     horizon_ = oldest_time;
   }
 
   const unsigned max_entries_;
   const unsigned window_secs_;
   uint8 orbit_[8];
   uint32 horizon_;
 
   set<string> nonces_;
 };
 
 TEST(StrikeRegisterStressTest, Stress) {
   // Fixed seed gives reproducibility for this test.
   srand(42);
   unsigned max_entries = 64;
   uint32 current_time = 10000, window = 200;
-  scoped_ptr<StrikeRegister> s1(new StrikeRegister(
-      max_entries, current_time, window, kOrbit));
-  scoped_ptr<SlowStrikeRegister> s2(new SlowStrikeRegister(
-      max_entries, current_time, window, kOrbit));
+  scoped_ptr<StrikeRegister> s1(
+      new StrikeRegister(max_entries, current_time, window, kOrbit));
+  scoped_ptr<SlowStrikeRegister> s2(
+      new SlowStrikeRegister(max_entries, current_time, window, kOrbit));
   uint64 i;
 
   // When making changes it's worth removing the limit on this test and running
   // it for a while. For the initial development an opt binary was left running
   // for 10 minutes.
   const uint64 kMaxIterations = 10000;
   for (i = 0; i < kMaxIterations; i++) {
     if (rand() % 1000 == 0) {
       // 0.1% chance of resetting the sets.
       max_entries = rand() % 300 + 2;
       current_time = rand() % 10000;
       window = rand() % 500;
       s1.reset(new StrikeRegister(max_entries, current_time, window, kOrbit));
-      s2.reset(new SlowStrikeRegister(max_entries, current_time, window,
-                                      kOrbit));
+      s2.reset(
+          new SlowStrikeRegister(max_entries, current_time, window, kOrbit));
     }
 
     int32 time_delta = rand() % (window * 4);
     time_delta -= window * 2;
     const uint32 time = current_time + time_delta;
     if (time_delta < 0 && time > current_time) {
       continue;  // overflow
     }
 
     uint8 nonce[32];
@@ skipping 16 matching lines @@
       s1->Validate();
     }
   }
 
   if (i != kMaxIterations) {
     FAIL() << "Failed after " << i << " iterations";
   }
 }
 
 }  // anonymous namespace