OLD | NEW |
1 // Copyright (C) 2014 Google Inc. | 1 // Copyright 2014 The Chromium Authors. All rights reserved. |
2 // | 2 // Use of this source code is governed by a BSD-style license that can be |
3 // Licensed under the Apache License, Version 2.0 (the "License"); | 3 // found in the LICENSE file. |
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 "address_validator_test.h" | |
16 | |
17 #include <libaddressinput/address_data.h> | |
18 #include <libaddressinput/address_field.h> | |
19 #include <libaddressinput/address_problem.h> | |
20 #include <libaddressinput/address_validator.h> | |
21 #include <libaddressinput/downloader.h> | |
22 #include <libaddressinput/load_rules_delegate.h> | |
23 #include <libaddressinput/storage.h> | |
24 #include <libaddressinput/util/scoped_ptr.h> | |
25 | 4 |
26 #include <cstddef> | 5 #include <cstddef> |
27 #include <set> | |
28 #include <string> | 6 #include <string> |
29 #include <vector> | 7 #include <vector> |
30 | 8 |
31 #include <gtest/gtest.h> | 9 #include "base/basictypes.h" |
| 10 #include "base/macros.h" |
| 11 #include "base/memory/scoped_ptr.h" |
| 12 #include "testing/gtest/include/gtest/gtest.h" |
32 | 13 |
33 #include "fake_downloader.h" | 14 #define I18N_ADDRESSINPUT_UTIL_BASICTYPES_H_ |
34 #include "fake_storage.h" | 15 #include "third_party/libaddressinput/chromium/preload_address_validator.h" |
35 #include "region_data_constants.h" | 16 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_da
ta.h" |
| 17 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_fi
eld.h" |
| 18 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_pr
oblem.h" |
| 19 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/address_va
lidator.h" |
| 20 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/callback.h
" |
| 21 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/downloader
.h" |
| 22 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/null_stora
ge.h" |
| 23 #include "third_party/libaddressinput/src/cpp/include/libaddressinput/storage.h" |
| 24 #include "third_party/libaddressinput/src/cpp/src/region_data_constants.h" |
| 25 #include "third_party/libaddressinput/src/cpp/test/fake_downloader.h" |
36 | 26 |
37 namespace i18n { | 27 namespace { |
38 namespace addressinput { | |
39 | 28 |
40 class AddressValidatorTest : public testing::Test, public LoadRulesDelegate { | 29 using ::autofill::PreloadAddressValidator; |
41 public: | 30 using ::i18n::addressinput::AddressData; |
42 AddressValidatorTest() | 31 using ::i18n::addressinput::AddressField; |
43 : validator_(BuildAddressValidatorForTesting( | 32 using ::i18n::addressinput::BuildCallback; |
44 FakeDownloader::kFakeDataUrl, | 33 using ::i18n::addressinput::Downloader; |
45 scoped_ptr<Downloader>(new FakeDownloader), | 34 using ::i18n::addressinput::FakeDownloader; |
46 scoped_ptr<Storage>(new FakeStorage), | 35 using ::i18n::addressinput::FieldProblemMap; |
47 this)) { | 36 using ::i18n::addressinput::NullStorage; |
48 validator_->LoadRules("US"); | 37 using ::i18n::addressinput::RegionDataConstants; |
| 38 using ::i18n::addressinput::Storage; |
| 39 |
| 40 using ::i18n::addressinput::COUNTRY; |
| 41 using ::i18n::addressinput::ADMIN_AREA; |
| 42 using ::i18n::addressinput::LOCALITY; |
| 43 using ::i18n::addressinput::DEPENDENT_LOCALITY; |
| 44 using ::i18n::addressinput::SORTING_CODE; |
| 45 using ::i18n::addressinput::POSTAL_CODE; |
| 46 using ::i18n::addressinput::STREET_ADDRESS; |
| 47 using ::i18n::addressinput::RECIPIENT; |
| 48 |
| 49 using ::i18n::addressinput::UNKNOWN_VALUE; |
| 50 using ::i18n::addressinput::INVALID_FORMAT; |
| 51 using ::i18n::addressinput::MISMATCHING_VALUE; |
| 52 |
| 53 class PreloadAddressValidatorTest : public testing::Test { |
| 54 protected: |
| 55 PreloadAddressValidatorTest() |
| 56 : validator_( |
| 57 new PreloadAddressValidator( |
| 58 FakeDownloader::kFakeAggregateDataUrl, |
| 59 scoped_ptr<Downloader>(new FakeDownloader), |
| 60 scoped_ptr<Storage>(new NullStorage))), |
| 61 loaded_(BuildCallback(this, &PreloadAddressValidatorTest::Loaded)) { |
| 62 validator_->LoadRules("US", *loaded_); |
49 } | 63 } |
50 | 64 |
51 virtual ~AddressValidatorTest() {} | 65 virtual ~PreloadAddressValidatorTest() {} |
52 | 66 |
53 protected: | 67 const scoped_ptr<PreloadAddressValidator> validator_; |
54 scoped_ptr<AddressValidator> validator_; | 68 const scoped_ptr<PreloadAddressValidator::Callback> loaded_; |
55 | 69 |
56 private: | 70 private: |
57 // LoadRulesDelegate implementation. | 71 void Loaded(bool success, |
58 virtual void OnAddressValidationRulesLoaded(const std::string& country_code, | 72 const std::string& region_code, |
59 bool success) { | 73 const int& rule_count) { |
60 AddressData address_data; | 74 AddressData address_data; |
61 address_data.country_code = country_code; | 75 address_data.region_code = region_code; |
62 AddressValidator::Status status = | 76 FieldProblemMap dummy; |
63 validator_->ValidateAddress(address_data, AddressProblemFilter(), NULL); | 77 PreloadAddressValidator::Status status = |
64 EXPECT_EQ(success, status == AddressValidator::SUCCESS); | 78 validator_->Validate(address_data, NULL, &dummy); |
| 79 ASSERT_EQ(success, status == PreloadAddressValidator::SUCCESS); |
65 } | 80 } |
| 81 |
| 82 DISALLOW_COPY_AND_ASSIGN(PreloadAddressValidatorTest); |
66 }; | 83 }; |
67 | 84 |
68 TEST_F(AddressValidatorTest, RegionHasRules) { | 85 TEST_F(PreloadAddressValidatorTest, RegionHasRules) { |
69 const std::vector<std::string>& region_codes = | 86 const std::vector<std::string>& region_codes = |
70 RegionDataConstants::GetRegionCodes(); | 87 RegionDataConstants::GetRegionCodes(); |
71 AddressData address; | 88 AddressData address; |
72 for (size_t i = 0; i < region_codes.size(); ++i) { | 89 for (size_t i = 0; i < region_codes.size(); ++i) { |
73 SCOPED_TRACE("For region: " + region_codes[i]); | 90 SCOPED_TRACE("For region: " + region_codes[i]); |
74 validator_->LoadRules(region_codes[i]); | 91 validator_->LoadRules(region_codes[i], *loaded_); |
75 address.country_code = region_codes[i]; | 92 address.region_code = region_codes[i]; |
| 93 FieldProblemMap dummy; |
76 EXPECT_EQ( | 94 EXPECT_EQ( |
77 AddressValidator::SUCCESS, | 95 PreloadAddressValidator::SUCCESS, |
78 validator_->ValidateAddress(address, AddressProblemFilter(), NULL)); | 96 validator_->Validate(address, NULL, &dummy)); |
79 } | 97 } |
80 } | 98 } |
81 | 99 |
82 TEST_F(AddressValidatorTest, EmptyAddressNoFatalFailure) { | 100 TEST_F(PreloadAddressValidatorTest, EmptyAddressNoFatalFailure) { |
83 AddressData address; | 101 AddressData address; |
84 address.country_code = "US"; | 102 address.region_code = "US"; |
85 | 103 |
86 AddressProblems problems; | 104 FieldProblemMap dummy; |
87 EXPECT_EQ( | 105 EXPECT_EQ( |
88 AddressValidator::SUCCESS, | 106 PreloadAddressValidator::SUCCESS, |
89 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 107 validator_->Validate(address, NULL, &dummy)); |
90 } | 108 } |
91 | 109 |
92 TEST_F(AddressValidatorTest, USZipCode) { | 110 TEST_F(PreloadAddressValidatorTest, USZipCode) { |
93 AddressData address; | 111 AddressData address; |
94 address.address_lines.push_back("340 Main St."); | 112 address.address_line.push_back("340 Main St."); |
95 address.locality = "Venice"; | 113 address.locality = "Venice"; |
96 address.administrative_area = "CA"; | 114 address.administrative_area = "CA"; |
97 address.country_code = "US"; | 115 address.region_code = "US"; |
98 | 116 |
99 // Valid Californian zip code. | 117 // Valid Californian zip code. |
100 address.postal_code = "90291"; | 118 address.postal_code = "90291"; |
101 AddressProblems problems; | 119 FieldProblemMap problems; |
102 EXPECT_EQ( | 120 EXPECT_EQ( |
103 AddressValidator::SUCCESS, | 121 PreloadAddressValidator::SUCCESS, |
104 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 122 validator_->Validate(address, NULL, &problems)); |
105 EXPECT_TRUE(problems.empty()); | 123 EXPECT_TRUE(problems.empty()); |
106 | 124 |
107 problems.clear(); | 125 problems.clear(); |
108 | 126 |
109 // An extended, valid Californian zip code. | 127 // An extended, valid Californian zip code. |
110 address.postal_code = "90210-1234"; | 128 address.postal_code = "90210-1234"; |
111 EXPECT_EQ( | 129 EXPECT_EQ( |
112 AddressValidator::SUCCESS, | 130 PreloadAddressValidator::SUCCESS, |
113 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 131 validator_->Validate(address, NULL, &problems)); |
114 EXPECT_TRUE(problems.empty()); | 132 EXPECT_TRUE(problems.empty()); |
115 | 133 |
116 problems.clear(); | 134 problems.clear(); |
117 | 135 |
118 // New York zip code (which is invalid for California). | 136 // New York zip code (which is invalid for California). |
119 address.postal_code = "12345"; | 137 address.postal_code = "12345"; |
120 EXPECT_EQ( | 138 EXPECT_EQ( |
121 AddressValidator::SUCCESS, | 139 PreloadAddressValidator::SUCCESS, |
122 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 140 validator_->Validate(address, NULL, &problems)); |
123 EXPECT_EQ(1U, problems.size()); | 141 EXPECT_EQ(1U, problems.size()); |
124 EXPECT_EQ(problems[0].field, POSTAL_CODE); | 142 EXPECT_EQ(problems.begin()->first, POSTAL_CODE); |
125 EXPECT_EQ(problems[0].type, AddressProblem::MISMATCHING_VALUE); | 143 EXPECT_EQ(problems.begin()->second, MISMATCHING_VALUE); |
126 | 144 |
127 problems.clear(); | 145 problems.clear(); |
128 | 146 |
129 // A zip code with a "90" in the middle. | 147 // A zip code with a "90" in the middle. |
130 address.postal_code = "12903"; | 148 address.postal_code = "12903"; |
131 EXPECT_EQ( | 149 EXPECT_EQ( |
132 AddressValidator::SUCCESS, | 150 PreloadAddressValidator::SUCCESS, |
133 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 151 validator_->Validate(address, NULL, &problems)); |
134 EXPECT_EQ(1U, problems.size()); | 152 EXPECT_EQ(1U, problems.size()); |
135 EXPECT_EQ(problems[0].field, POSTAL_CODE); | 153 EXPECT_EQ(problems.begin()->first, POSTAL_CODE); |
136 EXPECT_EQ(problems[0].type, AddressProblem::MISMATCHING_VALUE); | 154 EXPECT_EQ(problems.begin()->second, MISMATCHING_VALUE); |
137 | 155 |
138 problems.clear(); | 156 problems.clear(); |
139 | 157 |
140 // Invalid zip code (too many digits). | 158 // Invalid zip code (too many digits). |
141 address.postal_code = "902911"; | 159 address.postal_code = "902911"; |
142 EXPECT_EQ( | 160 EXPECT_EQ( |
143 AddressValidator::SUCCESS, | 161 PreloadAddressValidator::SUCCESS, |
144 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 162 validator_->Validate(address, NULL, &problems)); |
145 EXPECT_EQ(1U, problems.size()); | 163 EXPECT_EQ(1U, problems.size()); |
146 EXPECT_EQ(problems[0].field, POSTAL_CODE); | 164 EXPECT_EQ(problems.begin()->first, POSTAL_CODE); |
147 EXPECT_EQ(problems[0].type, AddressProblem::UNRECOGNIZED_FORMAT); | 165 EXPECT_EQ(problems.begin()->second, INVALID_FORMAT); |
148 | 166 |
149 problems.clear(); | 167 problems.clear(); |
150 | 168 |
151 // Invalid zip code (too few digits). | 169 // Invalid zip code (too few digits). |
152 address.postal_code = "9029"; | 170 address.postal_code = "9029"; |
153 EXPECT_EQ( | 171 EXPECT_EQ( |
154 AddressValidator::SUCCESS, | 172 PreloadAddressValidator::SUCCESS, |
155 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 173 validator_->Validate(address, NULL, &problems)); |
156 EXPECT_EQ(1U, problems.size()); | 174 EXPECT_EQ(1U, problems.size()); |
157 EXPECT_EQ(problems[0].field, POSTAL_CODE); | 175 EXPECT_EQ(problems.begin()->first, POSTAL_CODE); |
158 EXPECT_EQ(problems[0].type, AddressProblem::UNRECOGNIZED_FORMAT); | 176 EXPECT_EQ(problems.begin()->second, INVALID_FORMAT); |
159 } | 177 } |
160 | 178 |
161 TEST_F(AddressValidatorTest, BasicValidation) { | 179 // Test case disabled because libaddressinput address validation doesn't do |
| 180 // those kinds of normalizations that this test case expects. TODO: Something. |
| 181 TEST_F(PreloadAddressValidatorTest, DISABLED_BasicValidation) { |
162 // US rules should always be available, even though this load call fails. | 182 // US rules should always be available, even though this load call fails. |
163 validator_->LoadRules("US"); | 183 validator_->LoadRules("US", *loaded_); |
164 AddressData address; | 184 AddressData address; |
165 address.country_code = "US"; | 185 address.region_code = "US"; |
166 address.language_code = "en"; | 186 address.language_code = "en"; |
167 address.administrative_area = "TX"; | 187 address.administrative_area = "TX"; |
168 address.locality = "Paris"; | 188 address.locality = "Paris"; |
169 address.postal_code = "75461"; | 189 address.postal_code = "75461"; |
170 address.address_lines.push_back("123 Main St"); | 190 address.address_line.push_back("123 Main St"); |
171 AddressProblems problems; | 191 FieldProblemMap problems; |
172 EXPECT_EQ( | 192 EXPECT_EQ( |
173 AddressValidator::SUCCESS, | 193 PreloadAddressValidator::SUCCESS, |
174 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 194 validator_->Validate(address, NULL, &problems)); |
175 EXPECT_TRUE(problems.empty()); | 195 EXPECT_TRUE(problems.empty()); |
176 | 196 |
177 // The display name works as well as the key. | 197 // The display name works as well as the key. |
178 address.administrative_area = "Texas"; | 198 address.administrative_area = "Texas"; |
179 problems.clear(); | 199 problems.clear(); |
180 EXPECT_EQ( | 200 EXPECT_EQ( |
181 AddressValidator::SUCCESS, | 201 PreloadAddressValidator::SUCCESS, |
182 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 202 validator_->Validate(address, NULL, &problems)); |
183 EXPECT_TRUE(problems.empty()); | 203 EXPECT_TRUE(problems.empty()); |
184 | 204 |
185 // Ignore capitalization. | 205 // Ignore capitalization. |
186 address.administrative_area = "tx"; | 206 address.administrative_area = "tx"; |
187 problems.clear(); | 207 problems.clear(); |
188 EXPECT_EQ( | 208 EXPECT_EQ( |
189 AddressValidator::SUCCESS, | 209 PreloadAddressValidator::SUCCESS, |
190 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 210 validator_->Validate(address, NULL, &problems)); |
191 EXPECT_TRUE(problems.empty()); | 211 EXPECT_TRUE(problems.empty()); |
192 | 212 |
193 // Ignore capitalization. | 213 // Ignore capitalization. |
194 address.administrative_area = "teXas"; | 214 address.administrative_area = "teXas"; |
195 problems.clear(); | 215 problems.clear(); |
196 EXPECT_EQ( | 216 EXPECT_EQ( |
197 AddressValidator::SUCCESS, | 217 PreloadAddressValidator::SUCCESS, |
198 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 218 validator_->Validate(address, NULL, &problems)); |
199 EXPECT_TRUE(problems.empty()); | 219 EXPECT_TRUE(problems.empty()); |
200 | 220 |
201 // Ignore diacriticals. | 221 // Ignore diacriticals. |
202 address.administrative_area = "T\u00E9xas"; | 222 address.administrative_area = "T\u00E9xas"; |
203 problems.clear(); | 223 problems.clear(); |
204 EXPECT_EQ( | 224 EXPECT_EQ( |
205 AddressValidator::SUCCESS, | 225 PreloadAddressValidator::SUCCESS, |
206 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 226 validator_->Validate(address, NULL, &problems)); |
207 EXPECT_TRUE(problems.empty()); | 227 EXPECT_TRUE(problems.empty()); |
208 } | 228 } |
209 | 229 |
210 TEST_F(AddressValidatorTest, BasicValidationFailure) { | 230 TEST_F(PreloadAddressValidatorTest, BasicValidationFailure) { |
211 // US rules should always be available, even though this load call fails. | 231 // US rules should always be available, even though this load call fails. |
212 validator_->LoadRules("US"); | 232 validator_->LoadRules("US", *loaded_); |
213 AddressData address; | 233 AddressData address; |
214 address.country_code = "US"; | 234 address.region_code = "US"; |
215 address.language_code = "en"; | 235 address.language_code = "en"; |
216 address.administrative_area = "XT"; | 236 address.administrative_area = "XT"; |
217 address.locality = "Paris"; | 237 address.locality = "Paris"; |
218 address.postal_code = "75461"; | 238 address.postal_code = "75461"; |
219 address.address_lines.push_back("123 Main St"); | 239 address.address_line.push_back("123 Main St"); |
220 AddressProblems problems; | 240 FieldProblemMap problems; |
221 EXPECT_EQ( | 241 EXPECT_EQ( |
222 AddressValidator::SUCCESS, | 242 PreloadAddressValidator::SUCCESS, |
223 validator_->ValidateAddress(address, AddressProblemFilter(), &problems)); | 243 validator_->Validate(address, NULL, &problems)); |
224 | 244 |
225 ASSERT_EQ(1U, problems.size()); | 245 ASSERT_EQ(1U, problems.size()); |
226 EXPECT_EQ(AddressProblem::UNKNOWN_VALUE, problems[0].type); | 246 EXPECT_EQ(UNKNOWN_VALUE, problems.begin()->second); |
227 EXPECT_EQ(ADMIN_AREA, problems[0].field); | 247 EXPECT_EQ(ADMIN_AREA, problems.begin()->first); |
228 } | 248 } |
229 | 249 |
230 TEST_F(AddressValidatorTest, NoNullSuggestionsCrash) { | 250 #if 0 // TODO: Implement suggestions. |
| 251 |
| 252 TEST_F(PreloadAddressValidatorTest, NoNullSuggestionsCrash) { |
231 AddressData address; | 253 AddressData address; |
232 address.country_code = "US"; | 254 address.region_code = "US"; |
233 EXPECT_EQ(AddressValidator::SUCCESS, | 255 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
234 validator_->GetSuggestions(address, COUNTRY, 1, NULL)); | 256 validator_->GetSuggestions(address, COUNTRY, 1, NULL)); |
235 } | 257 } |
236 | 258 |
237 TEST_F(AddressValidatorTest, SuggestAdminAreaForPostalCode) { | 259 TEST_F(PreloadAddressValidatorTest, SuggestAdminAreaForPostalCode) { |
238 AddressData address; | 260 AddressData address; |
239 address.country_code = "US"; | 261 address.region_code = "US"; |
240 address.postal_code = "90291"; | 262 address.postal_code = "90291"; |
241 | 263 |
242 std::vector<AddressData> suggestions; | 264 std::vector<AddressData> suggestions; |
243 EXPECT_EQ(AddressValidator::SUCCESS, | 265 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
244 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); | 266 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); |
245 ASSERT_EQ(1U, suggestions.size()); | 267 ASSERT_EQ(1U, suggestions.size()); |
246 EXPECT_EQ("CA", suggestions[0].administrative_area); | 268 EXPECT_EQ("CA", suggestions[0].administrative_area); |
247 EXPECT_EQ("90291", suggestions[0].postal_code); | 269 EXPECT_EQ("90291", suggestions[0].postal_code); |
248 } | 270 } |
249 | 271 |
250 TEST_F(AddressValidatorTest, SuggestLocalityForPostalCodeWithAdminArea) { | 272 TEST_F(PreloadAddressValidatorTest, SuggestLocalityForPostalCodeWithAdminArea) { |
251 validator_->LoadRules("TW"); | 273 validator_->LoadRules("TW", *loaded_); |
252 AddressData address; | 274 AddressData address; |
253 address.country_code = "TW"; | 275 address.region_code = "TW"; |
254 address.postal_code = "515"; | 276 address.postal_code = "515"; |
255 address.administrative_area = "Changhua"; | 277 address.administrative_area = "Changhua"; |
256 | 278 |
257 std::vector<AddressData> suggestions; | 279 std::vector<AddressData> suggestions; |
258 EXPECT_EQ(AddressValidator::SUCCESS, | 280 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
259 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); | 281 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); |
260 ASSERT_EQ(1U, suggestions.size()); | 282 ASSERT_EQ(1U, suggestions.size()); |
261 EXPECT_EQ("Dacun Township", suggestions[0].locality); | 283 EXPECT_EQ("Dacun Township", suggestions[0].locality); |
262 EXPECT_EQ("Changhua County", suggestions[0].administrative_area); | 284 EXPECT_EQ("Changhua County", suggestions[0].administrative_area); |
263 EXPECT_EQ("515", suggestions[0].postal_code); | 285 EXPECT_EQ("515", suggestions[0].postal_code); |
264 } | 286 } |
265 | 287 |
266 TEST_F(AddressValidatorTest, SuggestAdminAreaForPostalCodeWithLocality) { | 288 TEST_F(PreloadAddressValidatorTest, SuggestAdminAreaForPostalCodeWithLocality) { |
267 validator_->LoadRules("TW"); | 289 validator_->LoadRules("TW", *loaded_); |
268 AddressData address; | 290 AddressData address; |
269 address.country_code = "TW"; | 291 address.region_code = "TW"; |
270 address.postal_code = "515"; | 292 address.postal_code = "515"; |
271 address.locality = "Dacun"; | 293 address.locality = "Dacun"; |
272 | 294 |
273 std::vector<AddressData> suggestions; | 295 std::vector<AddressData> suggestions; |
274 EXPECT_EQ(AddressValidator::SUCCESS, | 296 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
275 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); | 297 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); |
276 ASSERT_EQ(1U, suggestions.size()); | 298 ASSERT_EQ(1U, suggestions.size()); |
277 EXPECT_EQ("Dacun Township", suggestions[0].locality); | 299 EXPECT_EQ("Dacun Township", suggestions[0].locality); |
278 EXPECT_EQ("Changhua County", suggestions[0].administrative_area); | 300 EXPECT_EQ("Changhua County", suggestions[0].administrative_area); |
279 EXPECT_EQ("515", suggestions[0].postal_code); | 301 EXPECT_EQ("515", suggestions[0].postal_code); |
280 } | 302 } |
281 | 303 |
282 TEST_F(AddressValidatorTest, NoSuggestForPostalCodeWithWrongAdminArea) { | 304 TEST_F(PreloadAddressValidatorTest, NoSuggestForPostalCodeWithWrongAdminArea) { |
283 AddressData address; | 305 AddressData address; |
284 address.country_code = "US"; | 306 address.region_code = "US"; |
285 address.postal_code = "90066"; | 307 address.postal_code = "90066"; |
286 address.postal_code = "TX"; | 308 address.postal_code = "TX"; |
287 | 309 |
288 std::vector<AddressData> suggestions; | 310 std::vector<AddressData> suggestions; |
289 EXPECT_EQ(AddressValidator::SUCCESS, | 311 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
290 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); | 312 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); |
291 EXPECT_TRUE(suggestions.empty()); | 313 EXPECT_TRUE(suggestions.empty()); |
292 } | 314 } |
293 | 315 |
294 TEST_F(AddressValidatorTest, SuggestForLocality) { | 316 TEST_F(PreloadAddressValidatorTest, SuggestForLocality) { |
295 validator_->LoadRules("CN"); | 317 validator_->LoadRules("CN", *loaded_); |
296 AddressData address; | 318 AddressData address; |
297 address.country_code = "CN"; | 319 address.region_code = "CN"; |
298 address.locality = "Anqin"; | 320 address.locality = "Anqin"; |
299 | 321 |
300 std::vector<AddressData> suggestions; | 322 std::vector<AddressData> suggestions; |
301 EXPECT_EQ(AddressValidator::SUCCESS, | 323 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
302 validator_->GetSuggestions(address, LOCALITY, 10, &suggestions)); | 324 validator_->GetSuggestions(address, LOCALITY, 10, &suggestions)); |
303 ASSERT_EQ(1U, suggestions.size()); | 325 ASSERT_EQ(1U, suggestions.size()); |
304 EXPECT_EQ("Anqing Shi", suggestions[0].locality); | 326 EXPECT_EQ("Anqing Shi", suggestions[0].locality); |
305 EXPECT_EQ("ANHUI SHENG", suggestions[0].administrative_area); | 327 EXPECT_EQ("ANHUI SHENG", suggestions[0].administrative_area); |
306 } | 328 } |
307 | 329 |
308 TEST_F(AddressValidatorTest, SuggestForLocalityAndAdminArea) { | 330 TEST_F(PreloadAddressValidatorTest, SuggestForLocalityAndAdminArea) { |
309 validator_->LoadRules("CN"); | 331 validator_->LoadRules("CN", *loaded_); |
310 AddressData address; | 332 AddressData address; |
311 address.country_code = "CN"; | 333 address.region_code = "CN"; |
312 address.locality = "Anqing"; | 334 address.locality = "Anqing"; |
313 address.administrative_area = "Anhui"; | 335 address.administrative_area = "Anhui"; |
314 | 336 |
315 std::vector<AddressData> suggestions; | 337 std::vector<AddressData> suggestions; |
316 EXPECT_EQ(AddressValidator::SUCCESS, | 338 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
317 validator_->GetSuggestions(address, LOCALITY, 10, &suggestions)); | 339 validator_->GetSuggestions(address, LOCALITY, 10, &suggestions)); |
318 ASSERT_EQ(1U, suggestions.size()); | 340 ASSERT_EQ(1U, suggestions.size()); |
319 EXPECT_TRUE(suggestions[0].dependent_locality.empty()); | 341 EXPECT_TRUE(suggestions[0].dependent_locality.empty()); |
320 EXPECT_EQ("Anqing Shi", suggestions[0].locality); | 342 EXPECT_EQ("Anqing Shi", suggestions[0].locality); |
321 EXPECT_EQ("ANHUI SHENG", suggestions[0].administrative_area); | 343 EXPECT_EQ("ANHUI SHENG", suggestions[0].administrative_area); |
322 } | 344 } |
323 | 345 |
324 TEST_F(AddressValidatorTest, SuggestForAdminAreaAndLocality) { | 346 TEST_F(PreloadAddressValidatorTest, SuggestForAdminAreaAndLocality) { |
325 validator_->LoadRules("CN"); | 347 validator_->LoadRules("CN", *loaded_); |
326 AddressData address; | 348 AddressData address; |
327 address.country_code = "CN"; | 349 address.region_code = "CN"; |
328 address.locality = "Anqing"; | 350 address.locality = "Anqing"; |
329 address.administrative_area = "Anhui"; | 351 address.administrative_area = "Anhui"; |
330 | 352 |
331 std::vector<AddressData> suggestions; | 353 std::vector<AddressData> suggestions; |
332 EXPECT_EQ(AddressValidator::SUCCESS, | 354 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
333 validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions)); | 355 validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions)); |
334 ASSERT_EQ(1U, suggestions.size()); | 356 ASSERT_EQ(1U, suggestions.size()); |
335 EXPECT_TRUE(suggestions[0].dependent_locality.empty()); | 357 EXPECT_TRUE(suggestions[0].dependent_locality.empty()); |
336 EXPECT_TRUE(suggestions[0].locality.empty()); | 358 EXPECT_TRUE(suggestions[0].locality.empty()); |
337 EXPECT_EQ("ANHUI SHENG", suggestions[0].administrative_area); | 359 EXPECT_EQ("ANHUI SHENG", suggestions[0].administrative_area); |
338 } | 360 } |
339 | 361 |
340 TEST_F(AddressValidatorTest, SuggestForDependentLocality) { | 362 TEST_F(PreloadAddressValidatorTest, SuggestForDependentLocality) { |
341 validator_->LoadRules("CN"); | 363 validator_->LoadRules("CN", *loaded_); |
342 AddressData address; | 364 AddressData address; |
343 address.country_code = "CN"; | 365 address.region_code = "CN"; |
344 address.dependent_locality = "Zongyang"; | 366 address.dependent_locality = "Zongyang"; |
345 | 367 |
346 std::vector<AddressData> suggestions; | 368 std::vector<AddressData> suggestions; |
347 EXPECT_EQ(AddressValidator::SUCCESS, | 369 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
348 validator_->GetSuggestions( | 370 validator_->GetSuggestions( |
349 address, DEPENDENT_LOCALITY, 10, &suggestions)); | 371 address, DEPENDENT_LOCALITY, 10, &suggestions)); |
350 ASSERT_EQ(1U, suggestions.size()); | 372 ASSERT_EQ(1U, suggestions.size()); |
351 EXPECT_EQ("Zongyang Xian", suggestions[0].dependent_locality); | 373 EXPECT_EQ("Zongyang Xian", suggestions[0].dependent_locality); |
352 EXPECT_EQ("Anqing Shi", suggestions[0].locality); | 374 EXPECT_EQ("Anqing Shi", suggestions[0].locality); |
353 EXPECT_EQ("ANHUI SHENG", suggestions[0].administrative_area); | 375 EXPECT_EQ("ANHUI SHENG", suggestions[0].administrative_area); |
354 } | 376 } |
355 | 377 |
356 TEST_F(AddressValidatorTest, | 378 TEST_F(PreloadAddressValidatorTest, |
357 NoSuggestForDependentLocalityWithWrongAdminArea) { | 379 NoSuggestForDependentLocalityWithWrongAdminArea) { |
358 validator_->LoadRules("CN"); | 380 validator_->LoadRules("CN", *loaded_); |
359 AddressData address; | 381 AddressData address; |
360 address.country_code = "CN"; | 382 address.region_code = "CN"; |
361 address.dependent_locality = "Zongyang"; | 383 address.dependent_locality = "Zongyang"; |
362 address.administrative_area = "Sichuan Sheng"; | 384 address.administrative_area = "Sichuan Sheng"; |
363 | 385 |
364 std::vector<AddressData> suggestions; | 386 std::vector<AddressData> suggestions; |
365 EXPECT_EQ(AddressValidator::SUCCESS, | 387 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
366 validator_->GetSuggestions( | 388 validator_->GetSuggestions( |
367 address, DEPENDENT_LOCALITY, 10, &suggestions)); | 389 address, DEPENDENT_LOCALITY, 10, &suggestions)); |
368 EXPECT_TRUE(suggestions.empty()); | 390 EXPECT_TRUE(suggestions.empty()); |
369 } | 391 } |
370 | 392 |
371 TEST_F(AddressValidatorTest, EmptySuggestionsOverLimit) { | 393 TEST_F(PreloadAddressValidatorTest, EmptySuggestionsOverLimit) { |
372 AddressData address; | 394 AddressData address; |
373 address.country_code = "US"; | 395 address.region_code = "US"; |
374 address.administrative_area = "A"; | 396 address.administrative_area = "A"; |
375 | 397 |
376 std::vector<AddressData> suggestions; | 398 std::vector<AddressData> suggestions; |
377 EXPECT_EQ(AddressValidator::SUCCESS, | 399 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
378 validator_->GetSuggestions(address, ADMIN_AREA, 1, &suggestions)); | 400 validator_->GetSuggestions(address, ADMIN_AREA, 1, &suggestions)); |
379 EXPECT_TRUE(suggestions.empty()); | 401 EXPECT_TRUE(suggestions.empty()); |
380 } | 402 } |
381 | 403 |
382 TEST_F(AddressValidatorTest, PreferShortSuggestions) { | 404 TEST_F(PreloadAddressValidatorTest, PreferShortSuggestions) { |
383 AddressData address; | 405 AddressData address; |
384 address.country_code = "US"; | 406 address.region_code = "US"; |
385 address.administrative_area = "CA"; | 407 address.administrative_area = "CA"; |
386 | 408 |
387 std::vector<AddressData> suggestions; | 409 std::vector<AddressData> suggestions; |
388 EXPECT_EQ(AddressValidator::SUCCESS, | 410 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
389 validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions)); | 411 validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions)); |
390 ASSERT_EQ(1U, suggestions.size()); | 412 ASSERT_EQ(1U, suggestions.size()); |
391 EXPECT_EQ("CA", suggestions[0].administrative_area); | 413 EXPECT_EQ("CA", suggestions[0].administrative_area); |
392 } | 414 } |
393 | 415 |
394 TEST_F(AddressValidatorTest, SuggestTheSingleMatchForFullMatchName) { | 416 TEST_F(PreloadAddressValidatorTest, SuggestTheSingleMatchForFullMatchName) { |
395 AddressData address; | 417 AddressData address; |
396 address.country_code = "US"; | 418 address.region_code = "US"; |
397 address.administrative_area = "Texas"; | 419 address.administrative_area = "Texas"; |
398 | 420 |
399 std::vector<AddressData> suggestions; | 421 std::vector<AddressData> suggestions; |
400 EXPECT_EQ(AddressValidator::SUCCESS, | 422 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
401 validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions)); | 423 validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions)); |
402 ASSERT_EQ(1U, suggestions.size()); | 424 ASSERT_EQ(1U, suggestions.size()); |
403 EXPECT_EQ("Texas", suggestions[0].administrative_area); | 425 EXPECT_EQ("Texas", suggestions[0].administrative_area); |
404 } | 426 } |
405 | 427 |
406 TEST_F(AddressValidatorTest, SuggestAdminArea) { | 428 TEST_F(PreloadAddressValidatorTest, SuggestAdminArea) { |
407 AddressData address; | 429 AddressData address; |
408 address.country_code = "US"; | 430 address.region_code = "US"; |
409 address.administrative_area = "Cali"; | 431 address.administrative_area = "Cali"; |
410 | 432 |
411 std::vector<AddressData> suggestions; | 433 std::vector<AddressData> suggestions; |
412 EXPECT_EQ(AddressValidator::SUCCESS, | 434 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
413 validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions)); | 435 validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions)); |
414 ASSERT_EQ(1U, suggestions.size()); | 436 ASSERT_EQ(1U, suggestions.size()); |
415 EXPECT_EQ("California", suggestions[0].administrative_area); | 437 EXPECT_EQ("California", suggestions[0].administrative_area); |
416 } | 438 } |
417 | 439 |
418 TEST_F(AddressValidatorTest, MultipleSuggestions) { | 440 TEST_F(PreloadAddressValidatorTest, MultipleSuggestions) { |
419 AddressData address; | 441 AddressData address; |
420 address.country_code = "US"; | 442 address.region_code = "US"; |
421 address.administrative_area = "MA"; | 443 address.administrative_area = "MA"; |
422 | 444 |
423 std::vector<AddressData> suggestions; | 445 std::vector<AddressData> suggestions; |
424 EXPECT_EQ(AddressValidator::SUCCESS, | 446 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
425 validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions)); | 447 validator_->GetSuggestions(address, ADMIN_AREA, 10, &suggestions)); |
426 EXPECT_LT(1U, suggestions.size()); | 448 EXPECT_LT(1U, suggestions.size()); |
427 | 449 |
428 // Massachusetts should not be a suggestion, because it's already covered | 450 // Massachusetts should not be a suggestion, because it's already covered |
429 // under MA. | 451 // under MA. |
430 std::set<std::string> expected_suggestions; | 452 std::set<std::string> expected_suggestions; |
431 expected_suggestions.insert("MA"); | 453 expected_suggestions.insert("MA"); |
432 expected_suggestions.insert("Maine"); | 454 expected_suggestions.insert("Maine"); |
433 expected_suggestions.insert("Marshall Islands"); | 455 expected_suggestions.insert("Marshall Islands"); |
434 expected_suggestions.insert("Maryland"); | 456 expected_suggestions.insert("Maryland"); |
435 for (std::vector<AddressData>::const_iterator it = suggestions.begin(); | 457 for (std::vector<AddressData>::const_iterator it = suggestions.begin(); |
436 it != suggestions.end(); ++it) { | 458 it != suggestions.end(); ++it) { |
437 expected_suggestions.erase(it->administrative_area); | 459 expected_suggestions.erase(it->administrative_area); |
438 } | 460 } |
439 EXPECT_TRUE(expected_suggestions.empty()); | 461 EXPECT_TRUE(expected_suggestions.empty()); |
440 } | 462 } |
441 | 463 |
442 TEST_F(AddressValidatorTest, SuggestNonLatinKeyWhenLanguageMatches) { | 464 TEST_F(PreloadAddressValidatorTest, SuggestNonLatinKeyWhenLanguageMatches) { |
443 validator_->LoadRules("KR"); | 465 validator_->LoadRules("KR", *loaded_); |
444 AddressData address; | 466 AddressData address; |
445 address.language_code = "ko"; | 467 address.language_code = "ko"; |
446 address.country_code = "KR"; | 468 address.region_code = "KR"; |
447 address.postal_code = "210-210"; | 469 address.postal_code = "210-210"; |
448 | 470 |
449 std::vector<AddressData> suggestions; | 471 std::vector<AddressData> suggestions; |
450 EXPECT_EQ(AddressValidator::SUCCESS, | 472 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
451 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); | 473 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); |
452 ASSERT_EQ(1U, suggestions.size()); | 474 ASSERT_EQ(1U, suggestions.size()); |
453 EXPECT_EQ("강원도", suggestions[0].administrative_area); | 475 EXPECT_EQ("강원도", suggestions[0].administrative_area); |
454 EXPECT_EQ("210-210", suggestions[0].postal_code); | 476 EXPECT_EQ("210-210", suggestions[0].postal_code); |
455 } | 477 } |
456 | 478 |
457 TEST_F(AddressValidatorTest, SuggestNonLatinKeyWhenUserInputIsNotLatin) { | 479 TEST_F(PreloadAddressValidatorTest, SuggestNonLatinKeyWhenUserInputIsNotLatin) { |
458 validator_->LoadRules("KR"); | 480 validator_->LoadRules("KR", *loaded_); |
459 AddressData address; | 481 AddressData address; |
460 address.language_code = "en"; | 482 address.language_code = "en"; |
461 address.country_code = "KR"; | 483 address.region_code = "KR"; |
462 address.administrative_area = "강원"; | 484 address.administrative_area = "강원"; |
463 | 485 |
464 std::vector<AddressData> suggestions; | 486 std::vector<AddressData> suggestions; |
465 EXPECT_EQ(AddressValidator::SUCCESS, | 487 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
466 validator_->GetSuggestions(address, ADMIN_AREA, 1, &suggestions)); | 488 validator_->GetSuggestions(address, ADMIN_AREA, 1, &suggestions)); |
467 ASSERT_EQ(1U, suggestions.size()); | 489 ASSERT_EQ(1U, suggestions.size()); |
468 EXPECT_EQ("강원도", suggestions[0].administrative_area); | 490 EXPECT_EQ("강원도", suggestions[0].administrative_area); |
469 } | 491 } |
470 | 492 |
471 TEST_F(AddressValidatorTest, | 493 TEST_F(PreloadAddressValidatorTest, |
472 SuggestLatinNameWhenLanguageDiffersAndLatinNameAvailable) { | 494 SuggestLatinNameWhenLanguageDiffersAndLatinNameAvailable) { |
473 validator_->LoadRules("KR"); | 495 validator_->LoadRules("KR", *loaded_); |
474 AddressData address; | 496 AddressData address; |
475 address.language_code = "en"; | 497 address.language_code = "en"; |
476 address.country_code = "KR"; | 498 address.region_code = "KR"; |
477 address.postal_code = "210-210"; | 499 address.postal_code = "210-210"; |
478 | 500 |
479 std::vector<AddressData> suggestions; | 501 std::vector<AddressData> suggestions; |
480 EXPECT_EQ(AddressValidator::SUCCESS, | 502 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
481 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); | 503 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); |
482 ASSERT_EQ(1U, suggestions.size()); | 504 ASSERT_EQ(1U, suggestions.size()); |
483 EXPECT_EQ("Gangwon", suggestions[0].administrative_area); | 505 EXPECT_EQ("Gangwon", suggestions[0].administrative_area); |
484 EXPECT_EQ("210-210", suggestions[0].postal_code); | 506 EXPECT_EQ("210-210", suggestions[0].postal_code); |
485 } | 507 } |
486 | 508 |
487 TEST_F(AddressValidatorTest, SuggestLatinNameWhenUserInputIsLatin) { | 509 TEST_F(PreloadAddressValidatorTest, SuggestLatinNameWhenUserInputIsLatin) { |
488 validator_->LoadRules("KR"); | 510 validator_->LoadRules("KR", *loaded_); |
489 AddressData address; | 511 AddressData address; |
490 address.language_code = "ko"; | 512 address.language_code = "ko"; |
491 address.country_code = "KR"; | 513 address.region_code = "KR"; |
492 address.administrative_area = "Gang"; | 514 address.administrative_area = "Gang"; |
493 | 515 |
494 std::vector<AddressData> suggestions; | 516 std::vector<AddressData> suggestions; |
495 EXPECT_EQ(AddressValidator::SUCCESS, | 517 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
496 validator_->GetSuggestions(address, ADMIN_AREA, 1, &suggestions)); | 518 validator_->GetSuggestions(address, ADMIN_AREA, 1, &suggestions)); |
497 ASSERT_EQ(1U, suggestions.size()); | 519 ASSERT_EQ(1U, suggestions.size()); |
498 EXPECT_EQ("Gangwon", suggestions[0].administrative_area); | 520 EXPECT_EQ("Gangwon", suggestions[0].administrative_area); |
499 } | 521 } |
500 | 522 |
501 TEST_F(AddressValidatorTest, NoSuggestionsForEmptyAddress) { | 523 TEST_F(PreloadAddressValidatorTest, NoSuggestionsForEmptyAddress) { |
502 AddressData address; | 524 AddressData address; |
503 address.country_code = "US"; | 525 address.region_code = "US"; |
504 | 526 |
505 std::vector<AddressData> suggestions; | 527 std::vector<AddressData> suggestions; |
506 EXPECT_EQ( | 528 EXPECT_EQ( |
507 AddressValidator::SUCCESS, | 529 PreloadAddressValidator::SUCCESS, |
508 validator_->GetSuggestions(address, POSTAL_CODE, 999, &suggestions)); | 530 validator_->GetSuggestions(address, POSTAL_CODE, 999, &suggestions)); |
509 EXPECT_TRUE(suggestions.empty()); | 531 EXPECT_TRUE(suggestions.empty()); |
510 } | 532 } |
511 | 533 |
512 TEST_F(AddressValidatorTest, SuggestionIncludesCountry) { | 534 TEST_F(PreloadAddressValidatorTest, SuggestionIncludesCountry) { |
513 AddressData address; | 535 AddressData address; |
514 address.country_code = "US"; | 536 address.region_code = "US"; |
515 address.postal_code = "90291"; | 537 address.postal_code = "90291"; |
516 | 538 |
517 std::vector<AddressData> suggestions; | 539 std::vector<AddressData> suggestions; |
518 EXPECT_EQ(AddressValidator::SUCCESS, | 540 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
519 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); | 541 validator_->GetSuggestions(address, POSTAL_CODE, 1, &suggestions)); |
520 ASSERT_EQ(1U, suggestions.size()); | 542 ASSERT_EQ(1U, suggestions.size()); |
521 EXPECT_EQ("US", suggestions[0].country_code); | 543 EXPECT_EQ("US", suggestions[0].region_code); |
522 } | 544 } |
523 | 545 |
524 TEST_F(AddressValidatorTest, SuggestOnlyForAdministrativeAreasAndPostalCode) { | 546 TEST_F(PreloadAddressValidatorTest, |
| 547 SuggestOnlyForAdministrativeAreasAndPostalCode) { |
525 AddressData address; | 548 AddressData address; |
526 address.country_code = "US"; | 549 address.region_code = "US"; |
527 address.administrative_area = "CA"; | 550 address.administrative_area = "CA"; |
528 address.locality = "Los Angeles"; | 551 address.locality = "Los Angeles"; |
529 address.dependent_locality = "Venice"; | 552 address.dependent_locality = "Venice"; |
530 address.postal_code = "90291"; | 553 address.postal_code = "90291"; |
531 address.sorting_code = "123"; | 554 address.sorting_code = "123"; |
532 address.address_lines.push_back("123 Main St"); | 555 address.address_line.push_back("123 Main St"); |
533 address.organization = "Google"; | |
534 address.recipient = "Jon Smith"; | 556 address.recipient = "Jon Smith"; |
535 | 557 |
536 // Fields that should not have suggestions in US. | 558 // Fields that should not have suggestions in US. |
537 static const AddressField kNoSugestFields[] = { | 559 static const AddressField kNoSugestFields[] = { |
538 COUNTRY, | 560 COUNTRY, |
539 LOCALITY, | 561 LOCALITY, |
540 DEPENDENT_LOCALITY, | 562 DEPENDENT_LOCALITY, |
541 SORTING_CODE, | 563 SORTING_CODE, |
542 STREET_ADDRESS, | 564 STREET_ADDRESS, |
543 ORGANIZATION, | |
544 RECIPIENT | 565 RECIPIENT |
545 }; | 566 }; |
546 | 567 |
547 static const size_t kNumNoSuggestFields = | 568 static const size_t kNumNoSuggestFields = |
548 sizeof kNoSugestFields / sizeof (AddressField); | 569 sizeof kNoSugestFields / sizeof (AddressField); |
549 | 570 |
550 for (size_t i = 0; i < kNumNoSuggestFields; ++i) { | 571 for (size_t i = 0; i < kNumNoSuggestFields; ++i) { |
551 std::vector<AddressData> suggestions; | 572 std::vector<AddressData> suggestions; |
552 EXPECT_EQ(AddressValidator::SUCCESS, | 573 EXPECT_EQ(PreloadAddressValidator::SUCCESS, |
553 validator_->GetSuggestions( | 574 validator_->GetSuggestions( |
554 address, kNoSugestFields[i], 999, &suggestions)); | 575 address, kNoSugestFields[i], 999, &suggestions)); |
555 EXPECT_TRUE(suggestions.empty()); | 576 EXPECT_TRUE(suggestions.empty()); |
556 } | 577 } |
557 } | 578 } |
558 | 579 |
559 TEST_F(AddressValidatorTest, CanonicalizeUsAdminAreaName) { | 580 TEST_F(PreloadAddressValidatorTest, CanonicalizeUsAdminAreaName) { |
560 AddressData address; | 581 AddressData address; |
561 address.country_code = "US"; | 582 address.region_code = "US"; |
562 address.administrative_area = "cALIFORNIa"; | 583 address.administrative_area = "cALIFORNIa"; |
563 EXPECT_TRUE(validator_->CanonicalizeAdministrativeArea(&address)); | 584 EXPECT_TRUE(validator_->CanonicalizeAdministrativeArea(&address)); |
564 EXPECT_EQ("CA", address.administrative_area); | 585 EXPECT_EQ("CA", address.administrative_area); |
565 } | 586 } |
566 | 587 |
567 TEST_F(AddressValidatorTest, CanonicalizeUsAdminAreaKey) { | 588 TEST_F(PreloadAddressValidatorTest, CanonicalizeUsAdminAreaKey) { |
568 AddressData address; | 589 AddressData address; |
569 address.country_code = "US"; | 590 address.region_code = "US"; |
570 address.administrative_area = "CA"; | 591 address.administrative_area = "CA"; |
571 EXPECT_TRUE(validator_->CanonicalizeAdministrativeArea(&address)); | 592 EXPECT_TRUE(validator_->CanonicalizeAdministrativeArea(&address)); |
572 EXPECT_EQ("CA", address.administrative_area); | 593 EXPECT_EQ("CA", address.administrative_area); |
573 } | 594 } |
574 | 595 |
575 TEST_F(AddressValidatorTest, CanonicalizeJpAdminAreaKey) { | 596 TEST_F(PreloadAddressValidatorTest, CanonicalizeJpAdminAreaKey) { |
576 validator_->LoadRules("JP"); | 597 validator_->LoadRules("JP", *loaded_); |
577 AddressData address; | 598 AddressData address; |
578 address.country_code = "JP"; | 599 address.region_code = "JP"; |
579 address.administrative_area = "東京都"; | 600 address.administrative_area = "東京都"; |
580 EXPECT_TRUE(validator_->CanonicalizeAdministrativeArea(&address)); | 601 EXPECT_TRUE(validator_->CanonicalizeAdministrativeArea(&address)); |
581 EXPECT_EQ("東京都", address.administrative_area); | 602 EXPECT_EQ("東京都", address.administrative_area); |
582 } | 603 } |
583 | 604 |
584 TEST_F(AddressValidatorTest, CanonicalizeJpAdminAreaLatinName) { | 605 TEST_F(PreloadAddressValidatorTest, CanonicalizeJpAdminAreaLatinName) { |
585 validator_->LoadRules("JP"); | 606 validator_->LoadRules("JP", *loaded_); |
586 AddressData address; | 607 AddressData address; |
587 address.country_code = "JP"; | 608 address.region_code = "JP"; |
588 address.administrative_area = "tOKYo"; | 609 address.administrative_area = "tOKYo"; |
589 EXPECT_TRUE(validator_->CanonicalizeAdministrativeArea(&address)); | 610 EXPECT_TRUE(validator_->CanonicalizeAdministrativeArea(&address)); |
590 EXPECT_EQ("TOKYO", address.administrative_area); | 611 EXPECT_EQ("TOKYO", address.administrative_area); |
591 } | 612 } |
592 | 613 |
593 } // namespace addressinput | 614 #endif |
594 } // namespace i18n | 615 |
| 616 } // namespace |
OLD | NEW |