Land Recent QUIC changes

net/quic/crypto/aes_128_gcm_encrypter_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/aes_128_gcm_encrypter.h"
 
 #include "net/quic/test_tools/quic_test_utils.h"
 
 using base::StringPiece;
 
@@ skipping 267 matching lines @@
   size_t ct_len;
   char tag[1024];
   size_t tag_len;
 
   for (size_t i = 0; i < arraysize(test_group_array); i++) {
     SCOPED_TRACE(i);
     const TestVector* test_vector = test_group_array[i];
     const TestGroupInfo& test_info = test_group_info[i];
     for (size_t j = 0; test_vector[j].key != NULL; j++) {
       // Decode the test vector.
-      ASSERT_TRUE(DecodeHexString(test_vector[j].key, key, &key_len,
-                                  sizeof(key)));
-      ASSERT_TRUE(DecodeHexString(test_vector[j].iv, iv, &iv_len,
-                                  sizeof(iv)));
-      ASSERT_TRUE(DecodeHexString(test_vector[j].pt, pt, &pt_len,
-                                  sizeof(pt)));
-      ASSERT_TRUE(DecodeHexString(test_vector[j].aad, aad, &aad_len,
-                                  sizeof(aad)));
-      ASSERT_TRUE(DecodeHexString(test_vector[j].ct, ct, &ct_len,
-                                  sizeof(ct)));
-      ASSERT_TRUE(DecodeHexString(test_vector[j].tag, tag, &tag_len,
-                                  sizeof(tag)));
+      ASSERT_TRUE(
+          DecodeHexString(test_vector[j].key, key, &key_len, sizeof(key)));
+      ASSERT_TRUE(DecodeHexString(test_vector[j].iv, iv, &iv_len, sizeof(iv)));
+      ASSERT_TRUE(DecodeHexString(test_vector[j].pt, pt, &pt_len, sizeof(pt)));
+      ASSERT_TRUE(
+          DecodeHexString(test_vector[j].aad, aad, &aad_len, sizeof(aad)));
+      ASSERT_TRUE(DecodeHexString(test_vector[j].ct, ct, &ct_len, sizeof(ct)));
+      ASSERT_TRUE(
+          DecodeHexString(test_vector[j].tag, tag, &tag_len, sizeof(tag)));
 
       // The test vector's lengths should look sane. Note that the lengths
       // in |test_info| are in bits.
       EXPECT_EQ(test_info.key_len, key_len * 8);
       EXPECT_EQ(test_info.iv_len, iv_len * 8);
       EXPECT_EQ(test_info.pt_len, pt_len * 8);
       EXPECT_EQ(test_info.aad_len, aad_len * 8);
       EXPECT_EQ(test_info.pt_len, ct_len * 8);
       EXPECT_EQ(test_info.tag_len, tag_len * 8);
 
       Aes128GcmEncrypter encrypter;
       ASSERT_TRUE(encrypter.SetKey(StringPiece(key, key_len)));
       scoped_ptr<QuicData> encrypted(EncryptWithNonce(
           &encrypter, StringPiece(iv, iv_len),
           // OpenSSL fails if NULL is set as the AAD, as opposed to a
           // zero-length, non-NULL pointer. This deliberately tests that we
           // handle this case.
-          StringPiece(aad_len ? aad : NULL, aad_len),
-          StringPiece(pt, pt_len)));
+          StringPiece(aad_len ? aad : NULL, aad_len), StringPiece(pt, pt_len)));
       ASSERT_TRUE(encrypted.get());
       ASSERT_EQ(ct_len + tag_len, encrypted->length());
+      test::CompareCharArraysWithHexError("ciphertext", encrypted->data(),
+                                          ct_len, ct, ct_len);
       test::CompareCharArraysWithHexError(
-          "ciphertext", encrypted->data(), ct_len,
-          ct, ct_len);
-      test::CompareCharArraysWithHexError(
-          "authentication tag", encrypted->data() + ct_len, tag_len,
-          tag, tag_len);
+          "authentication tag", encrypted->data() + ct_len, tag_len, tag,
+          tag_len);
     }
   }
 }
 
 TEST(Aes128GcmEncrypterTest, GetMaxPlaintextSize) {
   Aes128GcmEncrypter encrypter;
   EXPECT_EQ(1000u, encrypter.GetMaxPlaintextSize(1016));
   EXPECT_EQ(100u, encrypter.GetMaxPlaintextSize(116));
   EXPECT_EQ(10u, encrypter.GetMaxPlaintextSize(26));
 }
 
 TEST(Aes128GcmEncrypterTest, GetCiphertextSize) {
   Aes128GcmEncrypter encrypter;
   EXPECT_EQ(1016u, encrypter.GetCiphertextSize(1000));
   EXPECT_EQ(116u, encrypter.GetCiphertextSize(100));
   EXPECT_EQ(26u, encrypter.GetCiphertextSize(10));
 }
 
 }  // namespace test
 }  // namespace net