Modified to allow to preserve two-word string in first-name and last-name in autofill profile.

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"
 #include "base/strings/string16.h"
+#include "base/strings/stringprintf.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/autofill_profile.h"
 #include "components/autofill/core/browser/autofill_test_utils.h"
 #include "components/autofill/core/browser/autofill_type.h"
+#include "components/autofill/core/browser/field_types.h"
 #include "components/autofill/core/common/form_field_data.h"
 #include "grit/components_strings.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 
 namespace autofill {
 
 namespace {
 
@@ skipping 866 matching lines @@
   profile.SetInfo(AutofillType(ADDRESS_HOME_STATE),
                                ASCIIToUTF16("CA"),
                                "en-US");
   EXPECT_FALSE(profile.GetInfo(full_address, "en-US").empty());
   profile.SetInfo(AutofillType(ADDRESS_HOME_COUNTRY),
                                base::string16(),
                                "en-US");
   EXPECT_TRUE(profile.GetInfo(full_address, "en-US").empty());
 }
 
+TEST(AutofillProfileTest, OverwriteOrAppendNames) {
+  struct TestCase {
+    std::string starting_names[3];
+    std::string additional_names[3];
+    std::string expected_result[3];
+  };
+
+  struct TestCase test_cases[] = {
+      // Identical name.
+      {{"Marion", "Mitchell", "Morrison"},
+       {"Marion", "Mitchell", "Morrison"},
+       {"Marion", "Mitchell", "Morrison"}},
+
+      // A parse that has a two-word last name should take precedence over a
+      // parse that assumes the two names are a middle and a last name.
+      {{"Marion", "Mitchell", "Morrison"},
+       {"Marion", "", "Mitchell Morrison"},
+       {"Marion", "", "Mitchell Morrison"}},
+      {{"Marion", "", "Mitchell Morrison"},
+       {"Marion", "Mitchell", "Morrison"},
+       {"Marion", "", "Mitchell Morrison"}},
+
+      // 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.
+      {{"Marion", "Mitchell", "Morrison"},
+       {"Marion Mitchell", "", "Morrison"},
+       {"Marion Mitchell", "", "Morrison"}},
+      {{"Marion Mitchell", "", "Morrison"},
+       {"Marion", "Mitchell", "Morrison"},
+       {"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.
+      {{"Arthur", "Ignatius Conan", "Doyle"},
+       {"Arthur Ignatius", "", "Conan Doyle"},
+       {"Arthur Ignatius", "", "Conan Doyle"}},
+      {{"Arthur Ignatius", "", "Conan Doyle"},
+       {"Arthur", "Ignatius Conan", "Doyle"},
+       {"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}.
+      {{"Arthur Ignatius Conan", "", "Doyle"},
+       {"Arthur", "Ignatius Conan", "Doyle"},
+       {"Arthur Ignatius Conan", "", "Doyle"}},
+      {{"Roberto", "Carlos da Silva", "Rocha"},
+       {"Roberto Carlos da Silva", "", "Rocha"},
+       {"Roberto Carlos da Silva", "", "Rocha"}},
+      {{"Antonio", "Augusto", "Ribeiro Reis Jr."},
+       {"Antonio", "Augusto Ribeiro Reis ", "Jr."},
+       {"Antonio", "Augusto", "Ribeiro Reis Jr."}},
+  };
+
+  for (size_t i = 0; i < ARRAYSIZE_UNSAFE(test_cases); ++i) {
+    SCOPED_TRACE(base::StringPrintf("i: %" PRIuS, i));
+
+    // Construct the starting_profile.
+    AutofillProfile starting_profile(base::GenerateGUID(),
+                                     "https://www.example.com/");
+    starting_profile.SetRawInfo(NAME_FIRST,
+                                ASCIIToUTF16(test_cases[i].starting_names[0]));
+    starting_profile.SetRawInfo(NAME_MIDDLE,
+                                ASCIIToUTF16(test_cases[i].starting_names[1]));
+    starting_profile.SetRawInfo(NAME_LAST,
+                                ASCIIToUTF16(test_cases[i].starting_names[2]));
+
+    // Construct the additional_profile.
+    AutofillProfile additional_profile(base::GenerateGUID(),
+                                       "https://www.example.com/");
+    additional_profile.SetRawInfo(
+        NAME_FIRST, ASCIIToUTF16(test_cases[i].additional_names[0]));
+    additional_profile.SetRawInfo(
+        NAME_MIDDLE, ASCIIToUTF16(test_cases[i].additional_names[1]));
+    additional_profile.SetRawInfo(
+        NAME_LAST, ASCIIToUTF16(test_cases[i].additional_names[2]));
+
+    // Merge the names from the |additional_profile| into the |starting_profile|
+    starting_profile.OverwriteWithOrAddTo(additional_profile, "en-US");
+
+    // Verify the test expectations.
+    EXPECT_EQ(starting_profile.GetRawInfo(NAME_FIRST),
+              ASCIIToUTF16(test_cases[i].expected_result[0]));
+    EXPECT_EQ(starting_profile.GetRawInfo(NAME_MIDDLE),
+              ASCIIToUTF16(test_cases[i].expected_result[1]));
+    EXPECT_EQ(starting_profile.GetRawInfo(NAME_LAST),
+              ASCIIToUTF16(test_cases[i].expected_result[2]));
+  }
+
+  // Cases where merging 2 profiles with same fullnames but
+  // different canonical forms appends instead of overwrites,
+  // provided they dont form heuristically parsed names.
+  {
+    // Construct the starting_profile.
+    AutofillProfile starting_profile(base::GenerateGUID(),
+                                     "https://www.example.com/");
+    starting_profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Marion Mitchell"));
+    starting_profile.SetRawInfo(NAME_LAST, ASCIIToUTF16("Morrison"));
+
+    // Construct the additional_profile.
+    AutofillProfile additional_profile(base::GenerateGUID(),
+                                       "https://www.example.com/");
+    additional_profile.SetRawInfo(NAME_FIRST, ASCIIToUTF16("Marion"));
+    additional_profile.SetRawInfo(NAME_LAST, ASCIIToUTF16("Mitchell Morrison"));
+
+    EXPECT_EQ(starting_profile.GetRawInfo(NAME_FULL),
+              additional_profile.GetRawInfo(NAME_FULL));
+
+    // Merge the names from the |additional_profile| into the |starting_profile|
+    starting_profile.OverwriteWithOrAddTo(additional_profile, "en-US");
+
+    std::vector<base::string16> first_names, last_names;
+    starting_profile.GetRawMultiInfo(NAME_FIRST, &first_names);
+    starting_profile.GetRawMultiInfo(NAME_LAST, &last_names);
+    ASSERT_EQ(2U, first_names.size());
+    ASSERT_EQ(2U, last_names.size());
+    EXPECT_EQ(ASCIIToUTF16("Marion Mitchell"), first_names[0]);
+    EXPECT_EQ(ASCIIToUTF16("Marion"), first_names[1]);
+    EXPECT_EQ(ASCIIToUTF16("Morrison"), last_names[0]);
+    EXPECT_EQ(ASCIIToUTF16("Mitchell Morrison"), last_names[1]);
+  }
+
+  // Cases where the names do not have the same full name strings,
+  // i.e. the list of merged names is longer than either of the incoming
+  // lists.
+  {
+    // Construct the starting_profile.
+    AutofillProfile starting_profile(base::GenerateGUID(),
+                                     "https://www.example.com/");
+
+    std::vector<base::string16> names;
+    names.push_back(ASCIIToUTF16("Antonio Augusto Ribeiro Reis Jr."));
+    names.push_back(ASCIIToUTF16("Juninho Pernambucano"));
+    starting_profile.SetRawMultiInfo(NAME_FULL, names);
+    names.clear();
+
+    // Construct the additional_profile.
+    AutofillProfile additional_profile(base::GenerateGUID(),
+                                       "https://www.example.com/");
+    names.push_back(ASCIIToUTF16("Marion Mitchell Morrison"));
+    names.push_back(ASCIIToUTF16("Marion M. Morrison"));
+    additional_profile.SetRawMultiInfo(NAME_FULL, names);
+    names.clear();
+
+    // Merge the names from the |additional_profile| into the |starting_profile|
+    starting_profile.OverwriteWithOrAddTo(additional_profile, "en-US");
+
+    starting_profile.GetRawMultiInfo(NAME_FULL, &names);
+    ASSERT_EQ(4U, names.size());
+    EXPECT_EQ(ASCIIToUTF16("Antonio Augusto Ribeiro Reis Jr."), names[0]);
+    EXPECT_EQ(ASCIIToUTF16("Juninho Pernambucano"), names[1]);
+    EXPECT_EQ(ASCIIToUTF16("Marion Mitchell Morrison"), names[2]);
+    EXPECT_EQ(ASCIIToUTF16("Marion M. Morrison"), names[3]);
+  }

[Ilya Sherman, 2014/06/03 22:09:52]

Please include these in the list of cases at the top of the test, by using
multi-dimensional arrays as I previously suggested.

[Pritam Nikam, 2014/06/04 06:54:44]

As i understand adding multiple-name in starting & additional name in a single
statically defined array won't be possible. And instead I have to define these
structure case-by-case basis and keep a separate array of test-cases.

Likewise, starting_names - 2, additional_names - 2, expected_result - 2/3/4
struct TestCase {
 std::string starting_names[2][3];
 std::string additional_names[2][3];
 std::string expected_result[4][3]; <-- 2 or 3 or 4
};

starting_names - 1, additional_names - 2, expected_result - 2/3
struct TestCase {
 std::string starting_names[3];
 std::string additional_names[2][3];
 std::string expected_result[3][3];  <-- 2 or 3
};

Dynamically it will be possible, but then we have add logic to populate
test-cases on case-by-case basis, isn't it? or didn't comprehend it correctly.
Please correct my understanding.

[Ilya Sherman, 2014/06/04 22:38:27]

Hmm, it looks like you're right that there's no way to do this prior to C++11,
which we can't use yet in Chromium code.  Bummer!

However, we can still use std::vector for a similar effect; it's just a little
clunkier.  Specifically, you could do something like this:

  struct NameParts {
    NameParts(const std::string& first,
              const std::string& middle,
              const std::string& last)
        : first(first), middle(middle), last(last) {}
    
    std::string first;
    std::string middle;
    std::string last;
  };
  struct TestCase {
    TestCase(const NameParts& starting_name,
             const NameParts& additional_name,
             const NameParts& expected_result)
        : starting_names(std::vector<NameParts>(1, starting_name)),
          additional_names(std::vector<NameParts>(1, additional_name)),
          expected_result(std::vector<NameParts>(1, expected_result)) {}
    TestCase(const std::vector<NameParts>& starting_names,
             const std::vector<NameParts>& additional_names,
             const std::vector<NameParts>& expected_result)
        : starting_names(starting_names),
          additional_names(additional_names),
          expected_result(expected_result) {}
    
    std::vector<NameParts> starting_names;
    std::vector<NameParts> additional_names;
    std::vector<NameParts> expected_result;
  };

  std::vector<TestCase> test_cases;

  // Identical name.
  test_cases.push_back(TestCase(NameParts("Marion", "Mitchell", "Morrison"),
                                NameParts("Marion", "Mitchell", "Morrison"),
                                NameParts("Marion", "Mitchell", "Morrison")));
  
  // A parse that has a two-word last name should take precedence over a
  // parse that assumes the two names are a middle and a last 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")));

[Pritam Nikam, 2014/06/07 06:25:12]

Done.

+}
+
 }  // namespace autofill