Home | History | Annotate | Download | only in test 
      1 // Copyright (C) 2014 Google Inc.
      2 //
      3 // Licensed under the Apache License, Version 2.0 (the "License");
      4 // you may not use this file except in compliance with the License.
      5 // You may obtain a copy of the License at
      6 //
      7 // http://www.apache.org/licenses/LICENSE-2.0
      8 //
      9 // Unless required by applicable law or agreed to in writing, software
     10 // distributed under the License is distributed on an "AS IS" BASIS,
     11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     12 // See the License for the specific language governing permissions and
     13 // limitations under the License.
     14 
     15 #include <libaddressinput/preload_supplier.h>
     16 
     17 #include <libaddressinput/address_data.h>
     18 #include <libaddressinput/callback.h>
     19 #include <libaddressinput/null_storage.h>
     20 #include <libaddressinput/util/basictypes.h>
     21 #include <libaddressinput/util/scoped_ptr.h>
     22 
     23 #include <cstddef>
     24 #include <string>
     25 
     26 #include <gtest/gtest.h>
     27 
     28 #include "lookup_key.h"
     29 #include "rule.h"
     30 #include "testdata_source.h"
     31 
     32 namespace {
     33 
     34 using i18n::addressinput::AddressData;
     35 using i18n::addressinput::BuildCallback;
     36 using i18n::addressinput::LookupKey;
     37 using i18n::addressinput::NullStorage;
     38 using i18n::addressinput::PreloadSupplier;
     39 using i18n::addressinput::Rule;
     40 using i18n::addressinput::scoped_ptr;
     41 using i18n::addressinput::TestdataSource;
     42 
     43 class PreloadSupplierTest : public testing::Test {
     44  protected:
     45   PreloadSupplierTest()
     46       : supplier_(new TestdataSource(true), new NullStorage),
     47         loaded_callback_(BuildCallback(this, &PreloadSupplierTest::OnLoaded)) {}
     48 
     49   PreloadSupplier supplier_;
     50   const scoped_ptr<const PreloadSupplier::Callback> loaded_callback_;
     51 
     52  private:
     53   void OnLoaded(bool success, const std::string& region_code, int num_rules) {
     54     ASSERT_TRUE(success);
     55     ASSERT_FALSE(region_code.empty());
     56     ASSERT_LT(0, num_rules);
     57     ASSERT_TRUE(supplier_.IsLoaded(region_code));
     58   }
     59 
     60   DISALLOW_COPY_AND_ASSIGN(PreloadSupplierTest);
     61 };
     62 
     63 TEST_F(PreloadSupplierTest, GetUsRule) {
     64   supplier_.LoadRules("US", *loaded_callback_);
     65   LookupKey us_key;
     66   AddressData us_address;
     67   us_address.region_code = "US";
     68   us_key.FromAddress(us_address);
     69   const Rule* rule = supplier_.GetRule(us_key);
     70   ASSERT_TRUE(rule != NULL);
     71   EXPECT_EQ("data/US", rule->GetId());
     72 }
     73 
     74 TEST_F(PreloadSupplierTest, GetUsCaRule) {
     75   supplier_.LoadRules("US", *loaded_callback_);
     76   LookupKey ca_key;
     77   AddressData ca_address;
     78   ca_address.region_code = "US";
     79   ca_address.administrative_area = "CA";
     80   ca_key.FromAddress(ca_address);
     81   const Rule* rule = supplier_.GetRule(ca_key);
     82   ASSERT_TRUE(rule != NULL);
     83   EXPECT_EQ("data/US/CA", rule->GetId());
     84 }
     85 
     86 TEST_F(PreloadSupplierTest, GetZwRule) {
     87   supplier_.LoadRules("ZW", *loaded_callback_);
     88   LookupKey zw_key;
     89   AddressData zw_address;
     90   zw_address.region_code = "ZW";
     91   zw_key.FromAddress(zw_address);
     92   const Rule* rule = supplier_.GetRule(zw_key);
     93   ASSERT_TRUE(rule != NULL);
     94   EXPECT_EQ("data/ZW", rule->GetId());
     95 }
     96 
     97 TEST_F(PreloadSupplierTest, GetUnknownRule) {
     98   supplier_.LoadRules("US", *loaded_callback_);
     99   LookupKey unknown_key;
    100   AddressData unknown_address;
    101   unknown_address.region_code = "US";
    102   unknown_address.administrative_area = "ZZ";
    103   unknown_key.FromAddress(unknown_address);
    104   const Rule* rule = supplier_.GetRule(unknown_key);
    105   EXPECT_TRUE(rule == NULL);
    106 }
    107 
    108 TEST_F(PreloadSupplierTest, GetTooPreciseRule) {
    109   supplier_.LoadRules("US", *loaded_callback_);
    110   LookupKey precise_key;
    111   AddressData precise_address;
    112   precise_address.region_code = "US";
    113   precise_address.administrative_area = "CA";
    114   precise_address.locality = "Mountain View";
    115   precise_key.FromAddress(precise_address);
    116   const Rule* rule = supplier_.GetRule(precise_key);
    117   EXPECT_TRUE(rule == NULL);
    118 }
    119 
    120 TEST_F(PreloadSupplierTest, GetRulesForRegion) {
    121   supplier_.LoadRules("CN", *loaded_callback_);
    122   const std::map<std::string, const Rule*>& rules =
    123       supplier_.GetRulesForRegion("CN");
    124   EXPECT_TRUE(rules.find("data/CN") != rules.end());
    125   EXPECT_LT(1U, rules.size());
    126 }
    127 
    128 }  // namespace
    129