Fill in more name fields with requestAutocomplete

components/autofill/core/browser/autofill_profile_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 "base/basictypes.h"
 #include "base/format_macros.h"
 #include "base/guid.h"
 #include "base/memory/scoped_ptr.h"
 #include "base/memory/scoped_vector.h"
 #include "base/stl_util.h"
@@ skipping 52 matching lines @@
 
   std::vector<NameParts> starting_names;
   std::vector<NameParts> additional_names;
   std::vector<NameParts> expected_result;
 };
 
 // Populates |first_names|, |middle_names| and |last_names| from the list of
 // NameParts from |starting_names|, |additional_names| or |expected_result|
 // from the testcase to create and verify the autofill profile.
 void GetNamePartsList(const std::vector<NameParts>& names,
-                      std::vector<base::string16>& first_names,
-                      std::vector<base::string16>& middle_names,
-                      std::vector<base::string16>& last_names) {
+                      std::vector<base::string16>* first_names,
+                      std::vector<base::string16>* middle_names,
+                      std::vector<base::string16>* last_names) {
   for (size_t i = 0; i < names.size(); ++i) {
-    first_names.push_back(ASCIIToUTF16(names[i].first));
-    middle_names.push_back(ASCIIToUTF16(names[i].middle));
-    last_names.push_back(ASCIIToUTF16(names[i].last));
+    first_names->push_back(ASCIIToUTF16(names[i].first));
+    middle_names->push_back(ASCIIToUTF16(names[i].middle));
+    last_names->push_back(ASCIIToUTF16(names[i].last));
   }
 }
 
 }  // namespace
 
 // Tests different possibilities for summary string generation.
 // Based on existence of first name, last name, and address line 1.
 TEST(AutofillProfileTest, PreviewSummaryString) {
   // Case 0/null: ""
   AutofillProfile profile0(base::GenerateGUID(), "https://www.example.com/");
@@ skipping 892 matching lines @@
 
   // A parse that has a two-word first name should take precedence over a
   // parse that assumes the two names are a first and a middle name.
   test_cases.push_back(TestCase(NameParts("Marion", "Mitchell", "Morrison"),
                                 NameParts("Marion Mitchell", "", "Morrison"),
                                 NameParts("Marion Mitchell", "", "Morrison")));
   test_cases.push_back(TestCase(NameParts("Marion Mitchell", "", "Morrison"),
                                 NameParts("Marion", "Mitchell", "Morrison"),
                                 NameParts("Marion Mitchell", "", "Morrison")));
 
-  // A parse that has a two-word first name and two-word last name should
-  // take precedence over a parse that assumes the two middle names and
-  // one last name.
+  // Two names that are identical in full, but not in parts: the parse that
+  // does *not* match the heuristic parse should be preferred.
   test_cases.push_back(
       TestCase(NameParts("Arthur", "Ignatius Conan", "Doyle"),
-               NameParts("Arthur Ignatius", "", "Conan Doyle"),
-               NameParts("Arthur Ignatius", "", "Conan Doyle")));
+               // Heurstic parse.
+               NameParts("Arthur Ignatius", "Conan", "Doyle"),
+               NameParts("Arthur", "Ignatius Conan", "Doyle")));
   test_cases.push_back(
-      TestCase(NameParts("Arthur Ignatius", "", "Conan Doyle"),
+               // Heuristic parse.
+      TestCase(NameParts("Arthur Ignatius", "Conan", "Doyle"),
                NameParts("Arthur", "Ignatius Conan", "Doyle"),
-               NameParts("Arthur Ignatius", "", "Conan Doyle")));
+               NameParts("Arthur", "Ignatius Conan", "Doyle")));
 
   // A parse that has a many-word first name and/or last name should take
-  // precedence over a heuristically parsed name into {first, middle1
-  // middle2.. middlen, name}.
+  // precedence over a heuristically parsed name.
   test_cases.push_back(
-      TestCase(NameParts("Arthur Ignatius Conan", "", "Doyle"),
-               NameParts("Arthur", "Ignatius Conan", "Doyle"),
-               NameParts("Arthur Ignatius Conan", "", "Doyle")));
-  test_cases.push_back(
-      TestCase(NameParts("Roberto", "Carlos da Silva", "Rocha"),
+               // Heuristic parse.
+      TestCase(NameParts("Roberto Carlos da", "Silva", "Rocha"),
                NameParts("Roberto Carlos da Silva", "", "Rocha"),
                NameParts("Roberto Carlos da Silva", "", "Rocha")));
-  test_cases.push_back(
-      TestCase(NameParts("Antonio", "Augusto", "Ribeiro Reis Jr."),
-               NameParts("Antonio", "Augusto Ribeiro Reis", "Jr."),
-               NameParts("Antonio", "Augusto", "Ribeiro Reis Jr.")));
 
   // Cases where merging 2 profiles with same full names but
   // different canonical forms appends instead of overwrites,
   // provided they dont form heuristically parsed names.
   {
     NameParts name1("Marion Mitchell", "", "Morrison");
     NameParts name2("Marion", "", "Mitchell Morrison");
     std::vector<NameParts> starting_names(1, name1);
     std::vector<NameParts> additional_names(1, name2);
     std::vector<NameParts> expected_result;
@@ skipping 23 matching lines @@
     expected_result.push_back(name3);
     expected_result.push_back(name4);
     test_cases.push_back(
         TestCase(starting_names, additional_names, expected_result));
   }
 
   for (std::vector<TestCase>::iterator it = test_cases.begin();
        it != test_cases.end();
        ++it) {
     TestCase current_case = *it;
+    SCOPED_TRACE(current_case.starting_names[0].first + " + " +
+                 current_case.additional_names[0].first + " = " +
+                 current_case.expected_result[0].first);
 
     std::vector<base::string16> first_names, middle_names, last_names;
     GetNamePartsList(
-        current_case.starting_names, first_names, middle_names, last_names);
+        current_case.starting_names, &first_names, &middle_names, &last_names);
 
     // Construct the starting_profile.
     AutofillProfile starting_profile(base::GenerateGUID(),
                                      "https://www.example.com/");
 
     starting_profile.SetRawMultiInfo(NAME_FIRST, first_names);
     starting_profile.SetRawMultiInfo(NAME_MIDDLE, middle_names);
     starting_profile.SetRawMultiInfo(NAME_LAST, last_names);
 
     first_names.clear();
     middle_names.clear();
     last_names.clear();
     GetNamePartsList(
-        current_case.additional_names, first_names, middle_names, last_names);
+        current_case.additional_names, &first_names, &middle_names,
+        &last_names);
 
     // Construct the additional_profile.
     AutofillProfile additional_profile(base::GenerateGUID(),
                                        "https://www.example.com/");
     additional_profile.SetRawMultiInfo(NAME_FIRST, first_names);
     additional_profile.SetRawMultiInfo(NAME_MIDDLE, middle_names);
     additional_profile.SetRawMultiInfo(NAME_LAST, last_names);
 
     // Merge the names from the |additional_profile| into the |starting_profile|
     starting_profile.OverwriteWithOrAddTo(additional_profile, "en-US");
 
     // Verify the test expectations.
     first_names.clear();
     middle_names.clear();
     last_names.clear();
     GetNamePartsList(
-        current_case.expected_result, first_names, middle_names, last_names);
+        current_case.expected_result, &first_names, &middle_names, &last_names);
 
     std::vector<base::string16> merged_first_names, merged_middle_names,
         merged_last_names;
     starting_profile.GetRawMultiInfo(NAME_FIRST, &merged_first_names);
     starting_profile.GetRawMultiInfo(NAME_MIDDLE, &merged_middle_names);
     starting_profile.GetRawMultiInfo(NAME_LAST, &merged_last_names);
     ASSERT_EQ(current_case.expected_result.size(), merged_first_names.size());
     ASSERT_EQ(current_case.expected_result.size(), merged_middle_names.size());
     ASSERT_EQ(current_case.expected_result.size(), merged_last_names.size());
 
     for (size_t i = 0; i < current_case.expected_result.size(); ++i) {
       EXPECT_EQ(first_names[i], merged_first_names[i]);
       EXPECT_EQ(middle_names[i], merged_middle_names[i]);
       EXPECT_EQ(last_names[i], merged_last_names[i]);
     }
   }
 }
 
 }  // namespace autofill