Use upstream libaddressinput in Chrome.

third_party/libaddressinput/chromium/preload_address_validator_unittest.cc

Index: third_party/libaddressinput/chromium/preload_address_validator_unittest.cc
diff --git a/third_party/libaddressinput/chromium/preload_address_validator_unittest.cc b/third_party/libaddressinput/chromium/preload_address_validator_unittest.cc
index 1cc7aafe7bff1277e7cd7173152205f9cf266595..2d568aecbd675bb5d6b0e8254514ea203d1850a4 100644
--- a/third_party/libaddressinput/chromium/preload_address_validator_unittest.cc
+++ b/third_party/libaddressinput/chromium/preload_address_validator_unittest.cc
@@ -10,8 +10,7 @@
 #include "base/macros.h"
 #include "base/memory/scoped_ptr.h"
 #include "testing/gtest/include/gtest/gtest.h"
-
-#define I18N_ADDRESSINPUT_UTIL_BASICTYPES_H_
+#include "third_party/libaddressinput/chromium/load_rules_delegate.h"
 #include "third_party/libaddressinput/chromium/preload_address_validator.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_data.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_field.h"
@@ -26,7 +25,8 @@
 
 namespace {
 
-using ::autofill::PreloadAddressValidator;
+using ::autofill::AddressValidator;
+using ::autofill::LoadRulesDelegate;
 using ::i18n::addressinput::AddressData;
 using ::i18n::addressinput::AddressField;
 using ::i18n::addressinput::BuildCallback;
@@ -50,64 +50,77 @@ using ::i18n::addressinput::UNKNOWN_VALUE;
 using ::i18n::addressinput::INVALID_FORMAT;
 using ::i18n::addressinput::MISMATCHING_VALUE;
 
-class PreloadAddressValidatorTest : public testing::Test {
+class AddressValidatorTest : public testing::Test, LoadRulesDelegate {
  protected:
-  PreloadAddressValidatorTest()
+  AddressValidatorTest()
       : validator_(
-          new PreloadAddressValidator(
+          new AddressValidator(
               FakeDownloader::kFakeAggregateDataUrl,
               scoped_ptr<Downloader>(new FakeDownloader),
-              scoped_ptr<Storage>(new NullStorage))),
-        loaded_(BuildCallback(this, &PreloadAddressValidatorTest::Loaded)) {
-    validator_->LoadRules("US", *loaded_);
+              scoped_ptr<Storage>(new NullStorage),
+              this)) {
+    validator_->LoadRules("US");
   }
 
-  virtual ~PreloadAddressValidatorTest() {}
+  virtual ~AddressValidatorTest() {}
 
-  const scoped_ptr<PreloadAddressValidator> validator_;
-  const scoped_ptr<PreloadAddressValidator::Callback> loaded_;
+  const scoped_ptr<AddressValidator> validator_;
 
  private:
-  void Loaded(bool success,
-              const std::string& region_code,
-              const int& rule_count) {
+  // LoadRulesDelegate implementation.
+  virtual void OnAddressValidationRulesLoaded(const std::string& country_code,
+                                              bool success) OVERRIDE {
     AddressData address_data;
-    address_data.region_code = region_code;
+    address_data.region_code = country_code;
     FieldProblemMap dummy;
-    PreloadAddressValidator::Status status =
-        validator_->Validate(address_data, NULL, &dummy);
-    ASSERT_EQ(success, status == PreloadAddressValidator::SUCCESS);
+    AddressValidator::Status status =
+        validator_->ValidateAddress(address_data, NULL, &dummy);
+    ASSERT_EQ(success, status == AddressValidator::SUCCESS);
   }
 
-  DISALLOW_COPY_AND_ASSIGN(PreloadAddressValidatorTest);
+  DISALLOW_COPY_AND_ASSIGN(AddressValidatorTest);
 };
 
-TEST_F(PreloadAddressValidatorTest, RegionHasRules) {
+TEST_F(AddressValidatorTest, RegionHasRules) {
   const std::vector<std::string>& region_codes =
       RegionDataConstants::GetRegionCodes();
   AddressData address;
   for (size_t i = 0; i < region_codes.size(); ++i) {
     SCOPED_TRACE("For region: " + region_codes[i]);
-    validator_->LoadRules(region_codes[i], *loaded_);
+    validator_->LoadRules(region_codes[i]);
     address.region_code = region_codes[i];
     FieldProblemMap dummy;
     EXPECT_EQ(
-        PreloadAddressValidator::SUCCESS,
-        validator_->Validate(address, NULL, &dummy));
+        AddressValidator::SUCCESS,
+        validator_->ValidateAddress(address, NULL, &dummy));
   }
 }
 
-TEST_F(PreloadAddressValidatorTest, EmptyAddressNoFatalFailure) {
+TEST_F(AddressValidatorTest, EmptyAddressNoFatalFailure) {
   AddressData address;
   address.region_code = "US";
 
   FieldProblemMap dummy;
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &dummy));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &dummy));
 }
 
-TEST_F(PreloadAddressValidatorTest, USZipCode) {
+TEST_F(AddressValidatorTest, UsStateNamesAreValidEntries) {
+  AddressData address;
+  address.region_code = "US";
+  address.administrative_area = "California";
+
+  FieldProblemMap filter;
+  filter.insert(std::make_pair(ADMIN_AREA, UNKNOWN_VALUE));
+  FieldProblemMap problems;
+  EXPECT_EQ(
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, &filter, &problems));
+  EXPECT_TRUE(problems.empty());
+}
+
+TEST_F(AddressValidatorTest, USZipCode) {
   AddressData address;
   address.address_line.push_back("340 Main St.");
   address.locality = "Venice";
@@ -118,8 +131,8 @@ TEST_F(PreloadAddressValidatorTest, USZipCode) {
   address.postal_code = "90291";
   FieldProblemMap problems;
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &problems));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &problems));
   EXPECT_TRUE(problems.empty());
 
   problems.clear();
@@ -127,8 +140,8 @@ TEST_F(PreloadAddressValidatorTest, USZipCode) {
   // An extended, valid Californian zip code.
   address.postal_code = "90210-1234";
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &problems));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &problems));
   EXPECT_TRUE(problems.empty());
 
   problems.clear();
@@ -136,8 +149,8 @@ TEST_F(PreloadAddressValidatorTest, USZipCode) {
   // New York zip code (which is invalid for California).
   address.postal_code = "12345";
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &problems));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &problems));
   EXPECT_EQ(1U, problems.size());
   EXPECT_EQ(problems.begin()->first, POSTAL_CODE);
   EXPECT_EQ(problems.begin()->second, MISMATCHING_VALUE);
@@ -147,8 +160,8 @@ TEST_F(PreloadAddressValidatorTest, USZipCode) {
   // A zip code with a "90" in the middle.
   address.postal_code = "12903";
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &problems));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &problems));
   EXPECT_EQ(1U, problems.size());
   EXPECT_EQ(problems.begin()->first, POSTAL_CODE);
   EXPECT_EQ(problems.begin()->second, MISMATCHING_VALUE);
@@ -158,8 +171,8 @@ TEST_F(PreloadAddressValidatorTest, USZipCode) {
   // Invalid zip code (too many digits).
   address.postal_code = "902911";
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &problems));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &problems));
   EXPECT_EQ(1U, problems.size());
   EXPECT_EQ(problems.begin()->first, POSTAL_CODE);
   EXPECT_EQ(problems.begin()->second, INVALID_FORMAT);
@@ -169,18 +182,16 @@ TEST_F(PreloadAddressValidatorTest, USZipCode) {
   // Invalid zip code (too few digits).
   address.postal_code = "9029";
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &problems));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &problems));
   EXPECT_EQ(1U, problems.size());
   EXPECT_EQ(problems.begin()->first, POSTAL_CODE);
   EXPECT_EQ(problems.begin()->second, INVALID_FORMAT);
 }
 
-// Test case disabled because libaddressinput address validation doesn't do
-// those kinds of normalizations that this test case expects. TODO: Something.
-TEST_F(PreloadAddressValidatorTest, DISABLED_BasicValidation) {
+TEST_F(AddressValidatorTest, BasicValidation) {
   // US rules should always be available, even though this load call fails.
-  validator_->LoadRules("US", *loaded_);
+  validator_->LoadRules("US");
   AddressData address;
   address.region_code = "US";
   address.language_code = "en";
@@ -190,46 +201,46 @@ TEST_F(PreloadAddressValidatorTest, DISABLED_BasicValidation) {
   address.address_line.push_back("123 Main St");
   FieldProblemMap problems;
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &problems));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &problems));
   EXPECT_TRUE(problems.empty());
 
   // The display name works as well as the key.
   address.administrative_area = "Texas";
   problems.clear();
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &problems));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &problems));
   EXPECT_TRUE(problems.empty());
 
   // Ignore capitalization.
   address.administrative_area = "tx";
   problems.clear();
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &problems));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &problems));
   EXPECT_TRUE(problems.empty());
 
   // Ignore capitalization.
   address.administrative_area = "teXas";
   problems.clear();
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &problems));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &problems));
   EXPECT_TRUE(problems.empty());
 
   // Ignore diacriticals.
   address.administrative_area = "T\u00E9xas";
   problems.clear();
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &problems));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &problems));
   EXPECT_TRUE(problems.empty());
 }
 
-TEST_F(PreloadAddressValidatorTest, BasicValidationFailure) {
+TEST_F(AddressValidatorTest, BasicValidationFailure) {
   // US rules should always be available, even though this load call fails.
-  validator_->LoadRules("US", *loaded_);
+  validator_->LoadRules("US");
   AddressData address;
   address.region_code = "US";
   address.language_code = "en";
@@ -239,43 +250,44 @@ TEST_F(PreloadAddressValidatorTest, BasicValidationFailure) {
   address.address_line.push_back("123 Main St");
   FieldProblemMap problems;
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
-      validator_->Validate(address, NULL, &problems));
+      AddressValidator::SUCCESS,
+      validator_->ValidateAddress(address, NULL, &problems));
 
   ASSERT_EQ(1U, problems.size());
   EXPECT_EQ(UNKNOWN_VALUE, problems.begin()->second);
   EXPECT_EQ(ADMIN_AREA, problems.begin()->first);
 }
 
-TEST_F(PreloadAddressValidatorTest, NoNullSuggestionsCrash) {
+TEST_F(AddressValidatorTest, NoNullSuggestionsCrash) {
   AddressData address;
   address.region_code = "US";
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::SUCCESS,
             validator_->GetSuggestions(address, COUNTRY, 1, NULL));
 }
 
-TEST_F(PreloadAddressValidatorTest, SuggestAdminAreaForPostalCode) {
+TEST_F(AddressValidatorTest, SuggestAdminAreaForPostalCode) {
   AddressData address;
   address.region_code = "US";
   address.postal_code = "90291";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::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(PreloadAddressValidatorTest, SuggestLocalityForPostalCodeWithAdminArea) {
-  validator_->LoadRules("TW", *loaded_);
+TEST_F(AddressValidatorTest, SuggestLocalityForPostalCodeWithAdminArea) {
+  validator_->LoadRules("TW");
   AddressData address;
   address.region_code = "TW";
   address.postal_code = "515";
   address.administrative_area = "Changhua";
+  address.language_code = "zh-Latn";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::SUCCESS,
             validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
   ASSERT_EQ(1U, suggestions.size());
   EXPECT_EQ("Dacun Township", suggestions[0].locality);
@@ -283,15 +295,16 @@ TEST_F(PreloadAddressValidatorTest, SuggestLocalityForPostalCodeWithAdminArea) {
   EXPECT_EQ("515", suggestions[0].postal_code);
 }
 
-TEST_F(PreloadAddressValidatorTest, SuggestAdminAreaForPostalCodeWithLocality) {
-  validator_->LoadRules("TW", *loaded_);
+TEST_F(AddressValidatorTest, SuggestAdminAreaForPostalCodeWithLocality) {
+  validator_->LoadRules("TW");
   AddressData address;
   address.region_code = "TW";
   address.postal_code = "515";
   address.locality = "Dacun";
+  address.language_code = "zh-Latn";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::SUCCESS,
             validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
   ASSERT_EQ(1U, suggestions.size());
   EXPECT_EQ("Dacun Township", suggestions[0].locality);
@@ -299,149 +312,154 @@ TEST_F(PreloadAddressValidatorTest, SuggestAdminAreaForPostalCodeWithLocality) {
   EXPECT_EQ("515", suggestions[0].postal_code);
 }
 
-TEST_F(PreloadAddressValidatorTest, NoSuggestForPostalCodeWithWrongAdminArea) {
+TEST_F(AddressValidatorTest, NoSuggestForPostalCodeWithWrongAdminArea) {
   AddressData address;
   address.region_code = "US";
   address.postal_code = "90066";
   address.postal_code = "TX";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::SUCCESS,
             validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
   EXPECT_TRUE(suggestions.empty());
 }
 
-TEST_F(PreloadAddressValidatorTest, SuggestForLocality) {
-  validator_->LoadRules("CN", *loaded_);
+TEST_F(AddressValidatorTest, SuggestForLocality) {
+  validator_->LoadRules("CN");
   AddressData address;
   address.region_code = "CN";
   address.locality = "Anqin";
+  address.language_code = "zh-Latn";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::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);
+  EXPECT_EQ("Anhui Sheng", suggestions[0].administrative_area);
 }
 
-TEST_F(PreloadAddressValidatorTest, SuggestForLocalityAndAdminArea) {
-  validator_->LoadRules("CN", *loaded_);
+TEST_F(AddressValidatorTest, SuggestForLocalityAndAdminArea) {
+  validator_->LoadRules("CN");
   AddressData address;
   address.region_code = "CN";
   address.locality = "Anqing";
   address.administrative_area = "Anhui";
+  address.language_code = "zh-Latn";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::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);
+  EXPECT_EQ("Anhui Sheng", suggestions[0].administrative_area);
 }
 
-TEST_F(PreloadAddressValidatorTest, SuggestForAdminAreaAndLocality) {
-  validator_->LoadRules("CN", *loaded_);
+TEST_F(AddressValidatorTest, SuggestForAdminAreaAndLocality) {
+  validator_->LoadRules("CN");
   AddressData address;
   address.region_code = "CN";
   address.locality = "Anqing";
   address.administrative_area = "Anhui";
+  address.language_code = "zh-Latn";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::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);
+  EXPECT_EQ("Anhui Sheng", suggestions[0].administrative_area);
 }
 
-TEST_F(PreloadAddressValidatorTest, SuggestForDependentLocality) {
-  validator_->LoadRules("CN", *loaded_);
+TEST_F(AddressValidatorTest, SuggestForDependentLocality) {
+  validator_->LoadRules("CN");
   AddressData address;
   address.region_code = "CN";
   address.dependent_locality = "Zongyang";
+  address.language_code = "zh-Latn";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::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);
+  EXPECT_EQ("Anhui Sheng", suggestions[0].administrative_area);
 }
 
-TEST_F(PreloadAddressValidatorTest,
+TEST_F(AddressValidatorTest,
        NoSuggestForDependentLocalityWithWrongAdminArea) {
-  validator_->LoadRules("CN", *loaded_);
+  validator_->LoadRules("CN");
   AddressData address;
   address.region_code = "CN";
   address.dependent_locality = "Zongyang";
   address.administrative_area = "Sichuan Sheng";
+  address.language_code = "zh-Latn";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::SUCCESS,
             validator_->GetSuggestions(
                 address, DEPENDENT_LOCALITY, 10, &suggestions));
   EXPECT_TRUE(suggestions.empty());
 }
 
-TEST_F(PreloadAddressValidatorTest, EmptySuggestionsOverLimit) {
+TEST_F(AddressValidatorTest, EmptySuggestionsOverLimit) {
   AddressData address;
   address.region_code = "US";
   address.administrative_area = "A";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::SUCCESS,
             validator_->GetSuggestions(address, ADMIN_AREA, 1, &suggestions));
   EXPECT_TRUE(suggestions.empty());
 }
 
-TEST_F(PreloadAddressValidatorTest, PreferShortSuggestions) {
+TEST_F(AddressValidatorTest, PreferShortSuggestions) {
   AddressData address;
   address.region_code = "US";
   address.administrative_area = "CA";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::SUCCESS,
             validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions));
   ASSERT_EQ(1U, suggestions.size());
   EXPECT_EQ("CA", suggestions[0].administrative_area);
 }
 
-TEST_F(PreloadAddressValidatorTest, SuggestTheSingleMatchForFullMatchName) {
+TEST_F(AddressValidatorTest, SuggestTheSingleMatchForFullMatchName) {
   AddressData address;
   address.region_code = "US";
   address.administrative_area = "Texas";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::SUCCESS,
             validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions));
   ASSERT_EQ(1U, suggestions.size());
   EXPECT_EQ("Texas", suggestions[0].administrative_area);
 }
 
-TEST_F(PreloadAddressValidatorTest, SuggestAdminArea) {
+TEST_F(AddressValidatorTest, SuggestAdminArea) {
   AddressData address;
   address.region_code = "US";
   address.administrative_area = "Cali";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::SUCCESS,
             validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions));
   ASSERT_EQ(1U, suggestions.size());
   EXPECT_EQ("California", suggestions[0].administrative_area);
 }
 
-TEST_F(PreloadAddressValidatorTest, MultipleSuggestions) {
+TEST_F(AddressValidatorTest, MultipleSuggestions) {
   AddressData address;
   address.region_code = "US";
   address.administrative_area = "MA";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::SUCCESS,
             validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions));
   EXPECT_LT(1U, suggestions.size());
 
@@ -459,89 +477,100 @@ TEST_F(PreloadAddressValidatorTest, MultipleSuggestions) {
   EXPECT_TRUE(expected_suggestions.empty());
 }
 
-TEST_F(PreloadAddressValidatorTest, SuggestNonLatinKeyWhenLanguageMatches) {
-  validator_->LoadRules("KR", *loaded_);
+TEST_F(AddressValidatorTest, 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(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::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(PreloadAddressValidatorTest, SuggestNonLatinKeyWhenUserInputIsNotLatin) {
-  validator_->LoadRules("KR", *loaded_);
+TEST_F(AddressValidatorTest, SuggestNonLatinKeyWhenUserInputIsNotLatin) {
+  validator_->LoadRules("KR");
   AddressData address;
   address.language_code = "en";
   address.region_code = "KR";
   address.administrative_area = "강원";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::SUCCESS,
             validator_->GetSuggestions(address, ADMIN_AREA, 1, &suggestions));
   ASSERT_EQ(1U, suggestions.size());
   EXPECT_EQ("강원도", suggestions[0].administrative_area);
 }
 
-TEST_F(PreloadAddressValidatorTest,
+TEST_F(AddressValidatorTest,
        SuggestLatinNameWhenLanguageDiffersAndLatinNameAvailable) {
-  validator_->LoadRules("KR", *loaded_);
+  validator_->LoadRules("KR");
   AddressData address;
-  address.language_code = "en";
+  address.language_code = "ko-Latn";
   address.region_code = "KR";
   address.postal_code = "210-210";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+  EXPECT_EQ(AddressValidator::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(PreloadAddressValidatorTest, SuggestLatinNameWhenUserInputIsLatin) {
-  validator_->LoadRules("KR", *loaded_);
+TEST_F(AddressValidatorTest, NoSuggestionsForEmptyAddress) {
   AddressData address;
-  address.language_code = "ko";
-  address.region_code = "KR";
-  address.administrative_area = "Gang";
+  address.region_code = "US";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
-            validator_->GetSuggestions(address, ADMIN_AREA, 1, &suggestions));
+  EXPECT_EQ(
+      AddressValidator::SUCCESS,
+      validator_->GetSuggestions(address, POSTAL_CODE, 999, &suggestions));
+  EXPECT_TRUE(suggestions.empty());
+}
+
+TEST_F(AddressValidatorTest, SuggestionIncludesCountry) {
+  AddressData address;
+  address.region_code = "US";
+  address.postal_code = "90291";
+
+  std::vector<AddressData> suggestions;
+  EXPECT_EQ(AddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
   ASSERT_EQ(1U, suggestions.size());
-  EXPECT_EQ("Gangwon", suggestions[0].administrative_area);
+  EXPECT_EQ("US", suggestions[0].region_code);
 }
 
-TEST_F(PreloadAddressValidatorTest, NoSuggestionsForEmptyAddress) {
+TEST_F(AddressValidatorTest, InvalidPostalCodeNoSuggestions) {
   AddressData address;
   address.region_code = "US";
+  address.postal_code = "0";
 
   std::vector<AddressData> suggestions;
   EXPECT_EQ(
-      PreloadAddressValidator::SUCCESS,
+      AddressValidator::SUCCESS,
       validator_->GetSuggestions(address, POSTAL_CODE, 999, &suggestions));
   EXPECT_TRUE(suggestions.empty());
 }
 
-TEST_F(PreloadAddressValidatorTest, SuggestionIncludesCountry) {
+TEST_F(AddressValidatorTest, MismatchedPostalCodeNoSuggestions) {
   AddressData address;
   address.region_code = "US";
+  address.administrative_area = "TX";
   address.postal_code = "90291";
 
   std::vector<AddressData> suggestions;
-  EXPECT_EQ(PreloadAddressValidator::SUCCESS,
-            validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
-  ASSERT_EQ(1U, suggestions.size());
-  EXPECT_EQ("US", suggestions[0].region_code);
+  EXPECT_EQ(
+      AddressValidator::SUCCESS,
+      validator_->GetSuggestions(address, POSTAL_CODE, 999, &suggestions));
+  EXPECT_TRUE(suggestions.empty());
 }
 
-TEST_F(PreloadAddressValidatorTest,
+TEST_F(AddressValidatorTest,
        SuggestOnlyForAdministrativeAreasAndPostalCode) {
   AddressData address;
   address.region_code = "US";
@@ -568,14 +597,24 @@ TEST_F(PreloadAddressValidatorTest,
 
   for (size_t i = 0; i < kNumNoSuggestFields; ++i) {
     std::vector<AddressData> suggestions;
-    EXPECT_EQ(PreloadAddressValidator::SUCCESS,
+    EXPECT_EQ(AddressValidator::SUCCESS,
               validator_->GetSuggestions(
                   address, kNoSugestFields[i], 999, &suggestions));
     EXPECT_TRUE(suggestions.empty());
   }
 }
 
-TEST_F(PreloadAddressValidatorTest, CanonicalizeUsAdminAreaName) {
+TEST_F(AddressValidatorTest, SuggestionsAreCleared) {
+  AddressData address;
+  address.region_code = "US";
+
+  std::vector<AddressData> suggestions(1, address);
+  EXPECT_EQ(AddressValidator::SUCCESS,
+            validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions));
+  EXPECT_TRUE(suggestions.empty());
+}
+
+TEST_F(AddressValidatorTest, CanonicalizeUsAdminAreaName) {
   AddressData address;
   address.region_code = "US";
   address.administrative_area = "cALIFORNIa";
@@ -583,7 +622,7 @@ TEST_F(PreloadAddressValidatorTest, CanonicalizeUsAdminAreaName) {
   EXPECT_EQ("CA", address.administrative_area);
 }
 
-TEST_F(PreloadAddressValidatorTest, CanonicalizeUsAdminAreaKey) {
+TEST_F(AddressValidatorTest, CanonicalizeUsAdminAreaKey) {
   AddressData address;
   address.region_code = "US";
   address.administrative_area = "CA";
@@ -591,8 +630,8 @@ TEST_F(PreloadAddressValidatorTest, CanonicalizeUsAdminAreaKey) {
   EXPECT_EQ("CA", address.administrative_area);
 }
 
-TEST_F(PreloadAddressValidatorTest, CanonicalizeJpAdminAreaKey) {
-  validator_->LoadRules("JP", *loaded_);
+TEST_F(AddressValidatorTest, CanonicalizeJpAdminAreaKey) {
+  validator_->LoadRules("JP");
   AddressData address;
   address.region_code = "JP";
   address.administrative_area = "東京都";
@@ -600,8 +639,8 @@ TEST_F(PreloadAddressValidatorTest, CanonicalizeJpAdminAreaKey) {
   EXPECT_EQ("東京都", address.administrative_area);
 }
 
-TEST_F(PreloadAddressValidatorTest, CanonicalizeJpAdminAreaLatinName) {
-  validator_->LoadRules("JP", *loaded_);
+TEST_F(AddressValidatorTest, CanonicalizeJpAdminAreaLatinName) {
+  validator_->LoadRules("JP");
   AddressData address;
   address.region_code = "JP";
   address.administrative_area = "tOKYo";