| // Copyright 2016 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 "components/autofill/core/browser/autofill_profile_comparator.h" |
| |
| #include "base/guid.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/contact_info.h" |
| #include "components/autofill/core/browser/country_names.h" |
| #include "components/autofill/core/browser/field_types.h" |
| #include "testing/gtest/include/gtest/gtest.h" |
| |
| // Field Type Constants |
| using autofill::ADDRESS_HOME_CITY; |
| using autofill::ADDRESS_HOME_COUNTRY; |
| using autofill::ADDRESS_HOME_DEPENDENT_LOCALITY; |
| using autofill::ADDRESS_HOME_LINE1; |
| using autofill::ADDRESS_HOME_LINE2; |
| using autofill::ADDRESS_HOME_LINE3; |
| using autofill::ADDRESS_HOME_SORTING_CODE; |
| using autofill::ADDRESS_HOME_STATE; |
| using autofill::ADDRESS_HOME_STREET_ADDRESS; |
| using autofill::ADDRESS_HOME_ZIP; |
| using autofill::COMPANY_NAME; |
| using autofill::EMAIL_ADDRESS; |
| using autofill::NAME_FIRST; |
| using autofill::NAME_FULL; |
| using autofill::NAME_LAST; |
| using autofill::NAME_MIDDLE; |
| using autofill::PHONE_HOME_WHOLE_NUMBER; |
| using autofill::PHONE_HOME_EXTENSION; |
| using autofill::PHONE_HOME_NUMBER; |
| using autofill::PHONE_HOME_CITY_CODE; |
| using autofill::PHONE_HOME_COUNTRY_CODE; |
| using autofill::PHONE_HOME_CITY_AND_NUMBER; |
| |
| // Classes, Functions, and other Symbols |
| using autofill::Address; |
| using autofill::AutofillProfile; |
| using autofill::AutofillType; |
| using autofill::CompanyInfo; |
| using autofill::EmailInfo; |
| using autofill::NameInfo; |
| using autofill::PhoneNumber; |
| using autofill::ServerFieldType; |
| using base::UTF8ToUTF16; |
| |
| namespace { |
| |
| const char kLocale[] = "en-US"; |
| |
| class AutofillProfileComparatorTest : public ::testing::Test { |
| public: |
| // Expose the protected methods of autofill::AutofillProfileComparator for |
| // testing. |
| class AutofillProfileComparator |
| : public ::autofill::AutofillProfileComparator { |
| public: |
| typedef ::autofill::AutofillProfileComparator Super; |
| using Super::Super; |
| using Super::UniqueTokens; |
| using Super::CompareTokens; |
| using Super::GetNamePartVariants; |
| using Super::IsNameVariantOf; |
| using Super::HaveMergeableNames; |
| using Super::HaveMergeableEmailAddresses; |
| using Super::HaveMergeableCompanyNames; |
| using Super::HaveMergeablePhoneNumbers; |
| using Super::HaveMergeableAddresses; |
| |
| using Super::DIFFERENT_TOKENS; |
| using Super::SAME_TOKENS; |
| using Super::S1_CONTAINS_S2; |
| using Super::S2_CONTAINS_S1; |
| }; |
| |
| AutofillProfileComparatorTest() { |
| autofill::CountryNames::SetLocaleString(kLocale); |
| } |
| |
| NameInfo CreateNameInfo(const char* first, |
| const char* middle, |
| const char* last, |
| const char* full) { |
| NameInfo name; |
| name.SetRawInfo(NAME_FIRST, base::UTF8ToUTF16(first)); |
| name.SetRawInfo(NAME_MIDDLE, base::UTF8ToUTF16(middle)); |
| name.SetRawInfo(NAME_LAST, base::UTF8ToUTF16(last)); |
| name.SetRawInfo(NAME_FULL, base::UTF8ToUTF16(full)); |
| return name; |
| } |
| |
| AutofillProfile CreateProfileWithName(const char* first, |
| const char* middle, |
| const char* last) { |
| AutofillProfile profile(base::GenerateGUID(), "http://www.example.com/"); |
| autofill::test::SetProfileInfo(&profile, first, middle, last, "", "", "", |
| "", "", "", "", "", ""); |
| return profile; |
| } |
| |
| AutofillProfile CreateProfileWithName(const NameInfo& name) { |
| AutofillProfile profile(base::GenerateGUID(), "http://www.example.com/"); |
| profile.SetRawInfo(NAME_FULL, name.GetRawInfo(NAME_FULL)); |
| profile.SetRawInfo(NAME_FIRST, name.GetRawInfo(NAME_FIRST)); |
| profile.SetRawInfo(NAME_MIDDLE, name.GetRawInfo(NAME_MIDDLE)); |
| profile.SetRawInfo(NAME_LAST, name.GetRawInfo(NAME_LAST)); |
| return profile; |
| } |
| |
| AutofillProfile CreateProfileWithEmail(const char* email) { |
| AutofillProfile profile(base::GenerateGUID(), "http://www.example.com/"); |
| autofill::test::SetProfileInfo(&profile, "", "", "", email, "", "", "", "", |
| "", "", "", ""); |
| return profile; |
| } |
| |
| AutofillProfile CreateProfileWithCompanyName(const char* company_name) { |
| AutofillProfile profile(base::GenerateGUID(), "http://www.example.com/"); |
| autofill::test::SetProfileInfo(&profile, "", "", "", "", company_name, "", |
| "", "", "", "", "", ""); |
| return profile; |
| } |
| |
| AutofillProfile CreateProfileWithPhoneNumber(const char* phone_number) { |
| AutofillProfile profile(base::GenerateGUID(), "http://www.example.com/"); |
| autofill::test::SetProfileInfo(&profile, "", "", "", "", "", "", "", "", "", |
| "", "", phone_number); |
| return profile; |
| } |
| |
| AutofillProfile CreateProfileWithAddress(const char* line1, |
| const char* line2, |
| const char* city, |
| const char* state, |
| const char* zip, |
| const char* country) { |
| AutofillProfile profile(base::GenerateGUID(), "http://www.example.com/"); |
| autofill::test::SetProfileInfo(&profile, "", "", "", "", "", line1, line2, |
| city, state, zip, country, ""); |
| return profile; |
| } |
| |
| AutofillProfile CopyAndModify( |
| const AutofillProfile& profile, |
| const std::vector<std::pair<ServerFieldType, const char*>>& updates) { |
| AutofillProfile new_profile = profile; |
| for (const auto& update : updates) { |
| new_profile.SetRawInfo(update.first, UTF8ToUTF16(update.second)); |
| } |
| return new_profile; |
| } |
| |
| void MergeNamesAndExpect(const AutofillProfile& a, |
| const AutofillProfile& b, |
| const NameInfo& expected) { |
| NameInfo actual; |
| ASSERT_TRUE(comparator_.MergeNames(a, b, &actual)); |
| |
| // Is the "processed" data correct? |
| EXPECT_EQ(expected.GetInfo(AutofillType(NAME_FULL), kLocale), |
| actual.GetInfo(AutofillType(NAME_FULL), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(NAME_FIRST), kLocale), |
| actual.GetInfo(AutofillType(NAME_FIRST), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(NAME_MIDDLE), kLocale), |
| actual.GetInfo(AutofillType(NAME_MIDDLE), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(NAME_LAST), kLocale), |
| actual.GetInfo(AutofillType(NAME_LAST), kLocale)); |
| |
| // Is the raw data correct? |
| EXPECT_EQ(expected.GetRawInfo(NAME_FULL), actual.GetRawInfo(NAME_FULL)); |
| EXPECT_EQ(expected.GetRawInfo(NAME_FIRST), actual.GetRawInfo(NAME_FIRST)); |
| EXPECT_EQ(expected.GetRawInfo(NAME_MIDDLE), actual.GetRawInfo(NAME_MIDDLE)); |
| EXPECT_EQ(expected.GetRawInfo(NAME_LAST), actual.GetRawInfo(NAME_LAST)); |
| } |
| |
| void MergeEmailAddressesAndExpect(const AutofillProfile& a, |
| const AutofillProfile& b, |
| const EmailInfo& expected) { |
| EmailInfo actual; |
| ASSERT_TRUE(comparator_.MergeEmailAddresses(a, b, &actual)); |
| EXPECT_EQ(expected.GetRawInfo(EMAIL_ADDRESS), |
| actual.GetRawInfo(EMAIL_ADDRESS)); |
| } |
| |
| void MergeCompanyNamesAndExpect(const AutofillProfile& a, |
| const AutofillProfile& b, |
| const CompanyInfo& expected) { |
| CompanyInfo actual; |
| ASSERT_TRUE(comparator_.MergeCompanyNames(a, b, &actual)); |
| EXPECT_EQ(expected.GetRawInfo(COMPANY_NAME), |
| actual.GetRawInfo(COMPANY_NAME)); |
| } |
| |
| void MergePhoneNumbersAndExpect(const AutofillProfile& a, |
| const AutofillProfile& b, |
| const std::string& expected_str) { |
| AutofillProfile dummy; |
| |
| // Merge the phone numbers. |
| PhoneNumber actual(&dummy); |
| ASSERT_TRUE(comparator_.MergePhoneNumbers(a, b, &actual)); |
| |
| // Construct the expected value. |
| PhoneNumber expected(&dummy); |
| expected.SetRawInfo(PHONE_HOME_WHOLE_NUMBER, UTF8ToUTF16(expected_str)); |
| |
| // Validate that we get what we expect. |
| EXPECT_EQ(expected.GetRawInfo(PHONE_HOME_WHOLE_NUMBER), |
| actual.GetRawInfo(PHONE_HOME_WHOLE_NUMBER)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(PHONE_HOME_WHOLE_NUMBER), kLocale), |
| actual.GetInfo(AutofillType(PHONE_HOME_WHOLE_NUMBER), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(PHONE_HOME_COUNTRY_CODE), kLocale), |
| actual.GetInfo(AutofillType(PHONE_HOME_COUNTRY_CODE), kLocale)); |
| EXPECT_EQ( |
| expected.GetInfo(AutofillType(PHONE_HOME_CITY_AND_NUMBER), kLocale), |
| actual.GetInfo(AutofillType(PHONE_HOME_CITY_AND_NUMBER), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(PHONE_HOME_CITY_CODE), kLocale), |
| actual.GetInfo(AutofillType(PHONE_HOME_CITY_CODE), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(PHONE_HOME_NUMBER), kLocale), |
| actual.GetInfo(AutofillType(PHONE_HOME_NUMBER), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(PHONE_HOME_EXTENSION), kLocale), |
| actual.GetInfo(AutofillType(PHONE_HOME_EXTENSION), kLocale)); |
| } |
| |
| void MergeAddressesAndExpect(const AutofillProfile& a, |
| const AutofillProfile& b, |
| const Address& expected) { |
| Address actual; |
| ASSERT_TRUE(comparator_.MergeAddresses(a, b, &actual)); |
| |
| EXPECT_EQ(expected.GetInfo(AutofillType(ADDRESS_HOME_LINE1), kLocale), |
| actual.GetInfo(AutofillType(ADDRESS_HOME_LINE1), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(ADDRESS_HOME_LINE2), kLocale), |
| actual.GetInfo(AutofillType(ADDRESS_HOME_LINE2), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(ADDRESS_HOME_LINE3), kLocale), |
| actual.GetInfo(AutofillType(ADDRESS_HOME_LINE3), kLocale)); |
| EXPECT_EQ( |
| expected.GetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS), kLocale), |
| actual.GetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS), kLocale)); |
| EXPECT_EQ( |
| expected.GetInfo(AutofillType(ADDRESS_HOME_DEPENDENT_LOCALITY), |
| kLocale), |
| actual.GetInfo(AutofillType(ADDRESS_HOME_DEPENDENT_LOCALITY), kLocale)); |
| EXPECT_EQ( |
| expected.GetInfo(AutofillType(ADDRESS_HOME_SORTING_CODE), kLocale), |
| actual.GetInfo(AutofillType(ADDRESS_HOME_SORTING_CODE), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(ADDRESS_HOME_CITY), kLocale), |
| actual.GetInfo(AutofillType(ADDRESS_HOME_CITY), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(ADDRESS_HOME_STATE), kLocale), |
| actual.GetInfo(AutofillType(ADDRESS_HOME_STATE), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(ADDRESS_HOME_ZIP), kLocale), |
| actual.GetInfo(AutofillType(ADDRESS_HOME_ZIP), kLocale)); |
| EXPECT_EQ(expected.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), kLocale), |
| actual.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), kLocale)); |
| } |
| |
| AutofillProfileComparator comparator_{kLocale}; |
| |
| private: |
| DISALLOW_COPY_AND_ASSIGN(AutofillProfileComparatorTest); |
| }; |
| |
| } // namespace |
| |
| TEST_F(AutofillProfileComparatorTest, UniqueTokens) { |
| base::string16 kInput = UTF8ToUTF16("a b a a b"); |
| std::vector<base::string16> tokens = {UTF8ToUTF16("a"), UTF8ToUTF16("b")}; |
| EXPECT_EQ(std::set<base::StringPiece16>(tokens.begin(), tokens.end()), |
| comparator_.UniqueTokens(kInput)); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, CompareTokens) { |
| base::string16 kEmptyStr = UTF8ToUTF16(""); |
| base::string16 kHello = UTF8ToUTF16("hello"); |
| base::string16 kHelloThere = UTF8ToUTF16("hello there"); |
| base::string16 kHelloThereAlice = UTF8ToUTF16("hello there alice"); |
| base::string16 kHelloThereBob = UTF8ToUTF16("hello there bob"); |
| |
| EXPECT_EQ(AutofillProfileComparator::SAME_TOKENS, |
| comparator_.CompareTokens(kHelloThereBob, kHelloThereBob)); |
| EXPECT_EQ(AutofillProfileComparator::S2_CONTAINS_S1, |
| comparator_.CompareTokens(kEmptyStr, kHello)); |
| EXPECT_EQ(AutofillProfileComparator::S1_CONTAINS_S2, |
| comparator_.CompareTokens(kHello, kEmptyStr)); |
| EXPECT_EQ(AutofillProfileComparator::S1_CONTAINS_S2, |
| comparator_.CompareTokens(kHelloThere, kHello)); |
| EXPECT_EQ(AutofillProfileComparator::S2_CONTAINS_S1, |
| comparator_.CompareTokens(kHello, kHelloThere)); |
| EXPECT_EQ(AutofillProfileComparator::DIFFERENT_TOKENS, |
| comparator_.CompareTokens(kHelloThereAlice, kHelloThereBob)); |
| EXPECT_EQ(AutofillProfileComparator::DIFFERENT_TOKENS, |
| comparator_.CompareTokens(kHelloThereBob, kHelloThereAlice)); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, NormalizeForComparison) { |
| EXPECT_EQ(UTF8ToUTF16("timothe"), |
| comparator_.NormalizeForComparison(UTF8ToUTF16("Timothé"))); |
| EXPECT_EQ(UTF8ToUTF16("sven ake"), |
| comparator_.NormalizeForComparison(UTF8ToUTF16(" sven-åke "))); |
| EXPECT_EQ(UTF8ToUTF16("c 㸐"), |
| comparator_.NormalizeForComparison(UTF8ToUTF16("Ç 㸐"))); |
| EXPECT_EQ(UTF8ToUTF16("902103214"), |
| comparator_.NormalizeForComparison( |
| base::UTF8ToUTF16("90210-3214"), |
| AutofillProfileComparator::DISCARD_WHITESPACE)); |
| EXPECT_EQ(UTF8ToUTF16("timothe noel etienne perier"), |
| comparator_.NormalizeForComparison( |
| UTF8ToUTF16("Timothé-Noël Étienne Périer"))); |
| // NOP. |
| EXPECT_EQ(base::string16(), |
| comparator_.NormalizeForComparison(base::string16())); |
| |
| // Simple punctuation removed. |
| EXPECT_EQ(UTF8ToUTF16("1600 amphitheatre pkwy"), |
| comparator_.NormalizeForComparison( |
| UTF8ToUTF16("1600 Amphitheatre, Pkwy."))); |
| |
| // Unicode punctuation (hyphen and space), multiple spaces collapsed. |
| EXPECT_EQ(UTF8ToUTF16("mid island plaza"), |
| comparator_.NormalizeForComparison( |
| base::WideToUTF16(L"Mid\x2013Island\x2003 Plaza"))); |
| |
| // Newline character removed. |
| EXPECT_EQ(UTF8ToUTF16("1600 amphitheatre pkwy app 2"), |
| comparator_.NormalizeForComparison( |
| UTF8ToUTF16("1600 amphitheatre pkwy \n App. 2"))); |
| |
| // Diacritics removed. |
| EXPECT_EQ(UTF8ToUTF16("まeoa정"), |
| comparator_.NormalizeForComparison(UTF8ToUTF16("まéÖä정"))); |
| |
| // Spaces removed. |
| EXPECT_EQ(UTF8ToUTF16("유재석"), comparator_.NormalizeForComparison( |
| UTF8ToUTF16("유 재석"), |
| AutofillProfileComparator::DISCARD_WHITESPACE)); |
| |
| // Punctuation removed, Japanese kana normalized. |
| EXPECT_EQ(UTF8ToUTF16("ヒルケイツ"), comparator_.NormalizeForComparison( |
| UTF8ToUTF16("ビル・ゲイツ"), |
| AutofillProfileComparator::DISCARD_WHITESPACE)); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, GetNamePartVariants) { |
| std::set<base::string16> expected_variants = { |
| UTF8ToUTF16("timothe noel"), |
| UTF8ToUTF16("timothe n"), |
| UTF8ToUTF16("timothe"), |
| UTF8ToUTF16("t noel"), |
| UTF8ToUTF16("t n"), |
| UTF8ToUTF16("t"), |
| UTF8ToUTF16("noel"), |
| UTF8ToUTF16("n"), |
| UTF8ToUTF16(""), |
| UTF8ToUTF16("tn"), |
| }; |
| |
| EXPECT_EQ(expected_variants, |
| comparator_.GetNamePartVariants(UTF8ToUTF16("timothe noel"))); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, IsNameVariantOf) { |
| const base::string16 kNormalizedFullName = |
| UTF8ToUTF16("timothe noel etienne perier"); |
| |
| EXPECT_TRUE( |
| comparator_.IsNameVariantOf(kNormalizedFullName, kNormalizedFullName)); |
| EXPECT_TRUE(comparator_.IsNameVariantOf( |
| kNormalizedFullName, UTF8ToUTF16("t noel etienne perier"))); |
| EXPECT_TRUE(comparator_.IsNameVariantOf(kNormalizedFullName, |
| UTF8ToUTF16("timothe perier"))); |
| EXPECT_TRUE(comparator_.IsNameVariantOf(kNormalizedFullName, |
| UTF8ToUTF16("t perier"))); |
| EXPECT_TRUE(comparator_.IsNameVariantOf(kNormalizedFullName, |
| UTF8ToUTF16("noel perier"))); |
| EXPECT_TRUE(comparator_.IsNameVariantOf(kNormalizedFullName, |
| UTF8ToUTF16("t n etienne perier"))); |
| EXPECT_TRUE(comparator_.IsNameVariantOf(kNormalizedFullName, |
| UTF8ToUTF16("tn perier"))); |
| EXPECT_TRUE(comparator_.IsNameVariantOf(kNormalizedFullName, |
| UTF8ToUTF16("te perier"))); |
| |
| EXPECT_FALSE(comparator_.IsNameVariantOf(kNormalizedFullName, |
| UTF8ToUTF16("etienne noel perier"))); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, HaveMergeableNames) { |
| AutofillProfile empty = CreateProfileWithName("", "", ""); |
| |
| AutofillProfile p1 = CreateProfileWithName("sven-åke", "", "larsson"); |
| AutofillProfile p2 = CreateProfileWithName("Åke", "", "Larsson"); |
| AutofillProfile p3 = CreateProfileWithName("A", "", "Larsson"); |
| AutofillProfile p4 = CreateProfileWithName("sven", "ake", "Larsson"); |
| |
| AutofillProfile initials = CreateProfileWithName("SA", "", "Larsson"); |
| |
| AutofillProfile different = CreateProfileWithName("Joe", "", "Larsson"); |
| |
| // |p1|, |p2|, |p3|, |p4| and |empty| should all be the mergeable with |
| // one another. The order of the comparands should not matter. |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p1, empty)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p1, p1)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p1, p2)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p1, p3)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p1, p4)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p2, empty)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p2, p1)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p2, p2)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p2, p3)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p2, p4)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p3, empty)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p3, p1)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p3, p2)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p3, p3)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p3, p4)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p4, empty)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p4, p1)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p4, p2)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p4, p3)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p4, p4)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(empty, empty)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(empty, p1)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(empty, p2)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(empty, p3)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(empty, p4)); |
| |
| // |initials| is mergeable with |p1| and |p4| but not |p2| or |p3|. |
| EXPECT_TRUE(comparator_.HaveMergeableNames(initials, empty)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(initials, p1)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(initials, p4)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(empty, initials)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p1, initials)); |
| EXPECT_TRUE(comparator_.HaveMergeableNames(p4, initials)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(initials, p2)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(initials, p3)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(p2, initials)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(p3, initials)); |
| |
| // None of the non-empty profiles should match |different|. The order of the |
| // comparands should not matter. |
| EXPECT_FALSE(comparator_.HaveMergeableNames(p1, different)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(p2, different)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(p3, different)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(p4, different)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(initials, different)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(different, p1)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(different, p2)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(different, p3)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(different, p4)); |
| EXPECT_FALSE(comparator_.HaveMergeableNames(different, initials)); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, HaveMergeableEmailAddresses) { |
| AutofillProfile empty = CreateProfileWithEmail(""); |
| AutofillProfile p1 = CreateProfileWithEmail("FOO@BAR.COM"); |
| AutofillProfile p2 = CreateProfileWithEmail("foo@bar.com"); |
| AutofillProfile different = CreateProfileWithEmail("not@the-same.com"); |
| |
| EXPECT_TRUE(comparator_.HaveMergeableEmailAddresses(p1, p2)); |
| EXPECT_TRUE(comparator_.HaveMergeableEmailAddresses(p2, p1)); |
| EXPECT_TRUE(comparator_.HaveMergeableEmailAddresses(p1, empty)); |
| EXPECT_TRUE(comparator_.HaveMergeableEmailAddresses(empty, p2)); |
| |
| EXPECT_FALSE(comparator_.HaveMergeableEmailAddresses(p1, different)); |
| EXPECT_FALSE(comparator_.HaveMergeableEmailAddresses(different, p1)); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, HaveMergeableCompanyNames) { |
| AutofillProfile empty = CreateProfileWithCompanyName(""); |
| AutofillProfile p1 = CreateProfileWithCompanyName("Nestlé S.A."); |
| AutofillProfile p2 = CreateProfileWithCompanyName("Nestle"); |
| AutofillProfile different = CreateProfileWithCompanyName("Other Corp"); |
| |
| EXPECT_TRUE(comparator_.HaveMergeableCompanyNames(p1, p2)); |
| EXPECT_TRUE(comparator_.HaveMergeableCompanyNames(p2, p1)); |
| EXPECT_TRUE(comparator_.HaveMergeableCompanyNames(p1, empty)); |
| EXPECT_TRUE(comparator_.HaveMergeableCompanyNames(empty, p2)); |
| |
| EXPECT_FALSE(comparator_.HaveMergeableCompanyNames(p1, different)); |
| EXPECT_FALSE(comparator_.HaveMergeableCompanyNames(different, p1)); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, HaveMergeablePhoneNumbers) { |
| AutofillProfile empty = CreateProfileWithPhoneNumber(""); |
| AutofillProfile p1 = CreateProfileWithPhoneNumber("+1 (800) 670-8700"); |
| AutofillProfile p2 = CreateProfileWithPhoneNumber("800.670.8700x321"); |
| AutofillProfile p3 = CreateProfileWithPhoneNumber("670-8700 ext321"); |
| AutofillProfile p4 = CreateProfileWithPhoneNumber("6708700"); |
| AutofillProfile different = CreateProfileWithPhoneNumber("1-800-321-4567"); |
| |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p1, p1)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p1, p2)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p1, p3)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p1, p4)); |
| |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p2, p1)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p2, p2)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p2, p3)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p2, p4)); |
| |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p3, p1)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p3, p2)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p3, p3)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p3, p4)); |
| |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p4, p1)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p4, p2)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p4, p3)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p4, p4)); |
| |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(p1, empty)); |
| EXPECT_TRUE(comparator_.HaveMergeablePhoneNumbers(empty, p2)); |
| |
| EXPECT_FALSE(comparator_.HaveMergeablePhoneNumbers(p1, different)); |
| EXPECT_FALSE(comparator_.HaveMergeablePhoneNumbers(different, p1)); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, HaveMergeableAddresses) { |
| // TODO(rogerm): Replace some of the tokens to also test the address |
| // normalization string replacement rules. For example: |
| // - State/Province abbreviations |
| // - Street/St/Saint/Sainte |
| // - etc... |
| AutofillProfile empty = CreateProfileWithAddress("", "", "", "", "", ""); |
| AutofillProfile p1 = CreateProfileWithAddress( |
| "1 Some Street", "Unit 3", "Carver", "CA - California", "90210", "US"); |
| p1.SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY, UTF8ToUTF16("Some String")); |
| p1.SetRawInfo(ADDRESS_HOME_SORTING_CODE, UTF8ToUTF16("64205 Biarritz CEDEX")); |
| |
| AutofillProfile p2 = CreateProfileWithAddress( |
| "Unit 3", "1 Some Street", "Suburb", "california", "90 210-3214", ""); |
| AutofillProfile p3 = CreateProfileWithAddress("1 Some Street #3", "", |
| "Carver City", "ca", "", "us"); |
| |
| AutofillProfile differentCountry = |
| CopyAndModify(p1, {{ADDRESS_HOME_COUNTRY, "CA"}}); |
| AutofillProfile differentZip = |
| CopyAndModify(p1, {{ADDRESS_HOME_ZIP, "32145"}}); |
| AutofillProfile differentState = CopyAndModify( |
| p1, {{ADDRESS_HOME_ZIP, ""}, {ADDRESS_HOME_STATE, "Florida"}}); |
| AutofillProfile differentCity = CopyAndModify( |
| p1, {{ADDRESS_HOME_ZIP, ""}, {ADDRESS_HOME_CITY, "Metropolis"}}); |
| AutofillProfile differentAddress = |
| CopyAndModify(p1, {{ADDRESS_HOME_LINE1, "17 Park Lane"}, |
| {ADDRESS_HOME_LINE2, "Suite 150"}}); |
| AutofillProfile differentLocality = |
| CopyAndModify(p1, {{ADDRESS_HOME_DEPENDENT_LOCALITY, "Funky Chicken"}}); |
| AutofillProfile differentSortingCode = |
| CopyAndModify(p1, {{ADDRESS_HOME_SORTING_CODE, "98000 Monaco"}}); |
| |
| EXPECT_TRUE(comparator_.HaveMergeableAddresses(p1, empty)); |
| EXPECT_TRUE(comparator_.HaveMergeableAddresses(empty, p2)); |
| |
| EXPECT_TRUE(comparator_.HaveMergeableAddresses(p1, p3)); |
| EXPECT_TRUE(comparator_.HaveMergeableAddresses(p3, p1)); |
| |
| // |p2| matches neither |p1| nor |p3| because we can't resolve the mismatched |
| // city/suburb names. |
| EXPECT_FALSE(comparator_.HaveMergeableAddresses(p1, p2)); |
| EXPECT_FALSE(comparator_.HaveMergeableAddresses(p2, p1)); |
| EXPECT_FALSE(comparator_.HaveMergeableAddresses(p2, p3)); |
| EXPECT_FALSE(comparator_.HaveMergeableAddresses(p3, p2)); |
| |
| // Changing things about |p1| causes its copies to stop being mergeable. |
| EXPECT_FALSE(comparator_.HaveMergeableAddresses(p1, differentCountry)); |
| EXPECT_FALSE(comparator_.HaveMergeableAddresses(p1, differentZip)); |
| EXPECT_FALSE(comparator_.HaveMergeableAddresses(p1, differentState)); |
| EXPECT_FALSE(comparator_.HaveMergeableAddresses(p1, differentCity)); |
| EXPECT_FALSE(comparator_.HaveMergeableAddresses(p1, differentAddress)); |
| EXPECT_FALSE(comparator_.HaveMergeableAddresses(p1, differentLocality)); |
| EXPECT_FALSE(comparator_.HaveMergeableAddresses(p1, differentSortingCode)); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, AreMergeable) { |
| AutofillProfile p(base::GenerateGUID(), "https://www.example.com/"); |
| autofill::test::SetProfileInfo(&p, "Marion", "Mitchell", "Morrison", |
| "marion@me.xyz", "Fox", "123 Zoo St.", |
| "Unit 5", "Hollywood", "CA", "91601", "US", |
| "+1 (234) 567-8910"); |
| |
| AutofillProfile mergeable = |
| CopyAndModify(p, {{NAME_FIRST, "MÁRÍÕÑ"}, |
| {NAME_MIDDLE, "M."}, |
| {EMAIL_ADDRESS, "MARION@ME.XYZ"}, |
| {COMPANY_NAME, "Fox Industries Inc."}, |
| {ADDRESS_HOME_LINE1, "123 zoo st. w., #5"}, |
| {ADDRESS_HOME_LINE1, ""}, |
| {ADDRESS_HOME_STATE, "california"}, |
| {PHONE_HOME_WHOLE_NUMBER, "5678910 ext. 77"}}); |
| AutofillProfile not_mergeable_by_name = |
| CopyAndModify(p, {{NAME_FIRST, "Steven"}}); |
| AutofillProfile not_mergeable_by_email_address = |
| CopyAndModify(p, {{EMAIL_ADDRESS, "marion.morrision@me.xyz"}}); |
| AutofillProfile not_mergeable_by_company_name = |
| CopyAndModify(p, {{COMPANY_NAME, "Hound Corp"}}); |
| AutofillProfile not_mergeable_by_address = |
| CopyAndModify(p, {{ADDRESS_HOME_LINE2, "Unit 7"}}); |
| AutofillProfile not_mergeable_by_phone_number = |
| CopyAndModify(p, {{PHONE_HOME_WHOLE_NUMBER, "555-1234"}}); |
| |
| EXPECT_TRUE(comparator_.AreMergeable(p, p)); |
| EXPECT_TRUE(comparator_.AreMergeable(p, mergeable)); |
| EXPECT_FALSE(comparator_.AreMergeable(p, not_mergeable_by_name)); |
| EXPECT_FALSE(comparator_.AreMergeable(p, not_mergeable_by_email_address)); |
| EXPECT_FALSE(comparator_.AreMergeable(p, not_mergeable_by_company_name)); |
| EXPECT_FALSE(comparator_.AreMergeable(p, not_mergeable_by_address)); |
| EXPECT_FALSE(comparator_.AreMergeable(p, not_mergeable_by_phone_number)); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, MergeNames) { |
| NameInfo name1; |
| name1.SetRawInfo(NAME_FULL, UTF8ToUTF16("John Quincy Public")); |
| name1.SetRawInfo(NAME_FIRST, UTF8ToUTF16("John")); |
| name1.SetRawInfo(NAME_MIDDLE, UTF8ToUTF16("Quincy")); |
| name1.SetRawInfo(NAME_LAST, UTF8ToUTF16("Public")); |
| |
| NameInfo name2; |
| name2.SetRawInfo(NAME_FULL, UTF8ToUTF16("John Q. Public")); |
| name2.SetRawInfo(NAME_FIRST, UTF8ToUTF16("John")); |
| name2.SetRawInfo(NAME_MIDDLE, UTF8ToUTF16("Q.")); |
| name2.SetRawInfo(NAME_LAST, UTF8ToUTF16("Public")); |
| |
| NameInfo name3; |
| name3.SetRawInfo(NAME_FULL, UTF8ToUTF16("J Public")); |
| name3.SetRawInfo(NAME_FIRST, UTF8ToUTF16("J")); |
| name3.SetRawInfo(NAME_MIDDLE, UTF8ToUTF16("")); |
| name3.SetRawInfo(NAME_LAST, UTF8ToUTF16("Public")); |
| |
| NameInfo name4; |
| name4.SetRawInfo(NAME_FULL, UTF8ToUTF16("John Quincy Public")); |
| |
| NameInfo name5; |
| name5.SetRawInfo(NAME_FIRST, UTF8ToUTF16("John")); |
| name5.SetRawInfo(NAME_LAST, UTF8ToUTF16("Public")); |
| |
| NameInfo synthesized; |
| synthesized.SetRawInfo(NAME_FULL, UTF8ToUTF16("John Public")); |
| synthesized.SetRawInfo(NAME_FIRST, UTF8ToUTF16("John")); |
| synthesized.SetRawInfo(NAME_MIDDLE, UTF8ToUTF16("")); |
| synthesized.SetRawInfo(NAME_LAST, UTF8ToUTF16("Public")); |
| |
| AutofillProfile p1 = CreateProfileWithName(name1); |
| AutofillProfile p2 = CreateProfileWithName(name2); |
| AutofillProfile p3 = CreateProfileWithName(name3); |
| AutofillProfile p4 = CreateProfileWithName(name4); |
| AutofillProfile p5 = CreateProfileWithName(name5); |
| |
| MergeNamesAndExpect(p1, p1, name1); |
| MergeNamesAndExpect(p1, p2, name1); |
| MergeNamesAndExpect(p1, p3, name1); |
| MergeNamesAndExpect(p1, p4, name1); |
| MergeNamesAndExpect(p1, p5, name1); |
| |
| MergeNamesAndExpect(p2, p1, name1); |
| MergeNamesAndExpect(p2, p2, name2); |
| MergeNamesAndExpect(p2, p3, name2); |
| MergeNamesAndExpect(p2, p4, name1); |
| MergeNamesAndExpect(p2, p5, name2); |
| |
| MergeNamesAndExpect(p3, p1, name1); |
| MergeNamesAndExpect(p3, p2, name2); |
| MergeNamesAndExpect(p3, p3, name3); |
| MergeNamesAndExpect(p3, p4, name1); |
| MergeNamesAndExpect(p3, p5, synthesized); |
| |
| // P4 can be teased apart and reconstituted as name1. |
| MergeNamesAndExpect(p4, p1, name1); |
| MergeNamesAndExpect(p4, p2, name1); |
| MergeNamesAndExpect(p4, p3, name1); |
| MergeNamesAndExpect(p4, p4, name1); |
| MergeNamesAndExpect(p4, p5, name1); |
| |
| // P5 expands the first name if it's not complete. |
| MergeNamesAndExpect(p5, p1, name1); |
| MergeNamesAndExpect(p5, p2, name2); |
| MergeNamesAndExpect(p5, p3, synthesized); |
| MergeNamesAndExpect(p5, p4, name1); |
| MergeNamesAndExpect(p5, p5, synthesized); // We flesh out missing data. |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, MergeCJKNames) { |
| // Korean names that are all mergeable, but constructed differently. |
| NameInfo name1 = CreateNameInfo("호", "", "이영", "이영 호"); |
| NameInfo name2 = CreateNameInfo("이영호", "", "", "이영호"); |
| NameInfo name3 = CreateNameInfo("영호", "", "이", "이영호"); |
| NameInfo name4 = CreateNameInfo("영호", "", "이", ""); |
| NameInfo name5 = CreateNameInfo("영호", "", "이", "이 영호"); |
| |
| |
| // Mergeable foreign name in Japanese with a 'KATAKANA MIDDLE DOT'. |
| NameInfo name6 = CreateNameInfo("", "", "", "ゲイツ・ビル"); |
| NameInfo name7 = CreateNameInfo("ビル", "", "ゲイツ", ""); |
| |
| // Set the use dates for the profiles, because |MergeCJKNames()| tries to use |
| // the most recent profile if there is a conflict. The ordering is |
| // p1 > p2 > p3 > p4 > p5, with p1 being the most recent. |
| AutofillProfile p1 = CreateProfileWithName(name1); |
| p1.set_use_date(base::Time::Now()); |
| AutofillProfile p2 = CreateProfileWithName(name2); |
| p2.set_use_date(base::Time::Now() - base::TimeDelta::FromHours(1)); |
| AutofillProfile p3 = CreateProfileWithName(name3); |
| p3.set_use_date(base::Time::Now() - base::TimeDelta::FromHours(2)); |
| AutofillProfile p4 = CreateProfileWithName(name4); |
| p4.set_use_date(base::Time::Now() - base::TimeDelta::FromHours(3)); |
| AutofillProfile p5 = CreateProfileWithName(name5); |
| p5.set_use_date(base::Time::Now() - base::TimeDelta::FromHours(4)); |
| |
| AutofillProfile p6 = CreateProfileWithName(name6); |
| AutofillProfile p7 = CreateProfileWithName(name7); |
| |
| // Because |p1| is the most recent, it always wins over others. |
| MergeNamesAndExpect(p1, p2, CreateNameInfo("호", "", "이영", "이영 호")); |
| MergeNamesAndExpect(p1, p3, CreateNameInfo("호", "", "이영", "이영 호")); |
| MergeNamesAndExpect(p1, p4, CreateNameInfo("호", "", "이영", "이영 호")); |
| MergeNamesAndExpect(p1, p5, CreateNameInfo("호", "", "이영", "이영 호")); |
| |
| // |p2| is more recent than |p3|, |p4|, and |p5|. However, it does not have a |
| // surname entry (it was probably parsed with the old logic), so the other |
| // profiles are used as the source for given/surname. |
| MergeNamesAndExpect(p2, p3, CreateNameInfo("영호", "", "이", "이영호")); |
| MergeNamesAndExpect(p2, p4, CreateNameInfo("영호", "", "이", "이영호")); |
| MergeNamesAndExpect(p2, p5, CreateNameInfo("영호", "", "이", "이영호")); |
| |
| // |p3| is more recent than |p4| and |p5|. |
| MergeNamesAndExpect(p3, p4, CreateNameInfo("영호", "", "이", "이영호")); |
| MergeNamesAndExpect(p3, p5, CreateNameInfo("영호", "", "이", "이영호")); |
| |
| // |p4| is more recent than |p5|. However, it does not have an explicit full |
| // name, so use the one from |p5|. |
| MergeNamesAndExpect(p4, p5, CreateNameInfo("영호", "", "이", "이 영호")); |
| |
| // There is no conflict between |p6| and |p7|, so use the parts from both. |
| MergeNamesAndExpect(p6, p7, |
| CreateNameInfo("ビル", "", "ゲイツ", "ゲイツ・ビル")); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, MergeEmailAddresses) { |
| static const char kEmailA[] = "testaccount@domain.net"; |
| static const char kEmailB[] = "TestAccount@Domain.Net"; |
| |
| EmailInfo email_a; |
| email_a.SetRawInfo(EMAIL_ADDRESS, UTF8ToUTF16(kEmailA)); |
| AutofillProfile profile_a = CreateProfileWithEmail(kEmailA); |
| profile_a.set_use_date(base::Time::Now()); |
| |
| EmailInfo email_b; |
| email_b.SetRawInfo(EMAIL_ADDRESS, UTF8ToUTF16(kEmailB)); |
| AutofillProfile profile_b = CreateProfileWithEmail(kEmailB); |
| profile_b.set_use_date(profile_a.use_date() + base::TimeDelta::FromDays(1)); |
| |
| MergeEmailAddressesAndExpect(profile_a, profile_a, email_a); |
| MergeEmailAddressesAndExpect(profile_b, profile_b, email_b); |
| MergeEmailAddressesAndExpect(profile_a, profile_b, email_b); |
| MergeEmailAddressesAndExpect(profile_b, profile_a, email_b); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, MergeCompanyNames) { |
| static const char kCompanyA[] = "Some Company"; |
| static const char kCompanyB[] = "SÔMÈ ÇÖMPÁÑÝ"; |
| static const char kCompanyC[] = "SÔMÈ ÇÖMPÁÑÝ A.G."; |
| |
| CompanyInfo company_a; |
| company_a.SetRawInfo(COMPANY_NAME, UTF8ToUTF16(kCompanyA)); |
| AutofillProfile profile_a = CreateProfileWithCompanyName(kCompanyA); |
| profile_a.set_use_date(base::Time::Now()); |
| |
| // Company Name B is post_normalization identical to Company Name A. The use |
| // date will be used to choose between them. |
| CompanyInfo company_b; |
| company_b.SetRawInfo(COMPANY_NAME, UTF8ToUTF16(kCompanyB)); |
| AutofillProfile profile_b = CreateProfileWithCompanyName(kCompanyB); |
| profile_b.set_use_date(profile_a.use_date() + base::TimeDelta::FromDays(1)); |
| |
| // Company Name C is the most complete. Even though it has the earliest use |
| // date, it will be preferred to the other two. |
| CompanyInfo company_c; |
| company_c.SetRawInfo(COMPANY_NAME, UTF8ToUTF16(kCompanyC)); |
| AutofillProfile profile_c = CreateProfileWithCompanyName(kCompanyC); |
| profile_c.set_use_date(profile_a.use_date() - base::TimeDelta::FromDays(1)); |
| |
| MergeCompanyNamesAndExpect(profile_a, profile_a, company_a); |
| MergeCompanyNamesAndExpect(profile_a, profile_b, company_b); |
| MergeCompanyNamesAndExpect(profile_a, profile_c, company_c); |
| MergeCompanyNamesAndExpect(profile_b, profile_a, company_b); |
| MergeCompanyNamesAndExpect(profile_b, profile_b, company_b); |
| MergeCompanyNamesAndExpect(profile_b, profile_c, company_c); |
| MergeCompanyNamesAndExpect(profile_c, profile_a, company_c); |
| MergeCompanyNamesAndExpect(profile_c, profile_b, company_c); |
| MergeCompanyNamesAndExpect(profile_c, profile_c, company_c); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, MergePhoneNumbers_NA) { |
| static const char kPhoneA[] = "5550199"; |
| static const char kPhoneB[] = "555.0199"; |
| static const char kPhoneC[] = "555-0199 ext321"; |
| static const char kPhoneD[] = "8005550199"; |
| static const char kPhoneE[] = "800-555-0199 #321"; |
| static const char kPhoneF[] = "1-800-555-0199 #321"; |
| static const char kPhoneG[] = "+1 (800) 555.0199;ext=321"; |
| static const char kMergedShortNumber[] = "5550199"; |
| static const char kMergedShortNumberExt[] = "5550199 ext. 321"; |
| static const char kMergedFullNumber[] = "+1 800-555-0199"; |
| static const char kMergedFullNumberExt[] = "+1 800-555-0199 ext. 321"; |
| |
| AutofillProfile profile_a = CreateProfileWithPhoneNumber(kPhoneA); |
| AutofillProfile profile_b = CreateProfileWithPhoneNumber(kPhoneB); |
| AutofillProfile profile_c = CreateProfileWithPhoneNumber(kPhoneC); |
| AutofillProfile profile_d = CreateProfileWithPhoneNumber(kPhoneD); |
| AutofillProfile profile_e = CreateProfileWithPhoneNumber(kPhoneE); |
| AutofillProfile profile_f = CreateProfileWithPhoneNumber(kPhoneF); |
| AutofillProfile profile_g = CreateProfileWithPhoneNumber(kPhoneG); |
| |
| // Profile A |
| MergePhoneNumbersAndExpect(profile_a, profile_a, kPhoneA); |
| MergePhoneNumbersAndExpect(profile_a, profile_b, kMergedShortNumber); |
| MergePhoneNumbersAndExpect(profile_a, profile_c, kMergedShortNumberExt); |
| MergePhoneNumbersAndExpect(profile_a, profile_d, kMergedFullNumber); |
| MergePhoneNumbersAndExpect(profile_a, profile_e, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_a, profile_f, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_a, profile_g, kMergedFullNumberExt); |
| |
| // Profile B |
| MergePhoneNumbersAndExpect(profile_b, profile_a, kMergedShortNumber); |
| MergePhoneNumbersAndExpect(profile_b, profile_b, kPhoneB); |
| MergePhoneNumbersAndExpect(profile_b, profile_c, kMergedShortNumberExt); |
| MergePhoneNumbersAndExpect(profile_b, profile_d, kMergedFullNumber); |
| MergePhoneNumbersAndExpect(profile_b, profile_e, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_b, profile_f, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_b, profile_g, kMergedFullNumberExt); |
| |
| // Profile C |
| MergePhoneNumbersAndExpect(profile_c, profile_a, kMergedShortNumberExt); |
| MergePhoneNumbersAndExpect(profile_c, profile_b, kMergedShortNumberExt); |
| MergePhoneNumbersAndExpect(profile_c, profile_c, kPhoneC); |
| MergePhoneNumbersAndExpect(profile_c, profile_d, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_c, profile_e, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_c, profile_f, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_c, profile_g, kMergedFullNumberExt); |
| |
| // Profile D |
| MergePhoneNumbersAndExpect(profile_d, profile_a, kMergedFullNumber); |
| MergePhoneNumbersAndExpect(profile_d, profile_b, kMergedFullNumber); |
| MergePhoneNumbersAndExpect(profile_d, profile_c, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_d, profile_d, kPhoneD); |
| MergePhoneNumbersAndExpect(profile_d, profile_e, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_d, profile_f, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_d, profile_g, kMergedFullNumberExt); |
| |
| // Profile E |
| MergePhoneNumbersAndExpect(profile_e, profile_a, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_e, profile_b, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_e, profile_c, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_e, profile_d, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_e, profile_e, kPhoneE); |
| MergePhoneNumbersAndExpect(profile_e, profile_f, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_e, profile_g, kMergedFullNumberExt); |
| |
| // Profile F |
| MergePhoneNumbersAndExpect(profile_f, profile_a, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_f, profile_b, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_f, profile_c, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_f, profile_d, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_f, profile_e, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_f, profile_f, kPhoneF); |
| MergePhoneNumbersAndExpect(profile_f, profile_g, kMergedFullNumberExt); |
| |
| // Profile G |
| MergePhoneNumbersAndExpect(profile_g, profile_a, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_g, profile_b, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_g, profile_c, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_g, profile_d, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_g, profile_e, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_g, profile_f, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_g, profile_g, kPhoneG); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, MergePhoneNumbers_Intl) { |
| const base::string16 kGermany = UTF8ToUTF16("DE"); |
| const AutofillType kCountry(ADDRESS_HOME_COUNTRY); |
| |
| static const char kPhoneA[] = "+49492180185611"; |
| static const char kPhoneB[] = "+49 4921 801 856-11"; |
| static const char kPhoneC[] = "+49 4921 8018 5611;ext=22"; |
| static const char kPhoneD[] = "04921 80185611"; // National Format. |
| static const char kMergedFullNumber[] = "+49 4921 80185611"; |
| static const char kMergedFullNumberExt[] = "+49 4921 80185611 ext. 22"; |
| |
| AutofillProfile profile_a = CreateProfileWithPhoneNumber(kPhoneA); |
| AutofillProfile profile_b = CreateProfileWithPhoneNumber(kPhoneB); |
| AutofillProfile profile_c = CreateProfileWithPhoneNumber(kPhoneC); |
| AutofillProfile profile_d = CreateProfileWithPhoneNumber(kPhoneD); |
| |
| profile_a.SetInfo(kCountry, kGermany, kLocale); |
| profile_b.SetInfo(kCountry, kGermany, kLocale); |
| profile_c.SetInfo(kCountry, kGermany, kLocale); |
| profile_d.SetInfo(kCountry, kGermany, kLocale); |
| |
| // Profile A |
| MergePhoneNumbersAndExpect(profile_a, profile_a, kPhoneA); |
| MergePhoneNumbersAndExpect(profile_a, profile_b, kMergedFullNumber); |
| MergePhoneNumbersAndExpect(profile_a, profile_c, kMergedFullNumberExt); |
| |
| // Profile B |
| MergePhoneNumbersAndExpect(profile_b, profile_a, kMergedFullNumber); |
| MergePhoneNumbersAndExpect(profile_b, profile_b, kPhoneB); |
| MergePhoneNumbersAndExpect(profile_b, profile_c, kMergedFullNumberExt); |
| |
| // Profile C |
| MergePhoneNumbersAndExpect(profile_c, profile_a, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_c, profile_b, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_c, profile_c, kPhoneC); |
| |
| // Profile D |
| MergePhoneNumbersAndExpect(profile_d, profile_a, kMergedFullNumber); |
| MergePhoneNumbersAndExpect(profile_d, profile_b, kMergedFullNumber); |
| MergePhoneNumbersAndExpect(profile_d, profile_c, kMergedFullNumberExt); |
| MergePhoneNumbersAndExpect(profile_d, profile_d, kPhoneD); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, MergeAddresses) { |
| AutofillProfile p1 = CreateProfileWithAddress( |
| "1 Some Street", "Unit 3", "Carver", "CA - California", "90210", "US"); |
| AutofillProfile p2 = CreateProfileWithAddress( |
| "1 Some Street #3", "", "Carver City", "ca", "90210-1234", "us"); |
| |
| Address expected; |
| expected.SetRawInfo(ADDRESS_HOME_LINE1, UTF8ToUTF16("1 Some Street")); |
| expected.SetRawInfo(ADDRESS_HOME_LINE2, UTF8ToUTF16("Unit 3")); |
| expected.SetRawInfo(ADDRESS_HOME_CITY, UTF8ToUTF16("Carver City")); |
| expected.SetRawInfo(ADDRESS_HOME_STATE, UTF8ToUTF16("ca")); |
| expected.SetRawInfo(ADDRESS_HOME_ZIP, UTF8ToUTF16("90210-1234")); |
| expected.SetRawInfo(ADDRESS_HOME_COUNTRY, UTF8ToUTF16("US")); |
| |
| MergeAddressesAndExpect(p1, p2, expected); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, MergeAddressesMostUniqueTokens) { |
| AutofillProfile p1 = CreateProfileWithAddress( |
| "1 Some Street", "Unit 3", "Carver", "CA - California", "90210", "US"); |
| AutofillProfile p2 = CreateProfileWithAddress( |
| "1 Some Other Street", "Unit 3", "Carver City", "ca", "90210-1234", "us"); |
| |
| Address expected; |
| expected.SetRawInfo(ADDRESS_HOME_LINE1, UTF8ToUTF16("1 Some Other Street")); |
| expected.SetRawInfo(ADDRESS_HOME_LINE2, UTF8ToUTF16("Unit 3")); |
| expected.SetRawInfo(ADDRESS_HOME_CITY, UTF8ToUTF16("Carver City")); |
| expected.SetRawInfo(ADDRESS_HOME_STATE, UTF8ToUTF16("ca")); |
| expected.SetRawInfo(ADDRESS_HOME_ZIP, UTF8ToUTF16("90210-1234")); |
| expected.SetRawInfo(ADDRESS_HOME_COUNTRY, UTF8ToUTF16("US")); |
| |
| MergeAddressesAndExpect(p1, p2, expected); |
| MergeAddressesAndExpect(p2, p1, expected); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, MergeAddressesWithRewrite) { |
| AutofillProfile p1 = CreateProfileWithAddress( |
| "6543 CH BACON", "APP 3", "MONTRÉAL", "QUÉBEC", "HHH999", "ca"); |
| AutofillProfile p2 = CreateProfileWithAddress( |
| "6543, Bacon Rd", "", "Montreal", "QC", "hhh 999", "CA"); |
| p2.set_use_date(p1.use_date() + base::TimeDelta::FromMinutes(1)); |
| |
| Address expected; |
| expected.SetRawInfo(ADDRESS_HOME_LINE1, UTF8ToUTF16("6543 CH BACON")); |
| expected.SetRawInfo(ADDRESS_HOME_LINE2, UTF8ToUTF16("APP 3")); |
| expected.SetRawInfo(ADDRESS_HOME_CITY, UTF8ToUTF16("Montreal")); |
| expected.SetRawInfo(ADDRESS_HOME_STATE, UTF8ToUTF16("QC")); |
| expected.SetRawInfo(ADDRESS_HOME_ZIP, UTF8ToUTF16("hhh 999")); |
| expected.SetRawInfo(ADDRESS_HOME_COUNTRY, UTF8ToUTF16("CA")); |
| |
| MergeAddressesAndExpect(p1, p2, expected); |
| MergeAddressesAndExpect(p2, p1, expected); |
| } |
| |
| TEST_F(AutofillProfileComparatorTest, |
| MergeAddressesDependendLocalityAndSortingCode) { |
| AutofillProfile p1 = CreateProfileWithAddress( |
| "6543 CH BACON", "APP 3", "MONTRÉAL", "QUÉBEC", "HHH999", "ca"); |
| p1.SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY, UTF8ToUTF16("Some String")); |
| p1.SetRawInfo(ADDRESS_HOME_SORTING_CODE, UTF8ToUTF16("64205 Biarritz CEDEX")); |
| AutofillProfile p2 = CreateProfileWithAddress( |
| "6543, Bacon Rd", "", "Montreal", "QC", "hhh 999", "CA"); |
| p2.SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY, |
| UTF8ToUTF16("Some Other String")); |
| p2.SetRawInfo(ADDRESS_HOME_SORTING_CODE, UTF8ToUTF16("64205 Biarritz")); |
| p2.set_use_date(p1.use_date() + base::TimeDelta::FromMinutes(1)); |
| |
| Address expected; |
| expected.SetRawInfo(ADDRESS_HOME_LINE1, UTF8ToUTF16("6543 CH BACON")); |
| expected.SetRawInfo(ADDRESS_HOME_LINE2, UTF8ToUTF16("APP 3")); |
| expected.SetRawInfo(ADDRESS_HOME_CITY, UTF8ToUTF16("Montreal")); |
| expected.SetRawInfo(ADDRESS_HOME_STATE, UTF8ToUTF16("QC")); |
| expected.SetRawInfo(ADDRESS_HOME_ZIP, UTF8ToUTF16("hhh 999")); |
| expected.SetRawInfo(ADDRESS_HOME_COUNTRY, UTF8ToUTF16("CA")); |
| expected.SetRawInfo(ADDRESS_HOME_DEPENDENT_LOCALITY, |
| UTF8ToUTF16("Some Other String")); |
| expected.SetRawInfo(ADDRESS_HOME_SORTING_CODE, |
| UTF8ToUTF16("64205 Biarritz")); // Preferred by use date. |
| |
| MergeAddressesAndExpect(p1, p2, expected); |
| MergeAddressesAndExpect(p2, p1, expected); |
| } |
