Update from https://crrev.com/312398

third_party/boringssl/boringssl_unittest.cc

 // Copyright 2014 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 <stdarg.h>
 
 #include <string>
 
 #include "base/base_paths.h"
 #include "base/command_line.h"
@@ skipping 38 matching lines @@
 bool BoringSSLPath(base::FilePath* result) {
   if (!PathService::Get(base::DIR_SOURCE_ROOT, result))
     return false;
 
   *result = result->Append(FILE_PATH_LITERAL("third_party"));
   *result = result->Append(FILE_PATH_LITERAL("boringssl"));
   *result = result->Append(FILE_PATH_LITERAL("src"));
   return true;
 }
 
-bool CryptoCipherPath(base::FilePath *result) {
+bool CryptoCipherTestPath(base::FilePath *result) {
   if (!BoringSSLPath(result))
     return false;
 
   *result = result->Append(FILE_PATH_LITERAL("crypto"));
   *result = result->Append(FILE_PATH_LITERAL("cipher"));
+  *result = result->Append(FILE_PATH_LITERAL("test"));
   return true;
 }
 
 }  // anonymous namespace
 
-TEST(BoringSSL, AES128GCM) {
-  base::FilePath data_file;
-  ASSERT_TRUE(CryptoCipherPath(&data_file));
-  data_file = data_file.Append(FILE_PATH_LITERAL("aes_128_gcm_tests.txt"));
+struct AEADTest {
+  const base::CommandLine::CharType *name;
+  const base::FilePath::CharType *test_vector_filename;
+};
 
-  std::vector<base::CommandLine::StringType> args;
-  args.push_back(FILE_PATH_LITERAL("aes-128-gcm"));
-  args.push_back(data_file.value());
+static const AEADTest kAEADTests[] = {
+    {FILE_PATH_LITERAL("aes-128-gcm"),
+     FILE_PATH_LITERAL("aes_128_gcm_tests.txt")},
+    {FILE_PATH_LITERAL("aes-128-key-wrap"),
+     FILE_PATH_LITERAL("aes_128_key_wrap_tests.txt")},
+    {FILE_PATH_LITERAL("aes-256-gcm"),
+     FILE_PATH_LITERAL("aes_256_gcm_tests.txt")},
+    {FILE_PATH_LITERAL("aes-256-key-wrap"),
+     FILE_PATH_LITERAL("aes_256_key_wrap_tests.txt")},
+    {FILE_PATH_LITERAL("chacha20-poly1305"),
+     FILE_PATH_LITERAL("chacha20_poly1305_tests.txt")},
+    {FILE_PATH_LITERAL("rc4-md5-tls"),
+     FILE_PATH_LITERAL("rc4_md5_tls_tests.txt")},
+    {FILE_PATH_LITERAL("rc4-sha1-tls"),
+     FILE_PATH_LITERAL("rc4_sha1_tls_tests.txt")},
+    {FILE_PATH_LITERAL("aes-128-cbc-sha1-tls"),
+     FILE_PATH_LITERAL("aes_128_cbc_sha1_tls_tests.txt")},
+    {FILE_PATH_LITERAL("aes-128-cbc-sha1-tls-implicit-iv"),
+     FILE_PATH_LITERAL("aes_128_cbc_sha1_tls_implicit_iv_tests.txt")},
+    {FILE_PATH_LITERAL("aes-128-cbc-sha256-tls"),
+     FILE_PATH_LITERAL("aes_128_cbc_sha256_tls_tests.txt")},
+    {FILE_PATH_LITERAL("aes-256-cbc-sha1-tls"),
+     FILE_PATH_LITERAL("aes_256_cbc_sha1_tls_tests.txt")},
+    {FILE_PATH_LITERAL("aes-256-cbc-sha1-tls-implicit-iv"),
+     FILE_PATH_LITERAL("aes_256_cbc_sha1_tls_implicit_iv_tests.txt")},
+    {FILE_PATH_LITERAL("aes-256-cbc-sha256-tls"),
+     FILE_PATH_LITERAL("aes_256_cbc_sha256_tls_tests.txt")},
+    {FILE_PATH_LITERAL("aes-256-cbc-sha384-tls"),
+     FILE_PATH_LITERAL("aes_256_cbc_sha384_tls_tests.txt")},
+    {FILE_PATH_LITERAL("des-ede3-cbc-sha1-tls"),
+     FILE_PATH_LITERAL("des_ede3_cbc_sha1_tls_tests.txt")},
+    {FILE_PATH_LITERAL("des-ede3-cbc-sha1-tls-implicit-iv"),
+     FILE_PATH_LITERAL("des_ede3_cbc_sha1_tls_implicit_iv_tests.txt")},
+    {FILE_PATH_LITERAL("rc4-md5-ssl3"),
+     FILE_PATH_LITERAL("rc4_md5_ssl3_tests.txt")},
+    {FILE_PATH_LITERAL("rc4-sha1-ssl3"),
+     FILE_PATH_LITERAL("rc4_sha1_ssl3_tests.txt")},
+    {FILE_PATH_LITERAL("aes-128-cbc-sha1-ssl3"),
+     FILE_PATH_LITERAL("aes_128_cbc_sha1_ssl3_tests.txt")},
+    {FILE_PATH_LITERAL("aes-256-cbc-sha1-ssl3"),
+     FILE_PATH_LITERAL("aes_256_cbc_sha1_ssl3_tests.txt")},
+    {FILE_PATH_LITERAL("des-ede3-cbc-sha1-ssl3"),
+     FILE_PATH_LITERAL("des_ede3_cbc_sha1_ssl3_tests.txt")},
+};
 
-  TestProcess("aead_test", args);
-}
+TEST(BoringSSL, AEADs) {
+  base::FilePath test_vector_dir;
+  ASSERT_TRUE(CryptoCipherTestPath(&test_vector_dir));
 
-TEST(BoringSSL, AES256GCM) {
-  base::FilePath data_file;
-  ASSERT_TRUE(CryptoCipherPath(&data_file));
-  data_file = data_file.Append(FILE_PATH_LITERAL("aes_256_gcm_tests.txt"));
+  for (size_t i = 0; i < arraysize(kAEADTests); i++) {
+    const AEADTest& test = kAEADTests[i];
+    SCOPED_TRACE(test.name);
 
-  std::vector<base::CommandLine::StringType> args;
-  args.push_back(FILE_PATH_LITERAL("aes-256-gcm"));
-  args.push_back(data_file.value());
+    base::FilePath test_vector_file =
+        test_vector_dir.Append(test.test_vector_filename);
 
-  TestProcess("aead_test", args);
-}
+    std::vector<base::CommandLine::StringType> args;
+    args.push_back(test.name);
+    args.push_back(test_vector_file.value());
 
-TEST(BoringSSL, ChaCha20Poly1305) {
-  base::FilePath data_file;
-  ASSERT_TRUE(CryptoCipherPath(&data_file));
-  data_file =
-      data_file.Append(FILE_PATH_LITERAL("chacha20_poly1305_tests.txt"));
-
-  std::vector<base::CommandLine::StringType> args;
-  args.push_back(FILE_PATH_LITERAL("chacha20-poly1305"));
-  args.push_back(data_file.value());
-
-  TestProcess("aead_test", args);
-}
-
-TEST(BoringSSL, RC4MD5) {
-  base::FilePath data_file;
-  ASSERT_TRUE(CryptoCipherPath(&data_file));
-  data_file = data_file.Append(FILE_PATH_LITERAL("rc4_md5_tests.txt"));
-
-  std::vector<base::CommandLine::StringType> args;
-  args.push_back(FILE_PATH_LITERAL("rc4-md5"));
-  args.push_back(data_file.value());
-
-  TestProcess("aead_test", args);
-}
-
-TEST(BoringSSL, AESKW128) {
-  base::FilePath data_file;
-  ASSERT_TRUE(CryptoCipherPath(&data_file));
-  data_file = data_file.Append(FILE_PATH_LITERAL("aes_128_key_wrap_tests.txt"));
-
-  std::vector<base::CommandLine::StringType> args;
-  args.push_back(FILE_PATH_LITERAL("aes-128-key-wrap"));
-  args.push_back(data_file.value());
-
-  TestProcess("aead_test", args);
-}
-
-TEST(BoringSSL, AESKW256) {
-  base::FilePath data_file;
-  ASSERT_TRUE(CryptoCipherPath(&data_file));
-  data_file = data_file.Append(FILE_PATH_LITERAL("aes_256_key_wrap_tests.txt"));
-
-  std::vector<base::CommandLine::StringType> args;
-  args.push_back(FILE_PATH_LITERAL("aes-256-key-wrap"));
-  args.push_back(data_file.value());
-
-  TestProcess("aead_test", args);
+    TestProcess("aead_test", args);
+  }
 }
 
 TEST(BoringSSL, Base64) {
   TestSimple("base64_test");
 }
 
 TEST(BoringSSL, BIO) {
   TestSimple("bio_test");
 }
 
 TEST(BoringSSL, BN) {
   TestSimple("bn_test");
 }
 
 TEST(BoringSSL, ByteString) {
   TestSimple("bytestring_test");
 }
 
 TEST(BoringSSL, ConstantTime) {
   TestSimple("constant_time_test");
 }
 
 TEST(BoringSSL, Cipher) {
   base::FilePath data_file;
-  ASSERT_TRUE(CryptoCipherPath(&data_file));
+  ASSERT_TRUE(CryptoCipherTestPath(&data_file));
   data_file = data_file.Append(FILE_PATH_LITERAL("cipher_test.txt"));
 
   std::vector<base::CommandLine::StringType> args;
   args.push_back(data_file.value());
 
   TestProcess("cipher_test", args);
 }
 
 TEST(BoringSSL, DH) {
   TestSimple("dh_test");
@@ skipping 55 matching lines @@
   TestSimple("ssl_test");
 }
 
 TEST(BoringSSL, PQueue) {
   TestSimple("pqueue_test");
 }
 
 TEST(BoringSSL, HKDF) {                                                        
   TestSimple("hkdf_test");                                                     
 }