Convert tests that parse an Extension value to instead

net/cert/internal/parse_certificate_unittest.cc

 // Copyright 2015 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/cert/internal/parse_certificate.h"
 
 #include "base/strings/stringprintf.h"
 #include "net/cert/internal/cert_errors.h"
 // TODO(eroman): These tests should be moved into
 //               parsed_certificate_unittest.cc; this include dependency should
@@ skipping 344 matching lines @@
 TEST(ParseTbsCertificateTest, ValidityGeneralizedTimeAndUTCTime) {
   RunTbsCertificateTest("tbs_validity_generalized_time_and_utc_time.pem");
 }
 
 // Parses a TBSCertificate whose "validity" field does not strictly follow
 // the DER rules (and fails to be parsed).
 TEST(ParseTbsCertificateTest, ValidityRelaxed) {
   RunTbsCertificateTest("tbs_validity_relaxed.pem");
 }
 
-// Reads a PEM file containing a block "EXTENSION". This input will be
-// passed to ParseExtension, and the results filled in |out|.
-bool ParseExtensionFromFile(const std::string& file_name,
-                            ParsedExtension* out,
-                            std::string* data) {
-  const PemBlockMapping mappings[] = {
-      {"EXTENSION", data},
-  };
-
-  EXPECT_TRUE(ReadTestDataFromPemFile(GetFilePath(file_name), mappings));
-  return ParseExtension(der::Input(data), out);
+der::Input DavidBenOid() {
+  // This OID corresponds with
+  // 1.2.840.113554.4.1.72585.0 (https://davidben.net/oid)
+  static const uint8_t kOid[] = {0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12,
+                                 0x04, 0x01, 0x84, 0xb7, 0x09, 0x00};
+  return der::Input(kOid);
 }
 
 // Parses an Extension whose critical field is true (255).
-TEST(ParseExtensionTest, Critical) {
-  std::string data;
-  ParsedExtension extension;
-  ASSERT_TRUE(
-      ParseExtensionFromFile("extension_critical.pem", &extension, &data));
+TEST(ParseCertificateTest, ExtensionCritical) {
+  scoped_refptr<ParsedCertificate> cert =
+      ParseCertificateFromFile("extension_critical.pem");
+  ASSERT_TRUE(cert);
+
+  const uint8_t kExpectedValue[] = {0x30, 0x00};
+
+  auto it = cert->unparsed_extensions().find(DavidBenOid());
+  ASSERT_NE(cert->unparsed_extensions().end(), it);
+  const auto& extension = it->second;
 
   EXPECT_TRUE(extension.critical);
-
-  const uint8_t kExpectedOid[] = {0x55, 0x1d, 0x13};
-  EXPECT_EQ(der::Input(kExpectedOid), extension.oid);
-
-  const uint8_t kExpectedValue[] = {0x30, 0x00};
+  EXPECT_EQ(DavidBenOid(), extension.oid);
   EXPECT_EQ(der::Input(kExpectedValue), extension.value);
 }
 
 // Parses an Extension whose critical field is false (omitted).
-TEST(ParseExtensionTest, NotCritical) {
-  std::string data;
-  ParsedExtension extension;
-  ASSERT_TRUE(
-      ParseExtensionFromFile("extension_not_critical.pem", &extension, &data));
+TEST(ParseCertificateTest, ExtensionNotCritical) {
+  scoped_refptr<ParsedCertificate> cert =
+      ParseCertificateFromFile("extension_not_critical.pem");
+  ASSERT_TRUE(cert);
+
+  const uint8_t kExpectedValue[] = {0x30, 0x00};
+
+  auto it = cert->unparsed_extensions().find(DavidBenOid());
+  ASSERT_NE(cert->unparsed_extensions().end(), it);
+  const auto& extension = it->second;
 
   EXPECT_FALSE(extension.critical);
-
-  const uint8_t kExpectedOid[] = {0x55, 0x1d, 0x13};
-  EXPECT_EQ(der::Input(kExpectedOid), extension.oid);
-
-  const uint8_t kExpectedValue[] = {0x30, 0x00};
+  EXPECT_EQ(DavidBenOid(), extension.oid);
   EXPECT_EQ(der::Input(kExpectedValue), extension.value);
 }
 
 // Parses an Extension whose critical field is 0. This is in one sense FALSE,
 // however because critical has DEFAULT of false this is in fact invalid
 // DER-encoding.
-TEST(ParseExtensionTest, Critical0) {
-  std::string data;
-  ParsedExtension extension;
-  ASSERT_FALSE(
-      ParseExtensionFromFile("extension_critical_0.pem", &extension, &data));
+TEST(ParseCertificateTest, ExtensionCritical0) {
+  ASSERT_FALSE(ParseCertificateFromFile("extension_critical_0.pem"));
 }
 
 // Parses an Extension whose critical field is 3. Under DER-encoding BOOLEAN
 // values must an octet of either all zero bits, or all 1 bits, so this is not
 // valid.
-TEST(ParseExtensionTest, Critical3) {
-  std::string data;
-  ParsedExtension extension;
-  ASSERT_FALSE(
-      ParseExtensionFromFile("extension_critical_3.pem", &extension, &data));
+TEST(ParseCertificateTest, ExtensionCritical3) {
+  ASSERT_FALSE(ParseCertificateFromFile("extension_critical_3.pem"));
 }
 
 // Runs a test for extensions parsing. The input file is a PEM file which
 // contains a DER-encoded Extensions sequence, as well as the expected value
 // for each contained extension.
 void EnsureParsingExtensionsSucceeds(
     const std::string& file_name,
     std::map<der::Input, ParsedExtension>* extensions,
     std::string* data) {
   const PemBlockMapping mappings[] = {
@@ skipping 40 matching lines @@
 }
 
 // Parses an Extensions that contains an unknown critical extension.
 TEST(ParseExtensionsTest, UnknownCritical) {
   std::string data;
   std::map<der::Input, ParsedExtension> extensions;
   EnsureParsingExtensionsSucceeds("extensions_unknown_critical.pem",
                                   &extensions, &data);
 
   ASSERT_EQ(1u, extensions.size());
-  // This OID corresponds with
-  // 1.2.840.113554.4.1.72585.0 (https://davidben.net/oid)
-  const uint8_t oid[] = {0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12,
-                         0x04, 0x01, 0x84, 0xb7, 0x09, 0x00};
-
-  auto iter = extensions.find(der::Input(oid));
+  auto iter = extensions.find(DavidBenOid());
   ASSERT_TRUE(iter != extensions.end());
   EXPECT_TRUE(iter->second.critical);
   EXPECT_EQ(4u, iter->second.value.Length());
 }
 
 // Parses an Extensions that contains an unknown non-critical extension.
 TEST(ParseExtensionsTest, UnknownNonCritical) {
   std::string data;
   std::map<der::Input, ParsedExtension> extensions;
   EnsureParsingExtensionsSucceeds("extensions_unknown_non_critical.pem",
                                   &extensions, &data);
 
   ASSERT_EQ(1u, extensions.size());
-  // This OID corresponds with
-  // 1.2.840.113554.4.1.72585.0 (https://davidben.net/oid)
-  const uint8_t oid[] = {0x2a, 0x86, 0x48, 0x86, 0xf7, 0x12,
-                         0x04, 0x01, 0x84, 0xb7, 0x09, 0x00};
-
-  auto iter = extensions.find(der::Input(oid));
+  auto iter = extensions.find(DavidBenOid());
   ASSERT_TRUE(iter != extensions.end());
   EXPECT_FALSE(iter->second.critical);
   EXPECT_EQ(4u, iter->second.value.Length());
 }
 
 // Parses an Extensions that contains a basic constraints.
 TEST(ParseExtensionsTest, BasicConstraints) {
   std::string data;
   std::map<der::Input, ParsedExtension> extensions;
   EnsureParsingExtensionsSucceeds("extensions_basic_constraints.pem",
@@ skipping 289 matching lines @@
       0x00,        // Number of unused bits
   };
 
   der::BitString key_usage;
   ASSERT_FALSE(ParseKeyUsage(der::Input(der), &key_usage));
 }
 
 }  // namespace
 
 }  // namespace net