Minor cleanup change for SetNonce in StrikeRegisterTest per wtc's comments

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 };
 
-void
-NonceSetTimeAndOrbit(uint8 nonce[32], unsigned time, const uint8 orbit[8]) {
+// StrikeRegisterTests don't look at the random bytes so this function can
+// simply set the random bytes to 0.
+void SetNonce(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);
   memset(nonce + 12, 0, 20);
 }
 
 TEST(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 nonce[32];
-  NonceSetTimeAndOrbit(nonce, 999, kOrbit);
+  SetNonce(nonce, 999, kOrbit);
   ASSERT_FALSE(set.Insert(nonce, 1000));
-  NonceSetTimeAndOrbit(nonce, 1000, kOrbit);
+  SetNonce(nonce, 1000, kOrbit);
   ASSERT_FALSE(set.Insert(nonce, 1000));
 }
 
 TEST(StrikeRegisterTest, NoStartupMode) {
   // Check that a strike register works immediately if NO_STARTUP_PERIOD_NEEDED
   // is specified.
   StrikeRegister set(10 /* max size */, 0 /* current time */,
                      100 /* window secs */, kOrbit,
                      StrikeRegister::NO_STARTUP_PERIOD_NEEDED);
   uint8 nonce[32];
-  NonceSetTimeAndOrbit(nonce, 0, kOrbit);
+  SetNonce(nonce, 0, kOrbit);
   ASSERT_TRUE(set.Insert(nonce, 0));
   ASSERT_FALSE(set.Insert(nonce, 0));
 }
 
 TEST(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 nonce[32];
-  NonceSetTimeAndOrbit(nonce, 1101, kOrbit);
+  SetNonce(nonce, 1101, kOrbit);
   ASSERT_FALSE(set.Insert(nonce, 1000));
-  NonceSetTimeAndOrbit(nonce, 999, kOrbit);
+  SetNonce(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,
                      StrikeRegister::DENY_REQUESTS_AT_STARTUP);
   uint8 nonce[32];
   static const uint8 kBadOrbit[8] = { 0, 0, 0, 0, 1, 1, 1, 1 };
-  NonceSetTimeAndOrbit(nonce, 1101, kBadOrbit);
+  SetNonce(nonce, 1101, kBadOrbit);
   ASSERT_FALSE(set.Insert(nonce, 1100));
 }
 
 TEST(StrikeRegisterTest, OneValue) {
   StrikeRegister set(10 /* max size */, 1000 /* current time */,
                      100 /* window secs */, kOrbit,
                      StrikeRegister::DENY_REQUESTS_AT_STARTUP);
   uint8 nonce[32];
-  NonceSetTimeAndOrbit(nonce, 1101, kOrbit);
+  SetNonce(nonce, 1101, kOrbit);
   ASSERT_TRUE(set.Insert(nonce, 1100));
 }
 
 TEST(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 nonce[32];
-  memset(nonce, 0, sizeof(nonce));
-  NonceSetTimeAndOrbit(nonce, 1101, kOrbit);
+  SetNonce(nonce, 1101, kOrbit);
   ASSERT_TRUE(set.Insert(nonce, 1100));
   ASSERT_FALSE(set.Insert(nonce, 1100));
 }
 
 TEST(StrikeRegisterTest, HorizonUpdating) {
   StrikeRegister set(5 /* max size */, 1000 /* current time */,
                      100 /* window secs */, kOrbit,
                      StrikeRegister::DENY_REQUESTS_AT_STARTUP);
   uint8 nonce[6][32];
   for (unsigned i = 0; i < 5; i++) {
-    NonceSetTimeAndOrbit(nonce[i], 1101, kOrbit);
-    memset(nonce[i] + 12, 0, 20);
+    SetNonce(nonce[i], 1101, kOrbit);
     nonce[i][31] = i;
     ASSERT_TRUE(set.Insert(nonce[i], 1100));
   }
 
   // This should push the oldest value out and force the horizon to be updated.
-  NonceSetTimeAndOrbit(nonce[5], 1102, kOrbit);
-  memset(nonce[5] + 12, 0, 20);
+  SetNonce(nonce[5], 1102, kOrbit);
   ASSERT_TRUE(set.Insert(nonce[5], 1100));
 
   // This should be behind the horizon now:
-  NonceSetTimeAndOrbit(nonce[5], 1101, kOrbit);
-  memset(nonce[5] + 12, 0, 20);
+  SetNonce(nonce[5], 1101, kOrbit);
   nonce[5][31] = 10;
   ASSERT_FALSE(set.Insert(nonce[5], 1100));
 }
 
 TEST(StrikeRegisterTest, InsertMany) {
   StrikeRegister set(5000 /* max size */, 1000 /* current time */,
                      500 /* window secs */, kOrbit,
                      StrikeRegister::DENY_REQUESTS_AT_STARTUP);
 
   uint8 nonce[32];
-  NonceSetTimeAndOrbit(nonce, 1101, kOrbit);
+  SetNonce(nonce, 1101, kOrbit);
   for (unsigned i = 0; i < 100000; i++) {
-    NonceSetTimeAndOrbit(nonce, 1101 + i/500, kOrbit);
+    SetNonce(nonce, 1101 + i/500, kOrbit);
     memcpy(nonce + 12, &i, sizeof(i));
     set.Insert(nonce, 1100);
   }
 }
 
 
 // For the following test we create a slow, but simple, version of a
 // StrikeRegister. The behaviour of this object is much easier to understand
 // than the fully fledged version. We then create a test to show, empirically,
 // that the two objects have identical behaviour.
@@ skipping 130 matching lines @@
     }
 
     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];
-    NonceSetTimeAndOrbit(nonce, time, kOrbit);
-    memset(nonce + 12, 0, 20);
+    SetNonce(nonce, time, kOrbit);
 
     // There are 2048 possible nonce values:
     const uint32 v = rand() % 2048;
     nonce[30] = v >> 8;
     nonce[31] = v;
 
     const bool r2 = s2->Insert(nonce, time);
     const bool r1 = s1->Insert(nonce, time);
 
     if (r1 != r2) {
       break;
     }
 
     if (i % 10 == 0) {
       s1->Validate();
     }
   }
 
   if (i != kMaxIterations) {
     FAIL() << "Failed after " << i << " iterations";
   }
 }
 
 }  // anonymous namespace