Refactor der::Input helper methods into new constructors

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/test_helpers.h"
 #include "net/der/input.h"
 #include "testing/gtest/include/gtest/gtest.h"
@@ skipping 28 matching lines @@
   const PemBlockMapping mappings[] = {
       {"CERTIFICATE", &data},
       {"SIGNATURE", &expected_signature},
       {"SIGNATURE ALGORITHM", &expected_signature_algorithm},
       {"TBS CERTIFICATE", &expected_tbs_certificate},
   };
   ASSERT_TRUE(ReadTestDataFromPemFile(GetFilePath(file_name), mappings));
 
   // Parsing the certificate should succeed.
   ParsedCertificate parsed;
-  ASSERT_TRUE(ParseCertificate(InputFromString(&data), &parsed));
+  ASSERT_TRUE(ParseCertificate(der::Input(&data), &parsed));
 
   // Ensure that the ParsedCertificate matches expectations.
   EXPECT_EQ(0, parsed.signature_value.unused_bits());
-  EXPECT_EQ(InputFromString(&expected_signature),
-            parsed.signature_value.bytes());
-  EXPECT_EQ(InputFromString(&expected_signature_algorithm),
+  EXPECT_EQ(der::Input(&expected_signature), parsed.signature_value.bytes());
+  EXPECT_EQ(der::Input(&expected_signature_algorithm),
             parsed.signature_algorithm_tlv);
-  EXPECT_EQ(InputFromString(&expected_tbs_certificate),
-            parsed.tbs_certificate_tlv);
+  EXPECT_EQ(der::Input(&expected_tbs_certificate), parsed.tbs_certificate_tlv);
 }
 
 // Loads certificate data from the PEM file |file_name| and verifies that the
 // Certificate parsing fails.
 void EnsureParsingCertificateFails(const std::string& file_name) {
   std::string data;
 
   const PemBlockMapping mappings[] = {
       {"CERTIFICATE", &data},
   };
 
   ASSERT_TRUE(ReadTestDataFromPemFile(GetFilePath(file_name), mappings));
 
   // Parsing the Certificate should fail.
   ParsedCertificate parsed;
-  ASSERT_FALSE(ParseCertificate(InputFromString(&data), &parsed));
+  ASSERT_FALSE(ParseCertificate(der::Input(&data), &parsed));
 }
 
 // Tests parsing a Certificate.
 TEST(ParseCertificateTest, Version3) {
   EnsureParsingCertificateSucceeds("cert_version3.pem");
 }
 
 // Tests parsing a simplified Certificate-like structure (the sub-fields for
 // algorithm and tbsCertificate are not actually valid, but ParseCertificate()
 // doesn't check them)
@@ skipping 61 matching lines @@
       {"SUBJECT", &expected_subject},
       {"SPKI", &expected_spki},
       {"ISSUER UNIQUE ID", &expected_issuer_unique_id, true},
       {"SUBJECT UNIQUE ID", &expected_subject_unique_id, true},
       {"EXTENSIONS", &expected_extensions, true},
   };
   ASSERT_TRUE(ReadTestDataFromPemFile(GetFilePath(file_name), mappings));
 
   // Parsing the TBSCertificate should succeed.
   ParsedTbsCertificate parsed;
-  ASSERT_TRUE(ParseTbsCertificate(InputFromString(&data), &parsed));
+  ASSERT_TRUE(ParseTbsCertificate(der::Input(&data), &parsed));
 
   // Ensure that the ParsedTbsCertificate matches expectations.
   EXPECT_EQ(expected_version, parsed.version);
 
-  EXPECT_EQ(InputFromString(&expected_serial_number), parsed.serial_number);
-  EXPECT_EQ(InputFromString(&expected_signature_algorithm),
+  EXPECT_EQ(der::Input(&expected_serial_number), parsed.serial_number);
+  EXPECT_EQ(der::Input(&expected_signature_algorithm),
             parsed.signature_algorithm_tlv);
 
-  EXPECT_EQ(InputFromString(&expected_issuer), parsed.issuer_tlv);
+  EXPECT_EQ(der::Input(&expected_issuer), parsed.issuer_tlv);
 
   // In the test expectations PEM file, validity is described as a
   // textual string of the parsed value (rather than as DER).
   EXPECT_EQ(expected_validity_not_before, ToString(parsed.validity_not_before));
   EXPECT_EQ(expected_validity_not_after, ToString(parsed.validity_not_after));
 
-  EXPECT_EQ(InputFromString(&expected_subject), parsed.subject_tlv);
-  EXPECT_EQ(InputFromString(&expected_spki), parsed.spki_tlv);
+  EXPECT_EQ(der::Input(&expected_subject), parsed.subject_tlv);
+  EXPECT_EQ(der::Input(&expected_spki), parsed.spki_tlv);
 
-  EXPECT_EQ(InputFromString(&expected_issuer_unique_id),
+  EXPECT_EQ(der::Input(&expected_issuer_unique_id),
             parsed.issuer_unique_id.bytes());
   EXPECT_EQ(!expected_issuer_unique_id.empty(), parsed.has_issuer_unique_id);
-  EXPECT_EQ(InputFromString(&expected_subject_unique_id),
+  EXPECT_EQ(der::Input(&expected_subject_unique_id),
             parsed.subject_unique_id.bytes());
   EXPECT_EQ(!expected_subject_unique_id.empty(), parsed.has_subject_unique_id);
 
-  EXPECT_EQ(InputFromString(&expected_extensions), parsed.extensions_tlv);
+  EXPECT_EQ(der::Input(&expected_extensions), parsed.extensions_tlv);
   EXPECT_EQ(!expected_extensions.empty(), parsed.has_extensions);
 }
 
 // Loads certificate data from the PEM file |file_name| and verifies that the
 // Certificate parsing succeed, however the TBSCertificate parsing fails.
 void EnsureParsingTbsFails(const std::string& file_name) {
   std::string data;
 
   const PemBlockMapping mappings[] = {
       {"TBS CERTIFICATE", &data},
   };
 
   ASSERT_TRUE(ReadTestDataFromPemFile(GetFilePath(file_name), mappings));
 
   // Parsing the TBSCertificate should fail.
   ParsedTbsCertificate parsed;
-  ASSERT_FALSE(ParseTbsCertificate(InputFromString(&data), &parsed));
+  ASSERT_FALSE(ParseTbsCertificate(der::Input(&data), &parsed));
 }
 
 // Tests parsing a TBSCertificate for v3 that contains no optional fields.
 TEST(ParseTbsCertificateTest, Version3NoOptionals) {
   EnsureParsingTbsSucceeds("tbs_v3_no_optionals.pem", CertificateVersion::V3);
 }
 
 // Tests parsing a TBSCertificate for v3 that contains extensions.
 TEST(ParseTbsCertificateTest, Version3WithExtensions) {
   EnsureParsingTbsSucceeds("tbs_v3_extensions.pem", CertificateVersion::V3);
@@ skipping 119 matching lines @@
 // 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(InputFromString(data), out);
+  return ParseExtension(der::Input(data), out);
 }
 
 // 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));
 
   EXPECT_TRUE(extension.critical);
@@ skipping 47 matching lines @@
 void EnsureParsingExtensionsSucceeds(
     const std::string& file_name,
     std::map<der::Input, ParsedExtension>* extensions,
     std::string* data) {
   const PemBlockMapping mappings[] = {
       // Test Input.
       {"EXTENSIONS", data},
   };
 
   ASSERT_TRUE(ReadTestDataFromPemFile(GetFilePath(file_name), mappings));
-  ASSERT_TRUE(ParseExtensions(InputFromString(data), extensions));
+  ASSERT_TRUE(ParseExtensions(der::Input(data), extensions));
 }
 
 // Runs a test that verifies extensions parsing fails. The input file is a PEM
 // file which contains a DER-encoded Extensions sequence.
 void EnsureParsingExtensionsFails(const std::string& file_name) {
   std::string data;
 
   const PemBlockMapping mappings[] = {
       {"EXTENSIONS", &data},
   };
 
   std::map<der::Input, ParsedExtension> extensions;
   ASSERT_TRUE(ReadTestDataFromPemFile(GetFilePath(file_name), mappings));
-  ASSERT_FALSE(ParseExtensions(InputFromString(&data), &extensions));
+  ASSERT_FALSE(ParseExtensions(der::Input(&data), &extensions));
 }
 
 // Parses an Extensions that is an empty sequence.
 TEST(ParseExtensionsTest, EmptySequence) {
   EnsureParsingExtensionsFails("extensions_empty_sequence.pem");
 }
 
 // Parses an Extensions that is not a sequence.
 TEST(ParseExtensionsTest, NotSequence) {
   EnsureParsingExtensionsFails("extensions_not_sequence.pem");
@@ skipping 152 matching lines @@
 // Reads a PEM file containing a block "BASIC CONSTRAINTS". This input will
 // be passed to ParseExtension, and the results filled in |out|.
 bool ParseBasicConstraintsFromFile(const std::string& file_name,
                                    ParsedBasicConstraints* out) {
   std::string data;
   const PemBlockMapping mappings[] = {
       {"BASIC CONSTRAINTS", &data},
   };
 
   EXPECT_TRUE(ReadTestDataFromPemFile(GetFilePath(file_name), mappings));
-  return ParseBasicConstraints(InputFromString(&data), out);
+  return ParseBasicConstraints(der::Input(&data), out);
 }
 
 // Parses a BasicConstraints with no CA or pathlen.
 TEST(ParseBasicConstraintsTest, NotCa) {
   ParsedBasicConstraints constraints;
   ASSERT_TRUE(ParseBasicConstraintsFromFile("basic_constraints_not_ca.pem",
                                             &constraints));
   EXPECT_FALSE(constraints.is_ca);
   EXPECT_FALSE(constraints.has_path_len);
 }
@@ skipping 178 matching lines @@
       0x00,        // Number of unused bits
   };
 
   der::BitString key_usage;
   ASSERT_FALSE(ParseKeyUsage(der::Input(der), &key_usage));
 }
 
 }  // namespace
 
 }  // namespace net