Use dropdown list for admin areas in pr form.

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>
 #include <vector>
 
 #include "base/macros.h"
 #include "base/message_loop/message_loop.h"
 #include "base/run_loop.h"
 #include "base/strings/utf_string_conversions.h"
 #include "testing/gtest/include/gtest/gtest.h"
 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_data.h"
@@ skipping 42 matching lines @@
             this)) {
     validator_->LoadRules("US");
   }
 
   virtual ~AddressValidatorTest() {}
 
   const std::unique_ptr<AddressValidator> validator_;
 
  private:
   // LoadRulesListener implementation.
-  virtual void OnAddressValidationRulesLoaded(const std::string& country_code,
-                                              bool success) override {
+  void OnAddressRulesLoaded(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);
   }
 
   DISALLOW_COPY_AND_ASSIGN(AddressValidatorTest);
 };
@@ skipping 21 matching lines @@
 
   // Owned shared instance of validator with large sets validation rules.
   static AddressValidator* validator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(LargeAddressValidatorTest);
 };
 
 AddressValidator* LargeAddressValidatorTest::validator_ = NULL;
 
+TEST_F(AddressValidatorTest, SubKeysLoaded) {
+  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";
+
+  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;
   for (size_t i = 0; i < region_codes.size(); ++i) {
     SCOPED_TRACE("For region: " + region_codes[i]);
     validator_->LoadRules(region_codes[i]);
     address.region_code = region_codes[i];
     FieldProblemMap dummy;
     EXPECT_EQ(AddressValidator::SUCCESS,
               validator_->ValidateAddress(address, NULL, &dummy));
@@ skipping 628 matching lines @@
     TestAddressValidator(std::unique_ptr<::i18n::addressinput::Source> source,
                          std::unique_ptr<::i18n::addressinput::Storage> storage,
                          LoadRulesListener* load_rules_listener)
         : AddressValidator(std::move(source),
                            std::move(storage),
                            load_rules_listener) {}
 
     virtual ~TestAddressValidator() {}
 
    protected:
-    virtual base::TimeDelta GetBaseRetryPeriod() const override {
+    base::TimeDelta GetBaseRetryPeriod() const override {
       return base::TimeDelta::FromSeconds(0);
     }
 
    private:
     DISALLOW_COPY_AND_ASSIGN(TestAddressValidator);
   };
 
   // A source that always fails |failures_number| times before downloading
   // data.
   class FailingSource : public Source {
    public:
-    explicit FailingSource()
+    FailingSource()
         : failures_number_(0), attempts_number_(0), actual_source_(true) {}
     virtual ~FailingSource() {}
 
     // Sets the number of times to fail before downloading data.
     void set_failures_number(int failures_number) {
       failures_number_ = failures_number;
     }
 
     // Source implementation.
     // Always fails for the first |failures_number| times.
-    virtual void Get(const std::string& url,
-                     const Callback& callback) const override {
+    void Get(const std::string& url, const Callback& callback) const override {
       ++attempts_number_;
       // |callback| takes ownership of the |new std::string|.
       if (failures_number_-- > 0)
         callback(false, url, new std::string);
       else
         actual_source_.Get(url, callback);
     }
 
     // Returns the number of download attempts.
     int attempts_number() const { return attempts_number_; }
@@ skipping 20 matching lines @@
         load_rules_success_(false) {}
 
   virtual ~FailingAddressValidatorTest() {}
 
   FailingSource* source_;  // Owned by |validator_|.
   std::unique_ptr<AddressValidator> validator_;
   bool load_rules_success_;
 
  private:
   // LoadRulesListener implementation.
-  virtual void OnAddressValidationRulesLoaded(const std::string&,
-                                              bool success) override {
+  void OnAddressRulesLoaded(const std::string&, bool success) override {
     load_rules_success_ = success;
   }
 
   base::MessageLoop ui_;
 
   DISALLOW_COPY_AND_ASSIGN(FailingAddressValidatorTest);
 };
 
 // The validator will attempt to load rules at most 8 times.
 TEST_F(FailingAddressValidatorTest, RetryLoadingRulesHasLimit) {
@@ skipping 53 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