Remove some duplicate code in quic tests.

net/quic/crypto/channel_id_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/quic/crypto/channel_id.h"
 
 #include "net/quic/test_tools/crypto_test_utils.h"
+#include "net/quic/test_tools/quic_test_utils.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::StringPiece;
 using std::string;
 
 namespace net {
 namespace test {
 
 namespace {
 
@@ skipping 160 matching lines @@
     "03c7e0d628e50736c7512df0acfa9f2320bd102229f46495ae6d0857cc452a84",
     "2d98ea01f754d34bbc3003df5050200abf445ec728556d7ed7d5c54c55552b6d",
     "9b52672742d637a32add056dfd6d8792f2a33c2e69dafabea09b960bc61e230a",
     "06108e525f845d0155bf60193222b3219c98e3d49424c2fb2a0987f825c17959",
     "62b5cdd591e5b507e560167ba8f6f7cda74673eb315680cb89ccbc4eec477dce",
     true  // P (0 )
   },
   { NULL }
 };
 
-// Returns true if |ch| is a lowercase hexadecimal digit.
-bool IsHexDigit(char ch) {
-  return ('0' <= ch && ch <= '9') || ('a' <= ch && ch <= 'f');
-}
-
-// Converts a lowercase hexadecimal digit to its integer value.
-int HexDigitToInt(char ch) {
-  if ('0' <= ch && ch <= '9') {
-    return ch - '0';
-  }
-  return ch - 'a' + 10;
-}
-
-// |in| is a string consisting of lowercase hexadecimal digits, where
-// every two digits represent one byte. |out| is a buffer of size |max_len|.
-// Converts |in| to bytes and stores the bytes in the |out| buffer. The
-// number of bytes converted is returned in |*out_len|. Returns true on
-// success, false on failure.
-bool DecodeHexString(const char* in,
-                     char* out,
-                     size_t* out_len,
-                     size_t max_len) {
-  if (!in) {
-    *out_len = (size_t)-1;
-    return true;
-  }
-  *out_len = 0;
-  while (*in != '\0') {
-    if (!IsHexDigit(*in) || !IsHexDigit(*(in + 1))) {
-      return false;
-    }
-    if (*out_len >= max_len) {
-      return false;
-    }
-    out[*out_len] = HexDigitToInt(*in) * 16 + HexDigitToInt(*(in + 1));
-    (*out_len)++;
-    in += 2;
-  }
-  return true;
-}
-
 }  // namespace
 
 // A known answer test for ChannelIDVerifier.
 TEST(ChannelIDTest, VerifyKnownAnswerTest) {
-  char msg[1024];
-  size_t msg_len;
-  char key[64];
-  size_t qx_len;
-  size_t qy_len;
-  char signature[64];
-  size_t r_len;
-  size_t s_len;
+  string msg;
+  string qx;
+  string qy;
+  string r;
+  string s;
 
   for (size_t i = 0; test_vector[i].msg != NULL; i++) {
     SCOPED_TRACE(i);
     // Decode the test vector.
-    ASSERT_TRUE(
-        DecodeHexString(test_vector[i].msg, msg, &msg_len, sizeof(msg)));
-    ASSERT_TRUE(DecodeHexString(test_vector[i].qx, key, &qx_len, sizeof(key)));
-    ASSERT_TRUE(DecodeHexString(test_vector[i].qy, key + qx_len, &qy_len,
-                                sizeof(key) - qx_len));
-    ASSERT_TRUE(DecodeHexString(test_vector[i].r, signature, &r_len,
-                                sizeof(signature)));
-    ASSERT_TRUE(DecodeHexString(test_vector[i].s, signature + r_len, &s_len,
-                                sizeof(signature) - r_len));
+    ASSERT_TRUE(DecodeHexString(test_vector[i].msg, &msg));
+    ASSERT_TRUE(DecodeHexString(test_vector[i].qx, &qx));
+    ASSERT_TRUE(DecodeHexString(test_vector[i].qy, &qy));
+    ASSERT_TRUE(DecodeHexString(test_vector[i].r, &r));
+    ASSERT_TRUE(DecodeHexString(test_vector[i].s, &s));
+
+    string key = qx + qy;
+    string signature = r + s;
 
     // The test vector's lengths should look sane.
-    EXPECT_EQ(sizeof(key) / 2, qx_len);
-    EXPECT_EQ(sizeof(key) / 2, qy_len);
-    EXPECT_EQ(sizeof(signature) / 2, r_len);
-    EXPECT_EQ(sizeof(signature) / 2, s_len);
+    EXPECT_EQ(key.size() / 2, qx.size());
+    EXPECT_EQ(key.size() / 2, qy.size());
+    EXPECT_EQ(signature.size() / 2, r.size());
+    EXPECT_EQ(signature.size() / 2, s.size());

[wtc, 2013/11/04 01:58:27]

The new tests are weaker than the original tests.

The original tests verify that qx.size() and qy.size(0 are exactly 64/2 (= 32),
and r.size() and s.size() are 64/2 (= 32).

[eroman, 2013/11/04 19:39:58]

Done.

 
     EXPECT_EQ(test_vector[i].result,
-              ChannelIDVerifier::VerifyRaw(
-                  StringPiece(key, sizeof(key)),
-                  StringPiece(msg, msg_len),
-                  StringPiece(signature, sizeof(signature)),
-                  false));
+              ChannelIDVerifier::VerifyRaw(key, msg, signature, false));
   }
 }
 
 TEST(ChannelIDTest, SignAndVerify) {
   scoped_ptr<ChannelIDSigner> signer(
       CryptoTestUtils::ChannelIDSignerForTesting());
 
   const string signed_data = "signed data";
   const string hostname = "foo.example.com";
   string key, signature;
@@ skipping 17 matching lines @@
   bad_signature[1] ^= 0x80;
   EXPECT_FALSE(ChannelIDVerifier::Verify(
       key, signed_data, string(bad_signature.get(), signature.size())));
 
   EXPECT_FALSE(ChannelIDVerifier::Verify(
       key, "wrong signed data", signature));
 }
 
 }  // namespace test
 }  // namespace net