1 // Copyright (C) 2013 Google Inc.
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
7 // http://www.apache.org/licenses/LICENSE-2.0
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.
17 #include <libaddressinput/address_field.h>
18 #include <libaddressinput/localization.h>
19 #include <libaddressinput/util/basictypes.h>
26 #include <gtest/gtest.h>
28 #include "format_element.h"
31 #include "region_data_constants.h"
32 #include "util/json.h"
36 using i18n::addressinput::AddressField;
37 using i18n::addressinput::ADMIN_AREA;
38 using i18n::addressinput::FormatElement;
39 using i18n::addressinput::INVALID_MESSAGE_ID;
40 using i18n::addressinput::Json;
41 using i18n::addressinput::LOCALITY;
42 using i18n::addressinput::Localization;
43 using i18n::addressinput::RegionDataConstants;
44 using i18n::addressinput::Rule;
45 using i18n::addressinput::STREET_ADDRESS;
47 TEST(RuleTest, CopyOverwritesRule) {
49 ASSERT_TRUE(rule.ParseSerializedRule(
54 "\"name\":\"Le Test\","
55 "\"lname\":\"Testistan\","
57 "\"sub_keys\":\"aa~bb~cc\","
58 "\"languages\":\"en~fr\","
59 "\"zip\":\"\\\\d{3}\","
60 "\"state_name_type\":\"area\","
61 "\"locality_name_type\":\"post_town\","
62 "\"sublocality_name_type\":\"neighborhood\","
63 "\"zip_name_type\":\"postal\","
65 "\"posturl\":\"http://www.testpost.com\""
69 EXPECT_NE(rule.GetFormat(), copy.GetFormat());
70 EXPECT_NE(rule.GetLatinFormat(), copy.GetLatinFormat());
71 EXPECT_NE(rule.GetId(), copy.GetId());
72 EXPECT_NE(rule.GetRequired(), copy.GetRequired());
73 EXPECT_NE(rule.GetSubKeys(), copy.GetSubKeys());
74 EXPECT_NE(rule.GetLanguages(), copy.GetLanguages());
75 EXPECT_NE(rule.GetAdminAreaNameMessageId(),
76 copy.GetAdminAreaNameMessageId());
77 EXPECT_NE(rule.GetPostalCodeNameMessageId(),
78 copy.GetPostalCodeNameMessageId());
79 EXPECT_NE(rule.GetLocalityNameMessageId(),
80 copy.GetLocalityNameMessageId());
81 EXPECT_NE(rule.GetSublocalityNameMessageId(),
82 copy.GetSublocalityNameMessageId());
83 EXPECT_NE(rule.GetName(), copy.GetName());
84 EXPECT_NE(rule.GetLatinName(), copy.GetLatinName());
85 EXPECT_NE(rule.GetPostalCodeExample(), copy.GetPostalCodeExample());
86 EXPECT_NE(rule.GetPostServiceUrl(), copy.GetPostServiceUrl());
88 EXPECT_TRUE(rule.GetPostalCodeMatcher() != NULL);
89 EXPECT_TRUE(copy.GetPostalCodeMatcher() == NULL);
92 EXPECT_EQ(rule.GetFormat(), copy.GetFormat());
93 EXPECT_EQ(rule.GetLatinFormat(), copy.GetLatinFormat());
94 EXPECT_EQ(rule.GetId(), copy.GetId());
95 EXPECT_EQ(rule.GetRequired(), copy.GetRequired());
96 EXPECT_EQ(rule.GetSubKeys(), copy.GetSubKeys());
97 EXPECT_EQ(rule.GetLanguages(), copy.GetLanguages());
98 EXPECT_EQ(rule.GetAdminAreaNameMessageId(),
99 copy.GetAdminAreaNameMessageId());
100 EXPECT_EQ(rule.GetPostalCodeNameMessageId(),
101 copy.GetPostalCodeNameMessageId());
102 EXPECT_EQ(rule.GetSublocalityNameMessageId(),
103 copy.GetSublocalityNameMessageId());
104 EXPECT_EQ(rule.GetLocalityNameMessageId(),
105 copy.GetLocalityNameMessageId());
106 EXPECT_EQ(rule.GetName(), copy.GetName());
107 EXPECT_EQ(rule.GetLatinName(), copy.GetLatinName());
108 EXPECT_EQ(rule.GetPostalCodeExample(), copy.GetPostalCodeExample());
109 EXPECT_EQ(rule.GetPostServiceUrl(), copy.GetPostServiceUrl());
111 EXPECT_TRUE(copy.GetPostalCodeMatcher() != NULL);
114 TEST(RuleTest, ParseOverwritesRule) {
116 ASSERT_TRUE(rule.ParseSerializedRule("{"
118 "\"state_name_type\":\"area\","
120 "\"zip_name_type\":\"postal\","
121 "\"zipex\":\"1234\","
122 "\"posturl\":\"http://www.testpost.com\""
124 EXPECT_FALSE(rule.GetFormat().empty());
125 EXPECT_EQ(IDS_LIBADDRESSINPUT_AREA,
126 rule.GetAdminAreaNameMessageId());
127 EXPECT_EQ(IDS_LIBADDRESSINPUT_POSTAL_CODE_LABEL,
128 rule.GetPostalCodeNameMessageId());
129 EXPECT_EQ("1234", rule.GetSolePostalCode());
130 EXPECT_EQ("1234", rule.GetPostalCodeExample());
131 EXPECT_EQ("http://www.testpost.com", rule.GetPostServiceUrl());
133 ASSERT_TRUE(rule.ParseSerializedRule("{"
135 "\"state_name_type\":\"do_si\","
136 "\"zip_name_type\":\"zip\","
137 "\"zipex\":\"5678\","
138 "\"posturl\":\"http://www.fakepost.com\""
140 EXPECT_TRUE(rule.GetFormat().empty());
141 EXPECT_EQ(IDS_LIBADDRESSINPUT_DO_SI,
142 rule.GetAdminAreaNameMessageId());
143 EXPECT_EQ(IDS_LIBADDRESSINPUT_ZIP_CODE_LABEL,
144 rule.GetPostalCodeNameMessageId());
145 EXPECT_TRUE(rule.GetSolePostalCode().empty());
146 EXPECT_EQ("5678", rule.GetPostalCodeExample());
147 EXPECT_EQ("http://www.fakepost.com", rule.GetPostServiceUrl());
150 TEST(RuleTest, ParsesFormatCorrectly) {
151 std::vector<FormatElement> expected;
152 expected.push_back(FormatElement(ADMIN_AREA));
153 expected.push_back(FormatElement(LOCALITY));
155 ASSERT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%S%C\"}"));
156 EXPECT_EQ(expected, rule.GetFormat());
159 TEST(RuleTest, ParsesNameCorrectly) {
161 ASSERT_TRUE(rule.ParseSerializedRule("{\"name\":\"Le Test\"}"));
162 EXPECT_EQ("Le Test", rule.GetName());
165 TEST(RuleTest, ParsesLatinNameCorrectly) {
167 ASSERT_TRUE(rule.ParseSerializedRule("{\"lname\":\"Testistan\"}"));
168 EXPECT_EQ("Testistan", rule.GetLatinName());
171 TEST(RuleTest, ParsesLatinFormatCorrectly) {
172 std::vector<FormatElement> expected;
173 expected.push_back(FormatElement(LOCALITY));
174 expected.push_back(FormatElement(ADMIN_AREA));
176 ASSERT_TRUE(rule.ParseSerializedRule("{\"lfmt\":\"%C%S\"}"));
177 EXPECT_EQ(expected, rule.GetLatinFormat());
180 TEST(RuleTest, ParsesRequiredCorrectly) {
181 std::vector<AddressField> expected;
182 expected.push_back(STREET_ADDRESS);
183 expected.push_back(LOCALITY);
185 ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"AC\"}"));
186 EXPECT_EQ(expected, rule.GetRequired());
189 TEST(RuleTest, ParsesSubKeysCorrectly) {
190 std::vector<std::string> expected;
191 expected.push_back("aa");
192 expected.push_back("bb");
193 expected.push_back("cc");
195 ASSERT_TRUE(rule.ParseSerializedRule("{\"sub_keys\":\"aa~bb~cc\"}"));
196 EXPECT_EQ(expected, rule.GetSubKeys());
199 TEST(RuleTest, ParsesLanguagesCorrectly) {
200 std::vector<std::string> expected;
201 expected.push_back("de");
202 expected.push_back("fr");
203 expected.push_back("it");
205 ASSERT_TRUE(rule.ParseSerializedRule("{\"languages\":\"de~fr~it\"}"));
206 EXPECT_EQ(expected, rule.GetLanguages());
209 TEST(RuleTest, ParsesPostalCodeExampleCorrectly) {
211 ASSERT_TRUE(rule.ParseSerializedRule("{\"zipex\":\"1234,12345-6789\"}"));
212 EXPECT_EQ("1234,12345-6789", rule.GetPostalCodeExample());
215 TEST(RuleTest, ParsesPostServiceUrlCorrectly) {
218 rule.ParseSerializedRule("{\"posturl\":\"http://www.testpost.com\"}"));
219 EXPECT_EQ("http://www.testpost.com", rule.GetPostServiceUrl());
222 TEST(RuleTest, PostalCodeMatcher) {
224 ASSERT_TRUE(rule.ParseSerializedRule("{\"zip\":\"\\\\d{3}\"}"));
225 EXPECT_TRUE(rule.GetPostalCodeMatcher() != NULL);
228 TEST(RuleTest, PostalCodeMatcherInvalidRegExp) {
230 ASSERT_TRUE(rule.ParseSerializedRule("{\"zip\":\"(\"}"));
231 EXPECT_TRUE(rule.GetPostalCodeMatcher() == NULL);
234 TEST(RuleTest, ParsesJsonRuleCorrectly) {
236 ASSERT_TRUE(json.ParseObject("{\"zip\":\"\\\\d{3}\"}"));
238 rule.ParseJsonRule(json);
239 EXPECT_TRUE(rule.GetPostalCodeMatcher() != NULL);
242 TEST(RuleTest, EmptyStringIsNotValid) {
244 EXPECT_FALSE(rule.ParseSerializedRule(std::string()));
247 TEST(RuleTest, EmptyDictionaryIsValid) {
249 EXPECT_TRUE(rule.ParseSerializedRule("{}"));
252 // Tests for parsing the postal code name.
253 class PostalCodeNameParseTest
254 : public testing::TestWithParam<std::pair<std::string, int> > {
256 PostalCodeNameParseTest() {}
260 DISALLOW_COPY_AND_ASSIGN(PostalCodeNameParseTest);
263 // Verifies that a postal code name is parsed correctly.
264 TEST_P(PostalCodeNameParseTest, ParsedCorrectly) {
265 ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().first));
266 EXPECT_EQ(GetParam().second, rule_.GetPostalCodeNameMessageId());
269 // Test parsing all postal code names.
270 INSTANTIATE_TEST_CASE_P(
271 AllPostalCodeNames, PostalCodeNameParseTest,
273 std::make_pair("{\"zip_name_type\":\"postal\"}",
274 IDS_LIBADDRESSINPUT_POSTAL_CODE_LABEL),
275 std::make_pair("{\"zip_name_type\":\"zip\"}",
276 IDS_LIBADDRESSINPUT_ZIP_CODE_LABEL)));
278 // Tests for parsing the locality name.
279 class LocalityNameParseTest
280 : public testing::TestWithParam<std::pair<std::string, int> > {
282 LocalityNameParseTest() {}
286 DISALLOW_COPY_AND_ASSIGN(LocalityNameParseTest);
289 // Verifies that a locality name is parsed correctly.
290 TEST_P(LocalityNameParseTest, ParsedCorrectly) {
291 ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().first));
292 EXPECT_EQ(GetParam().second, rule_.GetLocalityNameMessageId());
295 // Test parsing all locality names.
296 INSTANTIATE_TEST_CASE_P(
297 AllLocalityNames, LocalityNameParseTest,
299 std::make_pair("{\"locality_name_type\":\"post_town\"}",
300 IDS_LIBADDRESSINPUT_POST_TOWN),
301 std::make_pair("{\"locality_name_type\":\"city\"}",
302 IDS_LIBADDRESSINPUT_LOCALITY_LABEL),
303 std::make_pair("{\"locality_name_type\":\"district\"}",
304 IDS_LIBADDRESSINPUT_DISTRICT)));
306 // Tests for parsing the locality name.
307 class SublocalityNameParseTest
308 : public testing::TestWithParam<std::pair<std::string, int> > {
310 SublocalityNameParseTest() {}
314 DISALLOW_COPY_AND_ASSIGN(SublocalityNameParseTest);
317 // Verifies that a sublocality name is parsed correctly.
318 TEST_P(SublocalityNameParseTest, ParsedCorrectly) {
319 ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().first));
320 EXPECT_EQ(GetParam().second, rule_.GetSublocalityNameMessageId());
323 // Test parsing all sublocality names.
324 INSTANTIATE_TEST_CASE_P(
325 AllSublocalityNames, SublocalityNameParseTest,
327 std::make_pair("{\"sublocality_name_type\":\"village_township\"}",
328 IDS_LIBADDRESSINPUT_VILLAGE_TOWNSHIP),
329 std::make_pair("{\"sublocality_name_type\":\"neighborhood\"}",
330 IDS_LIBADDRESSINPUT_NEIGHBORHOOD),
331 std::make_pair("{\"sublocality_name_type\":\"suburb\"}",
332 IDS_LIBADDRESSINPUT_SUBURB),
333 std::make_pair("{\"sublocality_name_type\":\"district\"}",
334 IDS_LIBADDRESSINPUT_DISTRICT)));
336 // Tests for parsing the administrative area name.
337 class AdminAreaNameParseTest
338 : public testing::TestWithParam<std::pair<std::string, int> > {
340 AdminAreaNameParseTest() {}
344 DISALLOW_COPY_AND_ASSIGN(AdminAreaNameParseTest);
347 // Verifies that an administrative area name is parsed correctly.
348 TEST_P(AdminAreaNameParseTest, ParsedCorrectly) {
349 ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().first));
350 EXPECT_EQ(GetParam().second, rule_.GetAdminAreaNameMessageId());
353 // Test parsing all administrative area names.
354 INSTANTIATE_TEST_CASE_P(
355 AllAdminAreaNames, AdminAreaNameParseTest,
357 std::make_pair("{\"state_name_type\":\"area\"}",
358 IDS_LIBADDRESSINPUT_AREA),
359 std::make_pair("{\"state_name_type\":\"county\"}",
360 IDS_LIBADDRESSINPUT_COUNTY),
361 std::make_pair("{\"state_name_type\":\"department\"}",
362 IDS_LIBADDRESSINPUT_DEPARTMENT),
363 std::make_pair("{\"state_name_type\":\"district\"}",
364 IDS_LIBADDRESSINPUT_DISTRICT),
365 std::make_pair("{\"state_name_type\":\"do_si\"}",
366 IDS_LIBADDRESSINPUT_DO_SI),
367 std::make_pair("{\"state_name_type\":\"emirate\"}",
368 IDS_LIBADDRESSINPUT_EMIRATE),
369 std::make_pair("{\"state_name_type\":\"island\"}",
370 IDS_LIBADDRESSINPUT_ISLAND),
371 std::make_pair("{\"state_name_type\":\"parish\"}",
372 IDS_LIBADDRESSINPUT_PARISH),
373 std::make_pair("{\"state_name_type\":\"prefecture\"}",
374 IDS_LIBADDRESSINPUT_PREFECTURE),
375 std::make_pair("{\"state_name_type\":\"province\"}",
376 IDS_LIBADDRESSINPUT_PROVINCE),
377 std::make_pair("{\"state_name_type\":\"state\"}",
378 IDS_LIBADDRESSINPUT_STATE)));
380 // Tests for rule parsing.
381 class RuleParseTest : public testing::TestWithParam<std::string> {
385 const std::string& GetRegionData() const {
386 // GetParam() is either a region code or the region data itself.
387 // RegionDataContants::GetRegionData() returns an empty string for anything
388 // that's not a region code.
389 const std::string& data = RegionDataConstants::GetRegionData(GetParam());
390 return !data.empty() ? data : GetParam();
394 Localization localization_;
397 DISALLOW_COPY_AND_ASSIGN(RuleParseTest);
400 // Verifies that a region data can be parsed successfully.
401 TEST_P(RuleParseTest, RegionDataParsedSuccessfully) {
402 EXPECT_TRUE(rule_.ParseSerializedRule(GetRegionData()));
405 // Verifies that the admin area name type corresponds to a UI string.
406 TEST_P(RuleParseTest, AdminAreaNameTypeHasUiString) {
407 const std::string& region_data = GetRegionData();
408 rule_.ParseSerializedRule(region_data);
409 if (region_data.find("state_name_type") != std::string::npos) {
410 EXPECT_NE(INVALID_MESSAGE_ID, rule_.GetAdminAreaNameMessageId());
412 localization_.GetString(rule_.GetAdminAreaNameMessageId()).empty());
416 // Verifies that the postal code name type corresponds to a UI string.
417 TEST_P(RuleParseTest, PostalCodeNameTypeHasUiString) {
418 const std::string& region_data = GetRegionData();
419 rule_.ParseSerializedRule(region_data);
420 if (region_data.find("zip_name_type") != std::string::npos) {
421 EXPECT_NE(INVALID_MESSAGE_ID, rule_.GetPostalCodeNameMessageId());
423 localization_.GetString(rule_.GetPostalCodeNameMessageId()).empty());
427 // Verifies that the locality name type corresponds to a UI string.
428 TEST_P(RuleParseTest, LocalityNameTypeHasUiString) {
429 const std::string& region_data = GetRegionData();
430 rule_.ParseSerializedRule(region_data);
431 // The leading quote here ensures we don't match against sublocality_name_type
433 if (region_data.find("\"locality_name_type") != std::string::npos) {
434 EXPECT_NE(INVALID_MESSAGE_ID, rule_.GetLocalityNameMessageId());
436 localization_.GetString(rule_.GetLocalityNameMessageId()).empty());
440 // Verifies that the sublocality name type corresponds to a UI string.
441 TEST_P(RuleParseTest, SublocalityNameTypeHasUiString) {
442 const std::string& region_data = GetRegionData();
443 rule_.ParseSerializedRule(region_data);
444 if (region_data.find("sublocality_name_type") != std::string::npos) {
445 EXPECT_NE(INVALID_MESSAGE_ID, rule_.GetSublocalityNameMessageId());
447 localization_.GetString(rule_.GetSublocalityNameMessageId()).empty());
451 // Verifies that the sole postal code is correctly recognised and copied.
452 TEST_P(RuleParseTest, SolePostalCode) {
454 ASSERT_TRUE(rule.ParseSerializedRule("{\"zip\":\"1234\"}"));
455 EXPECT_TRUE(rule.GetPostalCodeMatcher() != NULL);
456 EXPECT_TRUE(rule.GetSolePostalCode() == "1234");
459 EXPECT_TRUE(copy.GetPostalCodeMatcher() == NULL);
460 EXPECT_TRUE(copy.GetSolePostalCode().empty());
463 EXPECT_TRUE(copy.GetPostalCodeMatcher() != NULL);
464 EXPECT_EQ(rule.GetSolePostalCode(), copy.GetSolePostalCode());
467 // Test parsing all region data.
468 INSTANTIATE_TEST_CASE_P(
469 AllRulesTest, RuleParseTest,
470 testing::ValuesIn(RegionDataConstants::GetRegionCodes()));
472 // Test parsing the default rule.
473 INSTANTIATE_TEST_CASE_P(
474 DefaultRuleTest, RuleParseTest,
475 testing::Values(RegionDataConstants::GetDefaultRegionData()));