1 // Copyright (C) 2013 Google Inc. 2 // 3 // Licensed under the Apache License, Version 2.0 (the "License"); 4 // you may not use this file except in compliance with the License. 5 // You may obtain a copy of the License at 6 // 7 // http://www.apache.org/licenses/LICENSE-2.0 8 // 9 // Unless required by applicable law or agreed to in writing, software 10 // distributed under the License is distributed on an "AS IS" BASIS, 11 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 // See the License for the specific language governing permissions and 13 // limitations under the License. 14 15 #include "rule.h" 16 17 #include <libaddressinput/address_field.h> 18 #include <libaddressinput/localization.h> 19 20 #include <cstddef> 21 #include <string> 22 #include <utility> 23 #include <vector> 24 25 #include <gtest/gtest.h> 26 27 #include "address_field_util.h" 28 #include "format_element.h" 29 #include "grit.h" 30 #include "messages.h" 31 #include "region_data_constants.h" 32 #include "util/json.h" 33 34 namespace { 35 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; 46 47 TEST(RuleTest, CopyOverwritesRule) { 48 Rule rule; 49 ASSERT_TRUE(rule.ParseSerializedRule("{" 50 "\"fmt\":\"%S%Z\"," 51 "\"lfmt\":\"%Z%S\"," 52 "\"id\":\"data/XA\"," 53 "\"name\":\"Le Test\"," 54 "\"lname\":\"Testistan\"," 55 "\"require\":\"AC\"," 56 "\"sub_keys\":\"aa~bb~cc\"," 57 "\"languages\":\"en~fr\"," 58 "\"zip\":\"\\\\d{3}\"," 59 "\"state_name_type\":\"area\"," 60 "\"zip_name_type\":\"postal\"," 61 "\"zipex\":\"1234\"," 62 "\"posturl\":\"http://www.testpost.com\"" 63 "}")); 64 65 Rule copy; 66 EXPECT_NE(rule.GetFormat(), copy.GetFormat()); 67 EXPECT_NE(rule.GetLatinFormat(), copy.GetLatinFormat()); 68 EXPECT_NE(rule.GetId(), copy.GetId()); 69 EXPECT_NE(rule.GetRequired(), copy.GetRequired()); 70 EXPECT_NE(rule.GetSubKeys(), copy.GetSubKeys()); 71 EXPECT_NE(rule.GetLanguages(), copy.GetLanguages()); 72 EXPECT_NE(rule.GetAdminAreaNameMessageId(), 73 copy.GetAdminAreaNameMessageId()); 74 EXPECT_NE(rule.GetPostalCodeNameMessageId(), 75 copy.GetPostalCodeNameMessageId()); 76 EXPECT_NE(rule.GetName(), copy.GetName()); 77 EXPECT_NE(rule.GetLatinName(), copy.GetLatinName()); 78 EXPECT_NE(rule.GetPostalCodeExample(), copy.GetPostalCodeExample()); 79 EXPECT_NE(rule.GetPostServiceUrl(), copy.GetPostServiceUrl()); 80 81 EXPECT_TRUE(rule.GetPostalCodeMatcher() != NULL); 82 EXPECT_TRUE(copy.GetPostalCodeMatcher() == NULL); 83 84 copy.CopyFrom(rule); 85 EXPECT_EQ(rule.GetFormat(), copy.GetFormat()); 86 EXPECT_EQ(rule.GetLatinFormat(), copy.GetLatinFormat()); 87 EXPECT_EQ(rule.GetId(), copy.GetId()); 88 EXPECT_EQ(rule.GetRequired(), copy.GetRequired()); 89 EXPECT_EQ(rule.GetSubKeys(), copy.GetSubKeys()); 90 EXPECT_EQ(rule.GetLanguages(), copy.GetLanguages()); 91 EXPECT_EQ(rule.GetAdminAreaNameMessageId(), 92 copy.GetAdminAreaNameMessageId()); 93 EXPECT_EQ(rule.GetPostalCodeNameMessageId(), 94 copy.GetPostalCodeNameMessageId()); 95 EXPECT_EQ(rule.GetName(), copy.GetName()); 96 EXPECT_EQ(rule.GetLatinName(), copy.GetLatinName()); 97 EXPECT_EQ(rule.GetPostalCodeExample(), copy.GetPostalCodeExample()); 98 EXPECT_EQ(rule.GetPostServiceUrl(), copy.GetPostServiceUrl()); 99 100 EXPECT_TRUE(copy.GetPostalCodeMatcher() != NULL); 101 } 102 103 TEST(RuleTest, ParseOverwritesRule) { 104 Rule rule; 105 ASSERT_TRUE(rule.ParseSerializedRule("{" 106 "\"fmt\":\"%S%Z\"," 107 "\"state_name_type\":\"area\"," 108 "\"zip\":\"1234\"," 109 "\"zip_name_type\":\"postal\"," 110 "\"zipex\":\"1234\"," 111 "\"posturl\":\"http://www.testpost.com\"" 112 "}")); 113 EXPECT_FALSE(rule.GetFormat().empty()); 114 EXPECT_EQ(IDS_LIBADDRESSINPUT_AREA, 115 rule.GetAdminAreaNameMessageId()); 116 EXPECT_EQ(IDS_LIBADDRESSINPUT_POSTAL_CODE_LABEL, 117 rule.GetPostalCodeNameMessageId()); 118 EXPECT_EQ("1234", rule.GetSolePostalCode()); 119 EXPECT_EQ("1234", rule.GetPostalCodeExample()); 120 EXPECT_EQ("http://www.testpost.com", rule.GetPostServiceUrl()); 121 122 ASSERT_TRUE(rule.ParseSerializedRule("{" 123 "\"fmt\":\"\"," 124 "\"state_name_type\":\"do_si\"," 125 "\"zip_name_type\":\"zip\"," 126 "\"zipex\":\"5678\"," 127 "\"posturl\":\"http://www.fakepost.com\"" 128 "}")); 129 EXPECT_TRUE(rule.GetFormat().empty()); 130 EXPECT_EQ(IDS_LIBADDRESSINPUT_DO_SI, 131 rule.GetAdminAreaNameMessageId()); 132 EXPECT_EQ(IDS_LIBADDRESSINPUT_ZIP_CODE_LABEL, 133 rule.GetPostalCodeNameMessageId()); 134 EXPECT_TRUE(rule.GetSolePostalCode().empty()); 135 EXPECT_EQ("5678", rule.GetPostalCodeExample()); 136 EXPECT_EQ("http://www.fakepost.com", rule.GetPostServiceUrl()); 137 } 138 139 TEST(RuleTest, ParsesFormatCorrectly) { 140 std::vector<FormatElement> expected; 141 expected.push_back(FormatElement(ADMIN_AREA)); 142 expected.push_back(FormatElement(LOCALITY)); 143 Rule rule; 144 ASSERT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%S%C\"}")); 145 EXPECT_EQ(expected, rule.GetFormat()); 146 } 147 148 TEST(RuleTest, ParsesNameCorrectly) { 149 Rule rule; 150 ASSERT_TRUE(rule.ParseSerializedRule("{\"name\":\"Le Test\"}")); 151 EXPECT_EQ("Le Test", rule.GetName()); 152 } 153 154 TEST(RuleTest, ParsesLatinNameCorrectly) { 155 Rule rule; 156 ASSERT_TRUE(rule.ParseSerializedRule("{\"lname\":\"Testistan\"}")); 157 EXPECT_EQ("Testistan", rule.GetLatinName()); 158 } 159 160 TEST(RuleTest, ParsesLatinFormatCorrectly) { 161 std::vector<FormatElement> expected; 162 expected.push_back(FormatElement(LOCALITY)); 163 expected.push_back(FormatElement(ADMIN_AREA)); 164 Rule rule; 165 ASSERT_TRUE(rule.ParseSerializedRule("{\"lfmt\":\"%C%S\"}")); 166 EXPECT_EQ(expected, rule.GetLatinFormat()); 167 } 168 169 TEST(RuleTest, ParsesRequiredCorrectly) { 170 std::vector<AddressField> expected; 171 expected.push_back(STREET_ADDRESS); 172 expected.push_back(LOCALITY); 173 Rule rule; 174 ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"AC\"}")); 175 EXPECT_EQ(expected, rule.GetRequired()); 176 } 177 178 TEST(RuleTest, ParsesSubKeysCorrectly) { 179 std::vector<std::string> expected; 180 expected.push_back("aa"); 181 expected.push_back("bb"); 182 expected.push_back("cc"); 183 Rule rule; 184 ASSERT_TRUE(rule.ParseSerializedRule("{\"sub_keys\":\"aa~bb~cc\"}")); 185 EXPECT_EQ(expected, rule.GetSubKeys()); 186 } 187 188 TEST(RuleTest, ParsesLanguagesCorrectly) { 189 std::vector<std::string> expected; 190 expected.push_back("de"); 191 expected.push_back("fr"); 192 expected.push_back("it"); 193 Rule rule; 194 ASSERT_TRUE(rule.ParseSerializedRule("{\"languages\":\"de~fr~it\"}")); 195 EXPECT_EQ(expected, rule.GetLanguages()); 196 } 197 198 TEST(RuleTest, ParsesPostalCodeExampleCorrectly) { 199 Rule rule; 200 ASSERT_TRUE(rule.ParseSerializedRule("{\"zipex\":\"1234,12345-6789\"}")); 201 EXPECT_EQ("1234,12345-6789", rule.GetPostalCodeExample()); 202 } 203 204 TEST(RuleTest, ParsesPostServiceUrlCorrectly) { 205 Rule rule; 206 ASSERT_TRUE( 207 rule.ParseSerializedRule("{\"posturl\":\"http://www.testpost.com\"}")); 208 EXPECT_EQ("http://www.testpost.com", rule.GetPostServiceUrl()); 209 } 210 211 TEST(RuleTest, PostalCodeMatcher) { 212 Rule rule; 213 ASSERT_TRUE(rule.ParseSerializedRule("{\"zip\":\"\\\\d{3}\"}")); 214 EXPECT_TRUE(rule.GetPostalCodeMatcher() != NULL); 215 } 216 217 TEST(RuleTest, PostalCodeMatcherInvalidRegExp) { 218 Rule rule; 219 ASSERT_TRUE(rule.ParseSerializedRule("{\"zip\":\"(\"}")); 220 EXPECT_TRUE(rule.GetPostalCodeMatcher() == NULL); 221 } 222 223 TEST(RuleTest, ParsesJsonRuleCorrectly) { 224 Json json; 225 ASSERT_TRUE(json.ParseObject("{\"zip\":\"\\\\d{3}\"}")); 226 Rule rule; 227 rule.ParseJsonRule(json); 228 EXPECT_TRUE(rule.GetPostalCodeMatcher() != NULL); 229 } 230 231 TEST(RuleTest, EmptyStringIsNotValid) { 232 Rule rule; 233 EXPECT_FALSE(rule.ParseSerializedRule(std::string())); 234 } 235 236 TEST(RuleTest, EmptyDictionaryIsValid) { 237 Rule rule; 238 EXPECT_TRUE(rule.ParseSerializedRule("{}")); 239 } 240 241 // Tests for parsing the postal code name. 242 class PostalCodeNameParseTest 243 : public testing::TestWithParam<std::pair<std::string, int> > { 244 protected: 245 Rule rule_; 246 }; 247 248 // Verifies that a postal code name is parsed correctly. 249 TEST_P(PostalCodeNameParseTest, ParsedCorrectly) { 250 ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().first)); 251 EXPECT_EQ(GetParam().second, rule_.GetPostalCodeNameMessageId()); 252 } 253 254 // Test parsing all postal code names. 255 INSTANTIATE_TEST_CASE_P( 256 AllPostalCodeNames, PostalCodeNameParseTest, 257 testing::Values( 258 std::make_pair("{\"zip_name_type\":\"postal\"}", 259 IDS_LIBADDRESSINPUT_POSTAL_CODE_LABEL), 260 std::make_pair("{\"zip_name_type\":\"zip\"}", 261 IDS_LIBADDRESSINPUT_ZIP_CODE_LABEL))); 262 263 // Tests for parsing the administrative area name. 264 class AdminAreaNameParseTest 265 : public testing::TestWithParam<std::pair<std::string, int> > { 266 protected: 267 Rule rule_; 268 }; 269 270 // Verifies that an administrative area name is parsed correctly. 271 TEST_P(AdminAreaNameParseTest, ParsedCorrectly) { 272 ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().first)); 273 EXPECT_EQ(GetParam().second, rule_.GetAdminAreaNameMessageId()); 274 } 275 276 // Test parsing all administrative area names. 277 INSTANTIATE_TEST_CASE_P( 278 AllAdminAreaNames, AdminAreaNameParseTest, 279 testing::Values( 280 std::make_pair("{\"state_name_type\":\"area\"}", 281 IDS_LIBADDRESSINPUT_AREA), 282 std::make_pair("{\"state_name_type\":\"county\"}", 283 IDS_LIBADDRESSINPUT_COUNTY), 284 std::make_pair("{\"state_name_type\":\"department\"}", 285 IDS_LIBADDRESSINPUT_DEPARTMENT), 286 std::make_pair("{\"state_name_type\":\"district\"}", 287 IDS_LIBADDRESSINPUT_DISTRICT), 288 std::make_pair("{\"state_name_type\":\"do_si\"}", 289 IDS_LIBADDRESSINPUT_DO_SI), 290 std::make_pair("{\"state_name_type\":\"emirate\"}", 291 IDS_LIBADDRESSINPUT_EMIRATE), 292 std::make_pair("{\"state_name_type\":\"island\"}", 293 IDS_LIBADDRESSINPUT_ISLAND), 294 std::make_pair("{\"state_name_type\":\"parish\"}", 295 IDS_LIBADDRESSINPUT_PARISH), 296 std::make_pair("{\"state_name_type\":\"prefecture\"}", 297 IDS_LIBADDRESSINPUT_PREFECTURE), 298 std::make_pair("{\"state_name_type\":\"province\"}", 299 IDS_LIBADDRESSINPUT_PROVINCE), 300 std::make_pair("{\"state_name_type\":\"state\"}", 301 IDS_LIBADDRESSINPUT_STATE))); 302 303 // Tests for rule parsing. 304 class RuleParseTest : public testing::TestWithParam<std::string> { 305 protected: 306 const std::string& GetRegionData() const { 307 // GetParam() is either a region code or the region data itself. 308 // RegionDataContants::GetRegionData() returns an empty string for anything 309 // that's not a region code. 310 const std::string& data = RegionDataConstants::GetRegionData(GetParam()); 311 return !data.empty() ? data : GetParam(); 312 } 313 314 Rule rule_; 315 Localization localization_; 316 }; 317 318 // Verifies that a region data can be parsed successfully. 319 TEST_P(RuleParseTest, RegionDataParsedSuccessfully) { 320 EXPECT_TRUE(rule_.ParseSerializedRule(GetRegionData())); 321 } 322 323 // Verifies that the admin area name type corresponds to a UI string. 324 TEST_P(RuleParseTest, AdminAreaNameTypeHasUiString) { 325 const std::string& region_data = GetRegionData(); 326 rule_.ParseSerializedRule(region_data); 327 if (region_data.find("state_name_type") != std::string::npos) { 328 EXPECT_NE(INVALID_MESSAGE_ID, rule_.GetAdminAreaNameMessageId()); 329 EXPECT_FALSE( 330 localization_.GetString(rule_.GetAdminAreaNameMessageId()).empty()); 331 } 332 } 333 334 // Verifies that the postal code name type corresponds to a UI string. 335 TEST_P(RuleParseTest, PostalCodeNameTypeHasUiString) { 336 const std::string& region_data = GetRegionData(); 337 rule_.ParseSerializedRule(region_data); 338 if (region_data.find("zip_name_type") != std::string::npos) { 339 EXPECT_NE(INVALID_MESSAGE_ID, rule_.GetPostalCodeNameMessageId()); 340 EXPECT_FALSE( 341 localization_.GetString(rule_.GetPostalCodeNameMessageId()).empty()); 342 } 343 } 344 345 // Verifies that the sole postal code is correctly recognised and copied. 346 TEST_P(RuleParseTest, SolePostalCode) { 347 Rule rule; 348 ASSERT_TRUE(rule.ParseSerializedRule("{\"zip\":\"1234\"}")); 349 EXPECT_TRUE(rule.GetPostalCodeMatcher() != NULL); 350 EXPECT_TRUE(rule.GetSolePostalCode() == "1234"); 351 352 Rule copy; 353 EXPECT_TRUE(copy.GetPostalCodeMatcher() == NULL); 354 EXPECT_TRUE(copy.GetSolePostalCode().empty()); 355 356 copy.CopyFrom(rule); 357 EXPECT_TRUE(copy.GetPostalCodeMatcher() != NULL); 358 EXPECT_EQ(rule.GetSolePostalCode(), copy.GetSolePostalCode()); 359 } 360 361 // Test parsing all region data. 362 INSTANTIATE_TEST_CASE_P( 363 AllRulesTest, RuleParseTest, 364 testing::ValuesIn(RegionDataConstants::GetRegionCodes())); 365 366 // Test parsing the default rule. 367 INSTANTIATE_TEST_CASE_P( 368 DefaultRuleTest, RuleParseTest, 369 testing::Values(RegionDataConstants::GetDefaultRegionData())); 370 371 } // namespace 372
