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>
23 #include <gtest/gtest.h>
25 #include "grit/libaddressinput_strings.h"
26 #include "region_data_constants.h"
30 using i18n::addressinput::AddressField;
31 using i18n::addressinput::ADMIN_AREA;
32 using i18n::addressinput::COUNTRY;
33 using i18n::addressinput::FormatElement;
34 using i18n::addressinput::LOCALITY;
35 using i18n::addressinput::ORGANIZATION;
36 using i18n::addressinput::POSTAL_CODE;
37 using i18n::addressinput::RECIPIENT;
38 using i18n::addressinput::RegionDataConstants;
39 using i18n::addressinput::Rule;
40 using i18n::addressinput::STREET_ADDRESS;
42 bool IsFormatEmpty(const std::vector<std::vector<FormatElement> >& format) {
43 for (std::vector<std::vector<FormatElement> >::const_iterator
54 TEST(RuleTest, CopyOverwritesRule) {
56 ASSERT_TRUE(rule.ParseSerializedRule(
60 "\"state_name_type\":\"area\","
61 "\"zip_name_type\":\"postal\","
62 "\"sub_keys\":\"CA~NY~TX\","
64 "\"languages\":\"en~fr\","
65 "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\""
69 EXPECT_NE(rule.GetFormat(), copy.GetFormat());
70 EXPECT_NE(rule.GetRequired(), copy.GetRequired());
71 EXPECT_NE(rule.GetSubKeys(), copy.GetSubKeys());
72 EXPECT_NE(rule.GetLanguages(), copy.GetLanguages());
73 EXPECT_NE(rule.GetLanguage(), copy.GetLanguage());
74 EXPECT_NE(rule.GetPostalCodeFormat(), copy.GetPostalCodeFormat());
75 EXPECT_NE(rule.GetAdminAreaNameMessageId(),
76 copy.GetAdminAreaNameMessageId());
77 EXPECT_NE(rule.GetInvalidAdminAreaMessageId(),
78 copy.GetInvalidAdminAreaMessageId());
79 EXPECT_NE(rule.GetPostalCodeNameMessageId(),
80 copy.GetPostalCodeNameMessageId());
81 EXPECT_NE(rule.GetInvalidPostalCodeMessageId(),
82 copy.GetInvalidPostalCodeMessageId());
85 EXPECT_EQ(rule.GetFormat(), copy.GetFormat());
86 EXPECT_EQ(rule.GetRequired(), copy.GetRequired());
87 EXPECT_EQ(rule.GetSubKeys(), copy.GetSubKeys());
88 EXPECT_EQ(rule.GetLanguages(), copy.GetLanguages());
89 EXPECT_EQ(rule.GetLanguage(), copy.GetLanguage());
90 EXPECT_EQ(rule.GetPostalCodeFormat(), copy.GetPostalCodeFormat());
91 EXPECT_EQ(rule.GetAdminAreaNameMessageId(),
92 copy.GetAdminAreaNameMessageId());
93 EXPECT_EQ(rule.GetInvalidAdminAreaMessageId(),
94 copy.GetInvalidAdminAreaMessageId());
95 EXPECT_EQ(rule.GetPostalCodeNameMessageId(),
96 copy.GetPostalCodeNameMessageId());
97 EXPECT_EQ(rule.GetInvalidPostalCodeMessageId(),
98 copy.GetInvalidPostalCodeMessageId());
101 TEST(RuleTest, ParseOverwritesRule) {
103 ASSERT_TRUE(rule.ParseSerializedRule(
106 "\"require\":\"SZ\","
107 "\"state_name_type\":\"area\","
108 "\"zip_name_type\":\"postal\","
109 "\"sub_keys\":\"CA~NY~TX\","
111 "\"languages\":\"en~fr\","
112 "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\""
114 EXPECT_FALSE(IsFormatEmpty(rule.GetFormat()));
115 EXPECT_FALSE(rule.GetRequired().empty());
116 EXPECT_FALSE(rule.GetSubKeys().empty());
117 EXPECT_FALSE(rule.GetLanguages().empty());
118 EXPECT_FALSE(rule.GetLanguage().empty());
119 EXPECT_FALSE(rule.GetPostalCodeFormat().empty());
120 EXPECT_EQ(IDS_LIBADDRESSINPUT_I18N_AREA,
121 rule.GetAdminAreaNameMessageId());
122 EXPECT_EQ(IDS_LIBADDRESSINPUT_I18N_INVALID_AREA,
123 rule.GetInvalidAdminAreaMessageId());
124 EXPECT_EQ(IDS_LIBADDRESSINPUT_I18N_POSTAL_CODE_LABEL,
125 rule.GetPostalCodeNameMessageId());
126 EXPECT_EQ(IDS_LIBADDRESSINPUT_I18N_INVALID_POSTAL_CODE_LABEL,
127 rule.GetInvalidPostalCodeMessageId());
129 ASSERT_TRUE(rule.ParseSerializedRule(
133 "\"state_name_type\":\"do_si\","
134 "\"zip_name_type\":\"zip\","
137 "\"languages\":\"\","
140 EXPECT_TRUE(IsFormatEmpty(rule.GetFormat()));
141 EXPECT_TRUE(rule.GetRequired().empty());
142 EXPECT_TRUE(rule.GetSubKeys().empty());
143 EXPECT_TRUE(rule.GetLanguages().empty());
144 EXPECT_TRUE(rule.GetLanguage().empty());
145 EXPECT_TRUE(rule.GetPostalCodeFormat().empty());
146 EXPECT_EQ(IDS_LIBADDRESSINPUT_I18N_DO_SI,
147 rule.GetAdminAreaNameMessageId());
148 EXPECT_EQ(IDS_LIBADDRESSINPUT_I18N_INVALID_DO_SI,
149 rule.GetInvalidAdminAreaMessageId());
150 EXPECT_EQ(IDS_LIBADDRESSINPUT_I18N_ZIP_CODE_LABEL,
151 rule.GetPostalCodeNameMessageId());
152 EXPECT_EQ(IDS_LIBADDRESSINPUT_I18N_INVALID_ZIP_CODE_LABEL,
153 rule.GetInvalidPostalCodeMessageId());
156 TEST(RuleTest, ParseEmptyDataDoesNotOverwriteRule) {
158 ASSERT_TRUE(rule.ParseSerializedRule(
161 "\"require\":\"SZ\","
162 "\"state_name_type\":\"area\","
163 "\"zip_name_type\":\"postal\","
164 "\"sub_keys\":\"CA~NY~TX\","
166 "\"languages\":\"en~fr\","
167 "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\""
172 ASSERT_TRUE(copy.ParseSerializedRule("{}"));
174 EXPECT_EQ(rule.GetFormat(), copy.GetFormat());
175 EXPECT_EQ(rule.GetRequired(), copy.GetRequired());
176 EXPECT_EQ(rule.GetSubKeys(), copy.GetSubKeys());
177 EXPECT_EQ(rule.GetLanguages(), copy.GetLanguages());
178 EXPECT_EQ(rule.GetLanguage(), copy.GetLanguage());
179 EXPECT_EQ(rule.GetPostalCodeFormat(), copy.GetPostalCodeFormat());
180 EXPECT_EQ(rule.GetAdminAreaNameMessageId(),
181 copy.GetAdminAreaNameMessageId());
182 EXPECT_EQ(rule.GetInvalidAdminAreaMessageId(),
183 copy.GetInvalidAdminAreaMessageId());
184 EXPECT_EQ(rule.GetPostalCodeNameMessageId(),
185 copy.GetPostalCodeNameMessageId());
186 EXPECT_EQ(rule.GetInvalidPostalCodeMessageId(),
187 copy.GetInvalidPostalCodeMessageId());
190 TEST(RuleTest, ParseFormatWithNewLines) {
193 rule.ParseSerializedRule("{\"fmt\":\"%O%n%N%n%A%nAX-%Z %C%nÃ…LAND\"}"));
195 std::vector<std::vector<FormatElement> > expected_format;
196 expected_format.push_back(
197 std::vector<FormatElement>(1, FormatElement(ORGANIZATION)));
198 expected_format.push_back(
199 std::vector<FormatElement>(1, FormatElement(RECIPIENT)));
200 expected_format.push_back(
201 std::vector<FormatElement>(1, FormatElement(STREET_ADDRESS)));
202 expected_format.push_back(
203 std::vector<FormatElement>(1, FormatElement("AX-")));
204 expected_format.back().push_back(FormatElement(POSTAL_CODE));
205 expected_format.back().push_back(FormatElement(" "));
206 expected_format.back().push_back(FormatElement(LOCALITY));
207 expected_format.push_back(
208 std::vector<FormatElement>(1, FormatElement("Ã…LAND")));
210 EXPECT_EQ(expected_format, rule.GetFormat());
213 TEST(RuleTest, DoubleTokenPrefixDoesNotCrash) {
215 EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%%R\"}"));
218 TEST(RuleTest, DoubleNewlineFormatDoesNotCrash) {
220 EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%n%n\"}"));
223 TEST(RuleTest, FormatTokenWithoutPrefixDoesNotCrash) {
225 ASSERT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"R\"}"));
228 TEST(RuleTest, ParseDuplicateTokenInFormatDoesNotCrash) {
230 EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%R%R\"}"));
233 TEST(RuleTest, ParseInvalidFormatFieldsDoesNotCrash) {
235 EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%K%L\"}"));
238 TEST(RuleTest, PrefixWithoutTokenFormatDoesNotCrash) {
240 EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%\"}"));
243 TEST(RuleTest, EmptyStringFormatDoesNotCrash) {
245 EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"\"}"));
248 TEST(RuleTest, ParseRequiredFields) {
250 ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"ONAZC\"}"));
251 std::vector<AddressField> expected;
252 expected.push_back(ORGANIZATION);
253 expected.push_back(RECIPIENT);
254 expected.push_back(STREET_ADDRESS);
255 expected.push_back(POSTAL_CODE);
256 expected.push_back(LOCALITY);
257 EXPECT_EQ(expected, rule.GetRequired());
260 TEST(RuleTest, ParseEmptyStringRequiredFields) {
262 ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"\"}"));
263 EXPECT_TRUE(rule.GetRequired().empty());
266 TEST(RuleTest, ParseInvalidRequiredFields) {
268 ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"garbage\"}"));
269 EXPECT_TRUE(rule.GetRequired().empty());
272 TEST(RuleTest, ParseDuplicateRequiredFields) {
274 ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"SSS\"}"));
275 EXPECT_EQ(std::vector<AddressField>(3, ADMIN_AREA), rule.GetRequired());
278 TEST(RuleTest, ParsesSubKeysCorrectly) {
280 ASSERT_TRUE(rule.ParseSerializedRule("{\"sub_keys\":\"CA~NY~TX\"}"));
281 std::vector<std::string> expected;
282 expected.push_back("CA");
283 expected.push_back("NY");
284 expected.push_back("TX");
285 EXPECT_EQ(expected, rule.GetSubKeys());
288 TEST(RuleTest, ParsesLanguageCorrectly) {
290 ASSERT_TRUE(rule.ParseSerializedRule("{\"lang\":\"en\"}"));
291 EXPECT_EQ("en", rule.GetLanguage());
294 TEST(RuleTest, ParsesLanguagesCorrectly) {
296 ASSERT_TRUE(rule.ParseSerializedRule("{\"languages\":\"de~fr~it\"}"));
297 std::vector<std::string> expected;
298 expected.push_back("de");
299 expected.push_back("fr");
300 expected.push_back("it");
301 EXPECT_EQ(expected, rule.GetLanguages());
304 TEST(RuleTest, ParsesPostalCodeFormatCorrectly) {
306 ASSERT_TRUE(rule.ParseSerializedRule(
308 "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\""
310 EXPECT_EQ("\\d{5}([ \\-]\\d{4})?", rule.GetPostalCodeFormat());
313 TEST(RuleTest, EmptyStringIsNotValid) {
315 EXPECT_FALSE(rule.ParseSerializedRule(std::string()));
318 TEST(RuleTest, EmptyDictionaryIsValid) {
320 EXPECT_TRUE(rule.ParseSerializedRule("{}"));
323 TEST(RuleTest, ParseSubKeyTest) {
324 i18n::addressinput::Rule rule;
325 ASSERT_TRUE(rule.ParseSerializedRule(
326 "{ \"sub_keys\": \"FOO~BAR~BAZ\","
327 " \"sub_names\": \"Foolandia~Bartopolis~Bazmonia\","
328 " \"sub_lnames\": \"Foolandia2~Bartopolis2~Bazmonia2\" }"));
329 EXPECT_EQ(3U, rule.GetSubKeys().size());
332 EXPECT_TRUE(rule.CanonicalizeSubKey("BAR", &sub_key));
333 EXPECT_EQ("BAR", sub_key);
336 EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis", &sub_key));
337 EXPECT_EQ("BAR", sub_key);
340 EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis2", &sub_key));
341 EXPECT_EQ("BAR", sub_key);
344 EXPECT_FALSE(rule.CanonicalizeSubKey("Beertopia", &sub_key));
345 EXPECT_EQ("", sub_key);
349 LabelData(const std::string& data, int name_id, int error_id)
350 : data(data), name_id(name_id), error_id(error_id) {}
359 // Tests for parsing the postal code name.
360 class PostalCodeNameParseTest : public testing::TestWithParam<LabelData> {
365 // Verifies that a postal code name is parsed correctly.
366 TEST_P(PostalCodeNameParseTest, ParsedCorrectly) {
367 ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().data));
368 EXPECT_EQ(GetParam().name_id, rule_.GetPostalCodeNameMessageId());
369 EXPECT_EQ(GetParam().error_id, rule_.GetInvalidPostalCodeMessageId());
370 EXPECT_EQ(GetParam().error_id, rule_.GetInvalidFieldMessageId(POSTAL_CODE));
373 // Test parsing all postal code names.
374 INSTANTIATE_TEST_CASE_P(
375 AllPostalCodeNames, PostalCodeNameParseTest,
377 LabelData("{\"zip_name_type\":\"postal\"}",
378 IDS_LIBADDRESSINPUT_I18N_POSTAL_CODE_LABEL,
379 IDS_LIBADDRESSINPUT_I18N_INVALID_POSTAL_CODE_LABEL),
380 LabelData("{\"zip_name_type\":\"zip\"}",
381 IDS_LIBADDRESSINPUT_I18N_ZIP_CODE_LABEL,
382 IDS_LIBADDRESSINPUT_I18N_INVALID_ZIP_CODE_LABEL)));
384 // Tests for parsing the administrative area name.
385 class AdminAreaNameParseTest : public testing::TestWithParam<LabelData> {
390 // Verifies that an administrative area name is parsed correctly.
391 TEST_P(AdminAreaNameParseTest, ParsedCorrectly) {
392 ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().data));
393 EXPECT_EQ(GetParam().name_id, rule_.GetAdminAreaNameMessageId());
394 EXPECT_EQ(GetParam().error_id, rule_.GetInvalidAdminAreaMessageId());
395 EXPECT_EQ(GetParam().error_id, rule_.GetInvalidFieldMessageId(ADMIN_AREA));
398 // Test parsing all administrative area names.
399 INSTANTIATE_TEST_CASE_P(
400 AllAdminAreaNames, AdminAreaNameParseTest,
402 LabelData("{\"state_name_type\":\"area\"}",
403 IDS_LIBADDRESSINPUT_I18N_AREA,
404 IDS_LIBADDRESSINPUT_I18N_INVALID_AREA),
405 LabelData("{\"state_name_type\":\"county\"}",
406 IDS_LIBADDRESSINPUT_I18N_COUNTY_LABEL,
407 IDS_LIBADDRESSINPUT_I18N_INVALID_COUNTY_LABEL),
408 LabelData("{\"state_name_type\":\"department\"}",
409 IDS_LIBADDRESSINPUT_I18N_DEPARTMENT,
410 IDS_LIBADDRESSINPUT_I18N_INVALID_DEPARTMENT),
411 LabelData("{\"state_name_type\":\"district\"}",
412 IDS_LIBADDRESSINPUT_I18N_DEPENDENT_LOCALITY_LABEL,
413 IDS_LIBADDRESSINPUT_I18N_INVALID_DEPENDENT_LOCALITY_LABEL),
414 LabelData("{\"state_name_type\":\"do_si\"}",
415 IDS_LIBADDRESSINPUT_I18N_DO_SI,
416 IDS_LIBADDRESSINPUT_I18N_INVALID_DO_SI),
417 LabelData("{\"state_name_type\":\"emirate\"}",
418 IDS_LIBADDRESSINPUT_I18N_EMIRATE,
419 IDS_LIBADDRESSINPUT_I18N_INVALID_EMIRATE),
420 LabelData("{\"state_name_type\":\"island\"}",
421 IDS_LIBADDRESSINPUT_I18N_ISLAND,
422 IDS_LIBADDRESSINPUT_I18N_INVALID_ISLAND),
423 LabelData("{\"state_name_type\":\"parish\"}",
424 IDS_LIBADDRESSINPUT_I18N_PARISH,
425 IDS_LIBADDRESSINPUT_I18N_INVALID_PARISH),
426 LabelData("{\"state_name_type\":\"prefecture\"}",
427 IDS_LIBADDRESSINPUT_I18N_PREFECTURE,
428 IDS_LIBADDRESSINPUT_I18N_INVALID_PREFECTURE),
429 LabelData("{\"state_name_type\":\"province\"}",
430 IDS_LIBADDRESSINPUT_I18N_PROVINCE,
431 IDS_LIBADDRESSINPUT_I18N_INVALID_PROVINCE),
432 LabelData("{\"state_name_type\":\"state\"}",
433 IDS_LIBADDRESSINPUT_I18N_STATE_LABEL,
434 IDS_LIBADDRESSINPUT_I18N_INVALID_STATE_LABEL)));
436 // Tests for rule parsing.
437 class RuleParseTest : public testing::TestWithParam<std::string> {
439 const std::string& GetData() const {
440 return RegionDataConstants::GetRegionData(GetParam());
446 // Verifies that an address format does not contain consecutive lines with
447 // multiple fields each. Such address format (e.g. {{ELEMENT, ELEMENT},
448 // {ELEMENT, ELEMENT}}) will result in incorrect behavior of BuildComponents()
450 TEST_P(RuleParseTest, ConsecutiveLinesWithMultipleFields) {
451 ASSERT_TRUE(rule_.ParseSerializedRule(GetData()));
452 bool previous_line_has_single_field = true;
453 for (std::vector<std::vector<FormatElement> >::const_iterator
454 line_it = rule_.GetFormat().begin();
455 line_it != rule_.GetFormat().end();
458 for (std::vector<FormatElement>::const_iterator
459 element_it = line_it->begin();
460 element_it != line_it->end();
462 if (element_it->IsField()) {
466 if (num_fields == 0) {
469 ASSERT_TRUE(num_fields == 1 || previous_line_has_single_field)
470 << GetParam() << ": " << GetData();
471 previous_line_has_single_field = num_fields == 1;
475 // Verifies that a street line is surrounded by either newlines or spaces. A
476 // different format will result in incorrect behavior in
477 // AddressData::BuildDisplayLines().
478 TEST_P(RuleParseTest, StreetAddressSurroundingElements) {
479 ASSERT_TRUE(rule_.ParseSerializedRule(GetData()));
480 for (std::vector<std::vector<FormatElement> >::const_iterator
481 line_it = rule_.GetFormat().begin();
482 line_it != rule_.GetFormat().end();
484 for (size_t i = 0; i < line_it->size(); ++i) {
485 const FormatElement& element = line_it->at(i);
486 if (element.IsField() && element.field == STREET_ADDRESS) {
487 bool surrounded_by_newlines = line_it->size() == 1;
488 bool surrounded_by_spaces =
490 i < line_it->size() - 1 &&
491 !line_it->at(i - 1).IsField() &&
492 line_it->at(i - 1).literal == " " &&
493 !line_it->at(i + 1).IsField() &&
494 line_it->at(i + 1).literal == " ";
495 EXPECT_TRUE(surrounded_by_newlines || surrounded_by_spaces)
496 << GetParam() << ": " << GetData();
502 // Test parsing all region data.
503 INSTANTIATE_TEST_CASE_P(
504 AllRulesTest, RuleParseTest,
505 testing::ValuesIn(RegionDataConstants::GetRegionCodes()));