[Autofill] Modernize some AutofillMergeTest

components/autofill/core/browser/autofill_merge_unittest.cc

 // Copyright 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 <stddef.h>
 
 #include <map>
 #include <memory>
 #include <vector>
 
+#include "base/files/file_enumerator.h"
 #include "base/files/file_path.h"
 #include "base/macros.h"
 #include "base/path_service.h"
 #include "base/strings/string_split.h"
 #include "base/strings/string_util.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/autofill_type.h"
 #include "components/autofill/core/browser/country_names.h"
 #include "components/autofill/core/browser/data_driven_test.h"
 #include "components/autofill/core/browser/form_structure.h"
 #include "components/autofill/core/browser/personal_data_manager.h"
 #include "components/autofill/core/common/form_data.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "url/gurl.h"
 
+#if defined(OS_MACOSX)
+#include "base/mac/foundation_util.h"
+#endif
+
 namespace autofill {
 
 namespace {
 
 const base::FilePath::CharType kTestName[] = FILE_PATH_LITERAL("merge");
 const base::FilePath::CharType kFileNamePattern[] = FILE_PATH_LITERAL("*.in");
 
 const char kFieldSeparator[] = ": ";
 const char kProfileSeparator[] = "---";
 const size_t kFieldOffset = arraysize(kFieldSeparator) - 1;
 
-const ServerFieldType kProfileFieldTypes[] = {
-  NAME_FIRST,
-  NAME_MIDDLE,
-  NAME_LAST,
-  EMAIL_ADDRESS,
-  COMPANY_NAME,
-  ADDRESS_HOME_LINE1,
-  ADDRESS_HOME_LINE2,
-  ADDRESS_HOME_CITY,
-  ADDRESS_HOME_STATE,
-  ADDRESS_HOME_ZIP,
-  ADDRESS_HOME_COUNTRY,
-  PHONE_HOME_WHOLE_NUMBER
-};
+const ServerFieldType kProfileFieldTypes[] = {NAME_FIRST,
+                                              NAME_MIDDLE,
+                                              NAME_LAST,
+                                              NAME_FULL,
+                                              EMAIL_ADDRESS,
+                                              COMPANY_NAME,
+                                              ADDRESS_HOME_STREET_ADDRESS,
+                                              ADDRESS_HOME_CITY,
+                                              ADDRESS_HOME_STATE,
+                                              ADDRESS_HOME_ZIP,
+                                              ADDRESS_HOME_COUNTRY,
+                                              PHONE_HOME_WHOLE_NUMBER};
 
 const base::FilePath& GetTestDataDir() {
   CR_DEFINE_STATIC_LOCAL(base::FilePath, dir, ());
   if (dir.empty()) {
     PathService::Get(base::DIR_SOURCE_ROOT, &dir);
     dir = dir.AppendASCII("components");
     dir = dir.AppendASCII("test");
     dir = dir.AppendASCII("data");
   }
   return dir;
 }
 
+const std::vector<base::FilePath> GetTestFiles() {
+  base::FilePath dir = GetTestDataDir();
+  dir = dir.AppendASCII("autofill").AppendASCII("merge").AppendASCII("input");
+  base::FileEnumerator input_files(dir, false, base::FileEnumerator::FILES,
+                                   kFileNamePattern);
+  std::vector<base::FilePath> files;
+  for (base::FilePath input_file = input_files.Next(); !input_file.empty();
+       input_file = input_files.Next()) {
+    files.push_back(input_file);
+  }
+  std::sort(files.begin(), files.end());
+
+#if defined(OS_MACOSX)
+  base::mac::ClearAmIBundledCache();
+#endif  // defined(OS_MACOSX)
+
+  return files;
+}
+
 // Serializes the |profiles| into a string.
 std::string SerializeProfiles(const std::vector<AutofillProfile*>& profiles) {
   std::string result;
   for (size_t i = 0; i < profiles.size(); ++i) {
     result += kProfileSeparator;
     result += "\n";
     for (size_t j = 0; j < arraysize(kProfileFieldTypes); ++j) {
       ServerFieldType type = kProfileFieldTypes[j];
       base::string16 value = profiles[i]->GetRawInfo(type);
       result += AutofillType(type).ToString();
       result += kFieldSeparator;
+      base::ReplaceFirstSubstringAfterOffset(
+          &value, 0, base::ASCIIToUTF16("\n"), base::ASCIIToUTF16("\\n"));
       result += base::UTF16ToUTF8(value);
       result += "\n";
     }
   }
 
   return result;
 }
 
 class PersonalDataManagerMock : public PersonalDataManager {
  public:
@@ skipping 39 matching lines @@
   return profiles_.get();
 }
 
 }  // namespace
 
 // A data-driven test for verifying merging of Autofill profiles. Each input is
 // a structured dump of a set of implicitly detected autofill profiles. The
 // corresponding output file is a dump of the saved profiles that result from
 // importing the input profiles. The output file format is identical to the
 // input format.
-class AutofillMergeTest : public testing::Test,
-                          public DataDrivenTest {
+class AutofillMergeTest : public DataDrivenTest,
+                          public testing::TestWithParam<base::FilePath> {
  protected:
   AutofillMergeTest();
   ~AutofillMergeTest() override;
 
   // testing::Test:
   void SetUp() override;
 
   // DataDrivenTest:
   void GenerateResults(const std::string& input, std::string* output) override;
 
@@ skipping 41 matching lines @@
   FormData form;
   form.name = base::ASCIIToUTF16("MyTestForm");
   form.origin = GURL("https://www.example.com/origin.html");
   form.action = GURL("https://www.example.com/action.html");
 
   // Parse the input line by line.
   std::vector<std::string> lines = base::SplitString(
       profiles, "\n", base::KEEP_WHITESPACE, base::SPLIT_WANT_NONEMPTY);
   for (size_t i = 0; i < lines.size(); ++i) {
     std::string line = lines[i];
-
     if (line != kProfileSeparator) {
       // Add a field to the current profile.
       size_t separator_pos = line.find(kFieldSeparator);
       ASSERT_NE(std::string::npos, separator_pos);
       base::string16 field_type =
           base::UTF8ToUTF16(line.substr(0, separator_pos));
       base::string16 value =
           base::UTF8ToUTF16(line.substr(separator_pos + kFieldOffset));
 
       FormFieldData field;
@@ skipping 32 matching lines @@
     }
   }
 
   *merged_profiles = SerializeProfiles(personal_data_.web_profiles());
 }
 
 ServerFieldType AutofillMergeTest::StringToFieldType(const std::string& str) {
   return string_to_field_type_map_[str];
 }
 
-TEST_F(AutofillMergeTest, DataDrivenMergeProfiles) {
-  RunDataDrivenTest(GetInputDirectory(kTestName), GetOutputDirectory(kTestName),
-                    kFileNamePattern);
+TEST_P(AutofillMergeTest, DataDrivenMergeProfiles) {
+  RunOneDataDrivenTest(GetParam(), GetOutputDirectory(kTestName));
 }
 
+INSTANTIATE_TEST_CASE_P(, AutofillMergeTest, testing::ValuesIn(GetTestFiles()));
+
 }  // namespace autofill