Use upstream libaddressinput in Chrome.

third_party/libaddressinput/chromium/suggestions_unittest.cc

Index: third_party/libaddressinput/chromium/suggestions_unittest.cc
diff --git a/third_party/libaddressinput/chromium/suggestions_unittest.cc b/third_party/libaddressinput/chromium/suggestions_unittest.cc
new file mode 100644
index 0000000000000000000000000000000000000000..e248202b538991440447313bd95e2570a2e2fd8d
--- /dev/null
+++ b/third_party/libaddressinput/chromium/suggestions_unittest.cc
@@ -0,0 +1,356 @@
+// Copyright 2014 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be

[please use gerrit instead, 2014/06/05 22:22:49]

Remove this file! (PreloadAddressValidatorTests have all the tests.)

[please use gerrit instead, 2014/06/09 23:28:17]

Done.

+// found in the LICENSE file.
+
+#include "third_party/libaddressinput/chromium/suggestions.h"
+
+// Use "base/memory/scoped_ptr.h" instead.
+#define I18N_ADDRESSINPUT_UTIL_SCOPED_PTR_H_
+
+#include "base/basictypes.h"
+#include "base/memory/scoped_ptr.h"
+#include "testing/gtest/include/gtest/gtest.h"
+#include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_data.h"
+#include "third_party/libaddressinput/src/cpp/include/libaddressinput/null_storage.h"
+#include "third_party/libaddressinput/src/cpp/include/libaddressinput/preload_supplier.h"
+#include "third_party/libaddressinput/src/cpp/test/fake_downloader.h"
+
+namespace autofill {
+
+/*
+class SuggestionsTest : public testing::Test {
+ protected:
+  SuggestionsTest() : suggestions_() {}
+
+  virtual ~SuggestionsTest() {}
+
+  Suggestions suggestions_;
+
+ private:
+  DISALLOW_COPY_AND_ASSIGN(SuggestionsTest);
+};
+
+TEST_F(SuggestionsTest, Basic) {}
+
+TEST_F(ChromeAddressValidatorTest, SuggestAdminAreaForPostalCode) {
+  AddressData address;
+  address.region_code = "US";
+  address.postal_code = "90291";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("CA", suggestions[0].administrative_area);
+  EXPECT_EQ("90291", suggestions[0].postal_code);
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestLocalityForPostalCodeWithAdminArea) {
+  validator_->LoadRules("TW");
+  AddressData address;
+  address.region_code = "TW";
+  address.postal_code = "515";
+  address.administrative_area = "Changhua";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("Dacun Township", suggestions[0].locality);
+  EXPECT_EQ("Changhua County", suggestions[0].administrative_area);
+  EXPECT_EQ("515", suggestions[0].postal_code);
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestAdminAreaForPostalCodeWithLocality) {
+  validator_->LoadRules("TW");
+  AddressData address;
+  address.region_code = "TW";
+  address.postal_code = "515";
+  address.locality = "Dacun";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("Dacun Township", suggestions[0].locality);
+  EXPECT_EQ("Changhua County", suggestions[0].administrative_area);
+  EXPECT_EQ("515", suggestions[0].postal_code);
+}
+
+TEST_F(ChromeAddressValidatorTest, NoSuggestForPostalCodeWithWrongAdminArea) {
+  AddressData address;
+  address.region_code = "US";
+  address.postal_code = "90066";
+  address.postal_code = "TX";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
+  EXPECT_TRUE(suggestions.empty());
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestForLocality) {
+  validator_->LoadRules("CN");
+  AddressData address;
+  address.region_code = "CN";
+  address.locality = "Anqin";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, LOCALITY, 10, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("Anqing Shi", suggestions[0].locality);
+  EXPECT_EQ("ANHUI SHENG", suggestions[0].administrative_area);
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestForLocalityAndAdminArea) {
+  validator_->LoadRules("CN");
+  AddressData address;
+  address.region_code = "CN";
+  address.locality = "Anqing";
+  address.administrative_area = "Anhui";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, LOCALITY, 10, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_TRUE(suggestions[0].dependent_locality.empty());
+  EXPECT_EQ("Anqing Shi", suggestions[0].locality);
+  EXPECT_EQ("ANHUI SHENG", suggestions[0].administrative_area);
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestForAdminAreaAndLocality) {
+  validator_->LoadRules("CN");
+  AddressData address;
+  address.region_code = "CN";
+  address.locality = "Anqing";
+  address.administrative_area = "Anhui";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_TRUE(suggestions[0].dependent_locality.empty());
+  EXPECT_TRUE(suggestions[0].locality.empty());
+  EXPECT_EQ("ANHUI SHENG", suggestions[0].administrative_area);
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestForDependentLocality) {
+  validator_->LoadRules("CN");
+  AddressData address;
+  address.region_code = "CN";
+  address.dependent_locality = "Zongyang";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(
+                address, DEPENDENT_LOCALITY, 10, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("Zongyang Xian", suggestions[0].dependent_locality);
+  EXPECT_EQ("Anqing Shi", suggestions[0].locality);
+  EXPECT_EQ("ANHUI SHENG", suggestions[0].administrative_area);
+}
+
+TEST_F(ChromeAddressValidatorTest,
+       NoSuggestForDependentLocalityWithWrongAdminArea) {
+  validator_->LoadRules("CN");
+  AddressData address;
+  address.region_code = "CN";
+  address.dependent_locality = "Zongyang";
+  address.administrative_area = "Sichuan Sheng";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(
+                address, DEPENDENT_LOCALITY, 10, &suggestions));
+  EXPECT_TRUE(suggestions.empty());
+}
+
+TEST_F(ChromeAddressValidatorTest, EmptySuggestionsOverLimit) {
+  AddressData address;
+  address.region_code = "US";
+  address.administrative_area = "A";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, ADMIN_AREA, 1, &suggestions));
+  EXPECT_TRUE(suggestions.empty());
+}
+
+TEST_F(ChromeAddressValidatorTest, PreferShortSuggestions) {
+  AddressData address;
+  address.region_code = "US";
+  address.administrative_area = "CA";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("CA", suggestions[0].administrative_area);
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestTheSingleMatchForFullMatchName) {
+  AddressData address;
+  address.region_code = "US";
+  address.administrative_area = "Texas";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("Texas", suggestions[0].administrative_area);
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestAdminArea) {
+  AddressData address;
+  address.region_code = "US";
+  address.administrative_area = "Cali";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("California", suggestions[0].administrative_area);
+}
+
+TEST_F(ChromeAddressValidatorTest, MultipleSuggestions) {
+  AddressData address;
+  address.region_code = "US";
+  address.administrative_area = "MA";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions));
+  EXPECT_LT(1U, suggestions.size());
+
+  // Massachusetts should not be a suggestion, because it's already covered
+  // under MA.
+  std::set<std::string> expected_suggestions;
+  expected_suggestions.insert("MA");
+  expected_suggestions.insert("Maine");
+  expected_suggestions.insert("Marshall Islands");
+  expected_suggestions.insert("Maryland");
+  for (std::vector<AddressData>::const_iterator it = suggestions.begin();
+       it != suggestions.end(); ++it) {
+    expected_suggestions.erase(it->administrative_area);
+  }
+  EXPECT_TRUE(expected_suggestions.empty());
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestNonLatinKeyWhenLanguageMatches) {
+  validator_->LoadRules("KR");
+  AddressData address;
+  address.language_code = "ko";
+  address.region_code = "KR";
+  address.postal_code = "210-210";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("강원도", suggestions[0].administrative_area);
+  EXPECT_EQ("210-210", suggestions[0].postal_code);
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestNonLatinKeyWhenUserInputIsNotLatin) {
+  validator_->LoadRules("KR");
+  AddressData address;
+  address.language_code = "en";
+  address.region_code = "KR";
+  address.administrative_area = "강원";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, ADMIN_AREA, 1, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("강원도", suggestions[0].administrative_area);
+}
+
+TEST_F(ChromeAddressValidatorTest,
+       SuggestLatinNameWhenLanguageDiffersAndLatinNameAvailable) {
+  validator_->LoadRules("KR");
+  AddressData address;
+  address.language_code = "en";
+  address.region_code = "KR";
+  address.postal_code = "210-210";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("Gangwon", suggestions[0].administrative_area);
+  EXPECT_EQ("210-210", suggestions[0].postal_code);
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestLatinNameWhenUserInputIsLatin) {
+  validator_->LoadRules("KR");
+  AddressData address;
+  address.language_code = "ko";
+  address.region_code = "KR";
+  address.administrative_area = "Gang";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, ADMIN_AREA, 1, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("Gangwon", suggestions[0].administrative_area);
+}
+
+TEST_F(ChromeAddressValidatorTest, NoSuggestionsForEmptyAddress) {
+  AddressData address;
+  address.region_code = "US";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(
+      ChromeAddressValidator::SUCCESS,
+      validator_->GetSuggestions(address, POSTAL_CODE, 999, &suggestions));
+  EXPECT_TRUE(suggestions.empty());
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestionIncludesCountry) {
+  AddressData address;
+  address.region_code = "US";
+  address.postal_code = "90291";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
+  ASSERT_EQ(1U, suggestions.size());
+  EXPECT_EQ("US", suggestions[0].region_code);
+}
+
+TEST_F(ChromeAddressValidatorTest, SuggestOnlyForAdministrativeAreasAndPostalCode) {
+  AddressData address;
+  address.region_code = "US";
+  address.administrative_area = "CA";
+  address.locality = "Los Angeles";
+  address.dependent_locality = "Venice";
+  address.postal_code = "90291";
+  address.sorting_code = "123";
+  address.address_line.push_back("123 Main St");
+  address.recipient = "Jon Smith";
+
+  // Fields that should not have suggestions in US.
+  static const AddressField kNoSugestFields[] = {
+    COUNTRY,
+    LOCALITY,
+    DEPENDENT_LOCALITY,
+    SORTING_CODE,
+    STREET_ADDRESS,
+    RECIPIENT
+  };
+
+  static const size_t kNumNoSuggestFields =
+      sizeof kNoSugestFields / sizeof (AddressField);
+
+  for (size_t i = 0; i < kNumNoSuggestFields; ++i) {
+    std::vector<AddressData> suggestions;
+    EXPECT_EQ(ChromeAddressValidator::SUCCESS,
+              validator_->GetSuggestions(
+                  address, kNoSugestFields[i], 999, &suggestions));
+    EXPECT_TRUE(suggestions.empty());
+  }
+}
+*/
+
+}  // namespace