Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(571)

Side by Side Diff: third_party/libaddressinput/chromium/preload_address_validator_unittest.cc

Issue 298863012: Use upstream libaddressinput in Chrome. (Closed) Base URL: svn://svn.chromium.org/chrome/trunk/src
Patch Set: Initial. Created 6 years, 7 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch | Annotate | Revision Log
OLDNEW
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
OLDNEW

Powered by Google App Engine
This is Rietveld 408576698