| OLD | NEW |
|---|
| (Empty) |
| 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 | |
| 19 #include <string> | |
| 20 #include <utility> | |
| 21 #include <vector> | |
| 22 | |
| 23 #include <gtest/gtest.h> | |
| 24 | |
| 25 #include "region_data_constants.h" | |
| 26 | |
| 27 namespace { | |
| 28 | |
| 29 using i18n::addressinput::AddressField; | |
| 30 using i18n::addressinput::ADMIN_AREA; | |
| 31 using i18n::addressinput::COUNTRY; | |
| 32 using i18n::addressinput::FormatElement; | |
| 33 using i18n::addressinput::LOCALITY; | |
| 34 using i18n::addressinput::ORGANIZATION; | |
| 35 using i18n::addressinput::POSTAL_CODE; | |
| 36 using i18n::addressinput::RECIPIENT; | |
| 37 using i18n::addressinput::RegionDataConstants; | |
| 38 using i18n::addressinput::Rule; | |
| 39 using i18n::addressinput::STREET_ADDRESS; | |
| 40 | |
| 41 bool IsFormatEmpty(const std::vector<std::vector<FormatElement> >& format) { | |
| 42 for (std::vector<std::vector<FormatElement> >::const_iterator | |
| 43 it = format.begin(); | |
| 44 it != format.end(); | |
| 45 ++it) { | |
| 46 if (!it->empty()) { | |
| 47 return false; | |
| 48 } | |
| 49 } | |
| 50 return true; | |
| 51 } | |
| 52 | |
| 53 TEST(RuleTest, CopyOverwritesRule) { | |
| 54 Rule rule; | |
| 55 ASSERT_TRUE(rule.ParseSerializedRule( | |
| 56 "{" | |
| 57 "\"fmt\":\"%S%Z\"," | |
| 58 "\"require\":\"SZ\"," | |
| 59 "\"state_name_type\":\"area\"," | |
| 60 "\"zip_name_type\":\"postal\"," | |
| 61 "\"sub_keys\":\"CA~NY~TX\"," | |
| 62 "\"lang\":\"en\"," | |
| 63 "\"languages\":\"en~fr\"," | |
| 64 "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\"" | |
| 65 "}")); | |
| 66 | |
| 67 Rule copy; | |
| 68 EXPECT_NE(rule.GetFormat(), copy.GetFormat()); | |
| 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.GetLanguage(), copy.GetLanguage()); | |
| 73 EXPECT_NE(rule.GetPostalCodeFormat(), copy.GetPostalCodeFormat()); | |
| 74 EXPECT_NE(rule.GetAdminAreaNameType(), | |
| 75 copy.GetAdminAreaNameType()); | |
| 76 EXPECT_NE(rule.GetPostalCodeNameType(), | |
| 77 copy.GetPostalCodeNameType()); | |
| 78 | |
| 79 copy.CopyFrom(rule); | |
| 80 EXPECT_EQ(rule.GetFormat(), copy.GetFormat()); | |
| 81 EXPECT_EQ(rule.GetRequired(), copy.GetRequired()); | |
| 82 EXPECT_EQ(rule.GetSubKeys(), copy.GetSubKeys()); | |
| 83 EXPECT_EQ(rule.GetLanguages(), copy.GetLanguages()); | |
| 84 EXPECT_EQ(rule.GetLanguage(), copy.GetLanguage()); | |
| 85 EXPECT_EQ(rule.GetPostalCodeFormat(), copy.GetPostalCodeFormat()); | |
| 86 EXPECT_EQ(rule.GetAdminAreaNameType(), | |
| 87 copy.GetAdminAreaNameType()); | |
| 88 EXPECT_EQ(rule.GetPostalCodeNameType(), | |
| 89 copy.GetPostalCodeNameType()); | |
| 90 } | |
| 91 | |
| 92 TEST(RuleTest, ParseOverwritesRule) { | |
| 93 Rule rule; | |
| 94 ASSERT_TRUE(rule.ParseSerializedRule( | |
| 95 "{" | |
| 96 "\"fmt\":\"%S%Z\"," | |
| 97 "\"require\":\"SZ\"," | |
| 98 "\"state_name_type\":\"area\"," | |
| 99 "\"zip_name_type\":\"postal\"," | |
| 100 "\"sub_keys\":\"CA~NY~TX\"," | |
| 101 "\"lang\":\"en\"," | |
| 102 "\"languages\":\"en~fr\"," | |
| 103 "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\"" | |
| 104 "}")); | |
| 105 EXPECT_FALSE(IsFormatEmpty(rule.GetFormat())); | |
| 106 EXPECT_FALSE(rule.GetRequired().empty()); | |
| 107 EXPECT_FALSE(rule.GetSubKeys().empty()); | |
| 108 EXPECT_FALSE(rule.GetLanguages().empty()); | |
| 109 EXPECT_FALSE(rule.GetLanguage().empty()); | |
| 110 EXPECT_FALSE(rule.GetPostalCodeFormat().empty()); | |
| 111 EXPECT_EQ("area", rule.GetAdminAreaNameType()); | |
| 112 EXPECT_EQ("postal", rule.GetPostalCodeNameType()); | |
| 113 | |
| 114 ASSERT_TRUE(rule.ParseSerializedRule( | |
| 115 "{" | |
| 116 "\"fmt\":\"\"," | |
| 117 "\"require\":\"\"," | |
| 118 "\"state_name_type\":\"do_si\"," | |
| 119 "\"zip_name_type\":\"zip\"," | |
| 120 "\"sub_keys\":\"\"," | |
| 121 "\"lang\":\"\"," | |
| 122 "\"languages\":\"\"," | |
| 123 "\"zip\":\"\"" | |
| 124 "}")); | |
| 125 EXPECT_TRUE(IsFormatEmpty(rule.GetFormat())); | |
| 126 EXPECT_TRUE(rule.GetRequired().empty()); | |
| 127 EXPECT_TRUE(rule.GetSubKeys().empty()); | |
| 128 EXPECT_TRUE(rule.GetLanguages().empty()); | |
| 129 EXPECT_TRUE(rule.GetLanguage().empty()); | |
| 130 EXPECT_TRUE(rule.GetPostalCodeFormat().empty()); | |
| 131 EXPECT_EQ("do_si", rule.GetAdminAreaNameType()); | |
| 132 EXPECT_EQ("zip", rule.GetPostalCodeNameType()); | |
| 133 } | |
| 134 | |
| 135 TEST(RuleTest, ParseEmptyDataDoesNotOverwriteRule) { | |
| 136 Rule rule; | |
| 137 ASSERT_TRUE(rule.ParseSerializedRule( | |
| 138 "{" | |
| 139 "\"fmt\":\"%S%Z\"," | |
| 140 "\"require\":\"SZ\"," | |
| 141 "\"state_name_type\":\"area\"," | |
| 142 "\"zip_name_type\":\"postal\"," | |
| 143 "\"sub_keys\":\"CA~NY~TX\"," | |
| 144 "\"lang\":\"en\"," | |
| 145 "\"languages\":\"en~fr\"," | |
| 146 "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\"" | |
| 147 "}")); | |
| 148 | |
| 149 Rule copy; | |
| 150 copy.CopyFrom(rule); | |
| 151 ASSERT_TRUE(copy.ParseSerializedRule("{}")); | |
| 152 | |
| 153 EXPECT_EQ(rule.GetFormat(), copy.GetFormat()); | |
| 154 EXPECT_EQ(rule.GetRequired(), copy.GetRequired()); | |
| 155 EXPECT_EQ(rule.GetSubKeys(), copy.GetSubKeys()); | |
| 156 EXPECT_EQ(rule.GetLanguages(), copy.GetLanguages()); | |
| 157 EXPECT_EQ(rule.GetLanguage(), copy.GetLanguage()); | |
| 158 EXPECT_EQ(rule.GetPostalCodeFormat(), copy.GetPostalCodeFormat()); | |
| 159 EXPECT_EQ(rule.GetAdminAreaNameType(), | |
| 160 copy.GetAdminAreaNameType()); | |
| 161 EXPECT_EQ(rule.GetPostalCodeNameType(), | |
| 162 copy.GetPostalCodeNameType()); | |
| 163 } | |
| 164 | |
| 165 TEST(RuleTest, ParseFormatWithNewLines) { | |
| 166 Rule rule; | |
| 167 ASSERT_TRUE( | |
| 168 rule.ParseSerializedRule("{\"fmt\":\"%O%n%N%n%A%nAX-%Z %C%nÅLAND\"}")); | |
| 169 | |
| 170 std::vector<std::vector<FormatElement> > expected_format; | |
| 171 expected_format.push_back( | |
| 172 std::vector<FormatElement>(1, FormatElement(ORGANIZATION))); | |
| 173 expected_format.push_back( | |
| 174 std::vector<FormatElement>(1, FormatElement(RECIPIENT))); | |
| 175 expected_format.push_back( | |
| 176 std::vector<FormatElement>(1, FormatElement(STREET_ADDRESS))); | |
| 177 expected_format.push_back( | |
| 178 std::vector<FormatElement>(1, FormatElement("AX-"))); | |
| 179 expected_format.back().push_back(FormatElement(POSTAL_CODE)); | |
| 180 expected_format.back().push_back(FormatElement(" ")); | |
| 181 expected_format.back().push_back(FormatElement(LOCALITY)); | |
| 182 expected_format.push_back( | |
| 183 std::vector<FormatElement>(1, FormatElement("ÅLAND"))); | |
| 184 | |
| 185 EXPECT_EQ(expected_format, rule.GetFormat()); | |
| 186 } | |
| 187 | |
| 188 TEST(RuleTest, DoubleTokenPrefixDoesNotCrash) { | |
| 189 Rule rule; | |
| 190 EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%%R\"}")); | |
| 191 } | |
| 192 | |
| 193 TEST(RuleTest, DoubleNewlineFormatDoesNotCrash) { | |
| 194 Rule rule; | |
| 195 EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%n%n\"}")); | |
| 196 } | |
| 197 | |
| 198 TEST(RuleTest, FormatTokenWithoutPrefixDoesNotCrash) { | |
| 199 Rule rule; | |
| 200 ASSERT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"R\"}")); | |
| 201 } | |
| 202 | |
| 203 TEST(RuleTest, ParseDuplicateTokenInFormatDoesNotCrash) { | |
| 204 Rule rule; | |
| 205 EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%R%R\"}")); | |
| 206 } | |
| 207 | |
| 208 TEST(RuleTest, ParseInvalidFormatFieldsDoesNotCrash) { | |
| 209 Rule rule; | |
| 210 EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%K%L\"}")); | |
| 211 } | |
| 212 | |
| 213 TEST(RuleTest, PrefixWithoutTokenFormatDoesNotCrash) { | |
| 214 Rule rule; | |
| 215 EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%\"}")); | |
| 216 } | |
| 217 | |
| 218 TEST(RuleTest, EmptyStringFormatDoesNotCrash) { | |
| 219 Rule rule; | |
| 220 EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"\"}")); | |
| 221 } | |
| 222 | |
| 223 TEST(RuleTest, ParseRequiredFields) { | |
| 224 Rule rule; | |
| 225 ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"ONAZC\"}")); | |
| 226 std::vector<AddressField> expected; | |
| 227 expected.push_back(ORGANIZATION); | |
| 228 expected.push_back(RECIPIENT); | |
| 229 expected.push_back(STREET_ADDRESS); | |
| 230 expected.push_back(POSTAL_CODE); | |
| 231 expected.push_back(LOCALITY); | |
| 232 EXPECT_EQ(expected, rule.GetRequired()); | |
| 233 } | |
| 234 | |
| 235 TEST(RuleTest, ParseEmptyStringRequiredFields) { | |
| 236 Rule rule; | |
| 237 ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"\"}")); | |
| 238 EXPECT_TRUE(rule.GetRequired().empty()); | |
| 239 } | |
| 240 | |
| 241 TEST(RuleTest, ParseInvalidRequiredFields) { | |
| 242 Rule rule; | |
| 243 ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"garbage\"}")); | |
| 244 EXPECT_TRUE(rule.GetRequired().empty()); | |
| 245 } | |
| 246 | |
| 247 TEST(RuleTest, ParseDuplicateRequiredFields) { | |
| 248 Rule rule; | |
| 249 ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"SSS\"}")); | |
| 250 EXPECT_EQ(std::vector<AddressField>(3, ADMIN_AREA), rule.GetRequired()); | |
| 251 } | |
| 252 | |
| 253 TEST(RuleTest, ParsesSubKeysCorrectly) { | |
| 254 Rule rule; | |
| 255 ASSERT_TRUE(rule.ParseSerializedRule("{\"sub_keys\":\"CA~NY~TX\"}")); | |
| 256 std::vector<std::string> expected; | |
| 257 expected.push_back("CA"); | |
| 258 expected.push_back("NY"); | |
| 259 expected.push_back("TX"); | |
| 260 EXPECT_EQ(expected, rule.GetSubKeys()); | |
| 261 } | |
| 262 | |
| 263 TEST(RuleTest, ParsesLanguageCorrectly) { | |
| 264 Rule rule; | |
| 265 ASSERT_TRUE(rule.ParseSerializedRule("{\"lang\":\"en\"}")); | |
| 266 EXPECT_EQ("en", rule.GetLanguage()); | |
| 267 } | |
| 268 | |
| 269 TEST(RuleTest, ParsesLanguagesCorrectly) { | |
| 270 Rule rule; | |
| 271 ASSERT_TRUE(rule.ParseSerializedRule("{\"languages\":\"de~fr~it\"}")); | |
| 272 std::vector<std::string> expected; | |
| 273 expected.push_back("de"); | |
| 274 expected.push_back("fr"); | |
| 275 expected.push_back("it"); | |
| 276 EXPECT_EQ(expected, rule.GetLanguages()); | |
| 277 } | |
| 278 | |
| 279 TEST(RuleTest, ParsesPostalCodeFormatCorrectly) { | |
| 280 Rule rule; | |
| 281 ASSERT_TRUE(rule.ParseSerializedRule( | |
| 282 "{" | |
| 283 "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\"" | |
| 284 "}")); | |
| 285 EXPECT_EQ("\\d{5}([ \\-]\\d{4})?", rule.GetPostalCodeFormat()); | |
| 286 } | |
| 287 | |
| 288 TEST(RuleTest, EmptyStringIsNotValid) { | |
| 289 Rule rule; | |
| 290 EXPECT_FALSE(rule.ParseSerializedRule(std::string())); | |
| 291 } | |
| 292 | |
| 293 TEST(RuleTest, EmptyDictionaryIsValid) { | |
| 294 Rule rule; | |
| 295 EXPECT_TRUE(rule.ParseSerializedRule("{}")); | |
| 296 } | |
| 297 | |
| 298 TEST(RuleTest, ParseSubKeyTest) { | |
| 299 i18n::addressinput::Rule rule; | |
| 300 ASSERT_TRUE(rule.ParseSerializedRule( | |
| 301 "{ \"sub_keys\": \"FOO~BAR~BAZ\"," | |
| 302 " \"sub_names\": \"Foolandia~Bartopolis~Bazmonia\"," | |
| 303 " \"sub_lnames\": \"Foolandia2~Bartopolis2~Bazmonia2\" }")); | |
| 304 EXPECT_EQ(3U, rule.GetSubKeys().size()); | |
| 305 | |
| 306 std::string sub_key; | |
| 307 EXPECT_TRUE(rule.CanonicalizeSubKey("BAR", false, &sub_key)); | |
| 308 EXPECT_EQ("BAR", sub_key); | |
| 309 sub_key.clear(); | |
| 310 | |
| 311 EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis", false, &sub_key)); | |
| 312 EXPECT_EQ("BAR", sub_key); | |
| 313 sub_key.clear(); | |
| 314 | |
| 315 // Unlatinize. | |
| 316 EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis2", false, &sub_key)); | |
| 317 EXPECT_EQ("BAR", sub_key); | |
| 318 sub_key.clear(); | |
| 319 | |
| 320 // Keep input latin. | |
| 321 EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis2", true, &sub_key)); | |
| 322 EXPECT_EQ("Bartopolis2", sub_key); | |
| 323 sub_key.clear(); | |
| 324 | |
| 325 EXPECT_FALSE(rule.CanonicalizeSubKey("Beertopia", false, &sub_key)); | |
| 326 EXPECT_EQ("", sub_key); | |
| 327 } | |
| 328 | |
| 329 struct LabelData { | |
| 330 LabelData(const std::string& data, const std::string& name_type) | |
| 331 : data(data), name_type(name_type) {} | |
| 332 | |
| 333 ~LabelData() {} | |
| 334 | |
| 335 std::string data; | |
| 336 std::string name_type; | |
| 337 }; | |
| 338 | |
| 339 // Tests for parsing the postal code name. | |
| 340 class PostalCodeNameParseTest : public testing::TestWithParam<LabelData> { | |
| 341 protected: | |
| 342 Rule rule_; | |
| 343 }; | |
| 344 | |
| 345 // Verifies that a postal code name is parsed correctly. | |
| 346 TEST_P(PostalCodeNameParseTest, ParsedCorrectly) { | |
| 347 ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().data)); | |
| 348 EXPECT_EQ(GetParam().name_type, rule_.GetPostalCodeNameType()); | |
| 349 } | |
| 350 | |
| 351 // Test parsing all postal code names. | |
| 352 INSTANTIATE_TEST_CASE_P( | |
| 353 AllPostalCodeNames, PostalCodeNameParseTest, | |
| 354 testing::Values( | |
| 355 LabelData("{\"zip_name_type\":\"postal\"}", "postal"), | |
| 356 LabelData("{\"zip_name_type\":\"zip\"}", "zip"))); | |
| 357 | |
| 358 // Tests for parsing the administrative area name. | |
| 359 class AdminAreaNameParseTest : public testing::TestWithParam<LabelData> { | |
| 360 protected: | |
| 361 Rule rule_; | |
| 362 }; | |
| 363 | |
| 364 // Verifies that an administrative area name is parsed correctly. | |
| 365 TEST_P(AdminAreaNameParseTest, ParsedCorrectly) { | |
| 366 ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().data)); | |
| 367 EXPECT_EQ(GetParam().name_type, rule_.GetAdminAreaNameType()); | |
| 368 } | |
| 369 | |
| 370 // Test parsing all administrative area names. | |
| 371 INSTANTIATE_TEST_CASE_P( | |
| 372 AllAdminAreaNames, AdminAreaNameParseTest, | |
| 373 testing::Values( | |
| 374 LabelData("{\"state_name_type\":\"area\"}", "area"), | |
| 375 LabelData("{\"state_name_type\":\"county\"}", "county"), | |
| 376 LabelData("{\"state_name_type\":\"department\"}", "department"), | |
| 377 LabelData("{\"state_name_type\":\"district\"}", "district"), | |
| 378 LabelData("{\"state_name_type\":\"do_si\"}", "do_si"), | |
| 379 LabelData("{\"state_name_type\":\"emirate\"}", "emirate"), | |
| 380 LabelData("{\"state_name_type\":\"island\"}", "island"), | |
| 381 LabelData("{\"state_name_type\":\"parish\"}", "parish"), | |
| 382 LabelData("{\"state_name_type\":\"prefecture\"}", "prefecture"), | |
| 383 LabelData("{\"state_name_type\":\"province\"}", "province"), | |
| 384 LabelData("{\"state_name_type\":\"state\"}", "state"))); | |
| 385 | |
| 386 // Verifies that an address format does not contain consecutive lines with | |
| 387 // multiple fields each. Such address format (e.g. {{ELEMENT, ELEMENT}, | |
| 388 // {ELEMENT, ELEMENT}}) will result in incorrect behavior of BuildComponents() | |
| 389 // public API. | |
| 390 TEST(RuleParseTest, ConsecutiveLinesWithMultipleFields) { | |
| 391 const std::vector<std::string>& region_codes = | |
| 392 RegionDataConstants::GetRegionCodes(); | |
| 393 Rule rule; | |
| 394 for (size_t i = 0; i < region_codes.size(); ++i) { | |
| 395 const std::string& region_data = | |
| 396 RegionDataConstants::GetRegionData(region_codes[i]); | |
| 397 SCOPED_TRACE(region_codes[i] + ": " + region_data); | |
| 398 | |
| 399 ASSERT_TRUE(rule.ParseSerializedRule(region_data)); | |
| 400 bool previous_line_has_single_field = true; | |
| 401 for (std::vector<std::vector<FormatElement> >::const_iterator | |
| 402 line_it = rule.GetFormat().begin(); | |
| 403 line_it != rule.GetFormat().end(); | |
| 404 ++line_it) { | |
| 405 int num_fields = 0; | |
| 406 for (std::vector<FormatElement>::const_iterator | |
| 407 element_it = line_it->begin(); | |
| 408 element_it != line_it->end(); | |
| 409 ++element_it) { | |
| 410 if (element_it->IsField()) { | |
| 411 ++num_fields; | |
| 412 } | |
| 413 } | |
| 414 if (num_fields == 0) { | |
| 415 continue; | |
| 416 } | |
| 417 ASSERT_TRUE(num_fields == 1 || previous_line_has_single_field); | |
| 418 previous_line_has_single_field = num_fields == 1; | |
| 419 } | |
| 420 } | |
| 421 } | |
| 422 | |
| 423 // Verifies that a street line is surrounded by either newlines or spaces. A | |
| 424 // different format will result in incorrect behavior in | |
| 425 // AddressData::BuildDisplayLines(). | |
| 426 TEST(RuleParseTest, StreetAddressSurroundingElements) { | |
| 427 const std::vector<std::string>& region_codes = | |
| 428 RegionDataConstants::GetRegionCodes(); | |
| 429 Rule rule; | |
| 430 for (size_t i = 0; i < region_codes.size(); ++i) { | |
| 431 const std::string& region_data = | |
| 432 RegionDataConstants::GetRegionData(region_codes[i]); | |
| 433 SCOPED_TRACE(region_codes[i] + ": " + region_data); | |
| 434 | |
| 435 ASSERT_TRUE(rule.ParseSerializedRule(region_data)); | |
| 436 for (std::vector<std::vector<FormatElement> >::const_iterator | |
| 437 line_it = rule.GetFormat().begin(); | |
| 438 line_it != rule.GetFormat().end(); | |
| 439 ++line_it) { | |
| 440 for (size_t i = 0; i < line_it->size(); ++i) { | |
| 441 const FormatElement& element = line_it->at(i); | |
| 442 if (element.IsField() && element.field == STREET_ADDRESS) { | |
| 443 bool surrounded_by_newlines = line_it->size() == 1; | |
| 444 bool surrounded_by_spaces = | |
| 445 i > 0 && | |
| 446 i < line_it->size() - 1 && | |
| 447 !line_it->at(i - 1).IsField() && | |
| 448 line_it->at(i - 1).literal == " " && | |
| 449 !line_it->at(i + 1).IsField() && | |
| 450 line_it->at(i + 1).literal == " "; | |
| 451 EXPECT_TRUE(surrounded_by_newlines || surrounded_by_spaces); | |
| 452 } | |
| 453 } | |
| 454 } | |
| 455 } | |
| 456 } | |
| 457 | |
| 458 } // namespace | |
| OLD | NEW |
|---|
Chromium Code Reviews
Issue 298863012:
Use upstream libaddressinput in Chrome. (Closed)
Base URL: svn://svn.chromium.org/chrome/trunk/src