[Payments] Avoid a crash caused by AddressValidatorTest.

third_party/libaddressinput/chromium/chrome_address_validator_unittest.cc

 // Copyright 2014 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 "third_party/libaddressinput/chromium/chrome_address_validator.h"
 
 #include <stddef.h>
 #include <set>
 #include <string>
 #include <utility>
@@ skipping 34 matching lines @@
 using ::i18n::addressinput::STREET_ADDRESS;
 using ::i18n::addressinput::RECIPIENT;
 
 using ::i18n::addressinput::INVALID_FORMAT;
 using ::i18n::addressinput::MISMATCHING_VALUE;
 using ::i18n::addressinput::MISSING_REQUIRED_FIELD;
 using ::i18n::addressinput::UNEXPECTED_FIELD;
 using ::i18n::addressinput::UNKNOWN_VALUE;
 using ::i18n::addressinput::USES_P_O_BOX;
 
+// This class should always succeed in getting the rules.
 class AddressValidatorTest : public testing::Test, LoadRulesListener {
  protected:
   AddressValidatorTest()
       : validator_(new AddressValidator(
             std::unique_ptr<Source>(new TestdataSource(true)),
             std::unique_ptr<Storage>(new NullStorage),
             this)) {
     validator_->LoadRules("US");
   }
 
+  void set_expected_status(AddressValidator::Status expected_status) {
+    expected_status_ = expected_status;
+  }
+
   virtual ~AddressValidatorTest() {}
 
   const std::unique_ptr<AddressValidator> validator_;
 
  private:
   // LoadRulesListener implementation.
   void OnAddressValidationRulesLoaded(const std::string& country_code,
                                       bool success) override {
     AddressData address_data;
     address_data.region_code = country_code;
     FieldProblemMap dummy;
     AddressValidator::Status status =
         validator_->ValidateAddress(address_data, NULL, &dummy);
-    ASSERT_EQ(success, status == AddressValidator::SUCCESS);
+    ASSERT_EQ(expected_status_, status);
   }
 
+  AddressValidator::Status expected_status_ = AddressValidator::SUCCESS;
+
   DISALLOW_COPY_AND_ASSIGN(AddressValidatorTest);
 };
 
 // Use this test fixture if you're going to use a region with a large set of
 // validation rules. All rules should be loaded in SetUpTestCase().
 class LargeAddressValidatorTest : public testing::Test {
  protected:
   LargeAddressValidatorTest() {}
   virtual ~LargeAddressValidatorTest() {}
 
@@ skipping 24 matching lines @@
   const std::string country_code = "US";
   const std::string first_state = "AL";
 
   validator_->LoadRules(country_code);
   std::vector<std::string> sub_keys =
       validator_->GetRegionSubKeys(country_code);
   ASSERT_FALSE(sub_keys.empty());
   ASSERT_EQ(sub_keys[0], first_state);
 }
 
-TEST_F(AddressValidatorTest, SubKeysNotLoaded) {
-  const std::string country_code = "ZZ";
+TEST_F(AddressValidatorTest, SubKeysNotExist) {
+  const std::string country_code = "OZ";
+
+  set_expected_status(AddressValidator::RULES_UNAVAILABLE);
 
   validator_->LoadRules(country_code);
   std::vector<std::string> sub_keys =
       validator_->GetRegionSubKeys(country_code);
   ASSERT_TRUE(sub_keys.empty());
 }
 
 TEST_F(AddressValidatorTest, RegionHasRules) {
   const std::vector<std::string>& region_codes = GetRegionCodes();
   AddressData address;
@@ skipping 603 matching lines @@
   EXPECT_FALSE(problems.empty());
 
   for (FieldProblemMap::const_iterator it = problems.begin();
        it != problems.end();
        ++it) {
     EXPECT_EQ(MISSING_REQUIRED_FIELD, it->second);
   }
 }
 
 TEST_F(AddressValidatorTest,
-       DoNotValidateRequiredFieldsWithoutRulesWhenErorrIsFiltered) {
+       DoNotValidateRequiredFieldsWithoutRulesWhenErrorIsFiltered) {
   // Do not load the rules for JP.
   AddressData address;
   address.region_code = "JP";
 
   FieldProblemMap filter;
   filter.insert(std::make_pair(COUNTRY, UNKNOWN_VALUE));
 
   FieldProblemMap problems;
   EXPECT_EQ(AddressValidator::RULES_UNAVAILABLE,
             validator_->ValidateAddress(address, &filter, &problems));
@@ skipping 149 matching lines @@
   source_->set_failures_number(99);
   validator_->LoadRules("CH");
   validator_->LoadRules("GB");
   base::RunLoop().RunUntilIdle();
 
   EXPECT_FALSE(load_rules_success_);
   EXPECT_EQ(16, source_->attempts_number());
 }
 
 }  // namespace autofill