[refactor] Extract some test helpers for certificate verification unittests.

net/cert/internal/verify_name_match_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/verify_name_match.h"
 
-#include "base/base_paths.h"
-#include "base/files/file_path.h"
-#include "base/files/file_util.h"
-#include "base/path_service.h"
 #include "base/strings/string_number_conversions.h"
 #include "base/strings/string_util.h"
-#include "net/cert/pem_tokenizer.h"
+#include "net/cert/internal/test_helpers.h"
 #include "net/der/input.h"
 #include "net/der/parser.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 namespace net {
 namespace {
 
 der::Input SequenceValueFromString(const std::string& s) {

[mattm, 2015/08/12 21:30:26]

Do you want to update this to also take a pointer instead of a reference, or
should I do that in a separate CL?

[eroman, 2015/08/12 21:51:30]

Good point!
I will make that change in this CL.

[eroman, 2015/08/12 22:51:00]

Done.

-  der::Parser parser(
-      der::Input(reinterpret_cast<const uint8_t*>(s.data()), s.size()));
+  der::Parser parser(InputFromString(&s));
   der::Input data;
   if (!parser.ReadTag(der::kSequence, &data)) {
     ADD_FAILURE();
     return der::Input();
   }
   if (parser.HasMore()) {
     ADD_FAILURE();
     return der::Input();
   }
   return data;
 }
 
 // Loads test data from file. The filename is constructed from the parameters:
 // |prefix| describes the type of data being tested, e.g. "ascii",
 // "unicode_bmp", "unicode_supplementary", and "invalid".
 // |value_type| indicates what ASN.1 type is used to encode the data.
 // |suffix| indicates any additional modifications, such as caseswapping,
 // whitespace adding, etc.
 ::testing::AssertionResult LoadTestData(const std::string& prefix,
                                         const std::string& value_type,
                                         const std::string& suffix,
                                         std::string* result) {
-  base::FilePath src_root;
-  PathService::Get(base::DIR_SOURCE_ROOT, &src_root);
-  std::string filename = prefix + "-" + value_type + "-" + suffix + ".pem";
-  base::FilePath filepath =
-      src_root.Append(FILE_PATH_LITERAL(
-                          "net/data/verify_name_match_unittest/names"))
-          .AppendASCII(filename);
-  std::string file_data;
-  if (!base::ReadFileToString(filepath, &file_data)) {
-    return ::testing::AssertionFailure()
-           << "ReadFileToString returned false on " << filename;
-  }
+  std::string path = "net/data/verify_name_match_unittest/names/" + prefix +
+                     "-" + value_type + "-" + suffix + ".pem";
 
-  std::vector<std::string> pem_headers;
-  pem_headers.push_back("NAME");
-  PEMTokenizer pem_tokenizer(file_data, pem_headers);
-  if (!pem_tokenizer.GetNext()) {
-    return ::testing::AssertionFailure() << "PEM.GetNext returned false on "
-                                         << filename;
-  }
+  const PemBlockMapping mappings[] = {
+      {"NAME", result},
+  };
 
-  result->assign(pem_tokenizer.data());
-  return ::testing::AssertionSuccess();
+  return ReadTestDataFromPemFile(path, mappings);
 }
 
 bool TypesAreComparable(const std::string& type_1, const std::string& type_2) {
   if (type_1 == type_2)
     return true;
   if ((type_1 == "PRINTABLESTRING" || type_1 == "UTF8" ||
        type_1 == "BMPSTRING" || type_1 == "UNIVERSALSTRING") &&
       (type_2 == "PRINTABLESTRING" || type_2 == "UTF8" ||
        type_2 == "BMPSTRING" || type_2 == "UNIVERSALSTRING")) {
     return true;
@@ skipping 375 matching lines @@
   ASSERT_TRUE(LoadTestData("ascii", "mixed", "rdn_dupetype_sorting_1", &a));
   std::string b;
   ASSERT_TRUE(LoadTestData("ascii", "mixed", "rdn_dupetype_sorting_2", &b));
   EXPECT_TRUE(
       VerifyNameMatch(SequenceValueFromString(a), SequenceValueFromString(b)));
   EXPECT_TRUE(
       VerifyNameMatch(SequenceValueFromString(b), SequenceValueFromString(a)));
 }
 
 }  // namespace net