src/third_party/libaddressinput/chromium/cpp/test/rule_test.cc

   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 "grit/libaddressinput_strings.h"
  26 #include "region_data_constants.h"
  27
  28 namespace {
  29
  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;
  41
  42 bool IsFormatEmpty(const std::vector<std::vector<FormatElement> >& format) {
  43   for (std::vector<std::vector<FormatElement> >::const_iterator
  44            it = format.begin();
  45        it != format.end();
  46        ++it) {
  47     if (!it->empty()) {
  48       return false;
  49     }
  50   }
  51   return true;
  52 }
  53
  54 TEST(RuleTest, CopyOverwritesRule) {
  55   Rule rule;
  56   ASSERT_TRUE(rule.ParseSerializedRule(
  57       "{"
  58       "\"fmt\":\"%S%Z\","
  59       "\"require\":\"SZ\","
  60       "\"state_name_type\":\"area\","
  61       "\"zip_name_type\":\"postal\","
  62       "\"sub_keys\":\"CA~NY~TX\","
  63       "\"lang\":\"en\","
  64       "\"languages\":\"en~fr\","
  65       "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\""
  66       "}"));
  67
  68   Rule copy;
  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());
  83
  84   copy.CopyFrom(rule);
  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());
  99 }
 100
 101 TEST(RuleTest, ParseOverwritesRule) {
 102   Rule rule;
 103   ASSERT_TRUE(rule.ParseSerializedRule(
 104       "{"
 105       "\"fmt\":\"%S%Z\","
 106       "\"require\":\"SZ\","
 107       "\"state_name_type\":\"area\","
 108       "\"zip_name_type\":\"postal\","
 109       "\"sub_keys\":\"CA~NY~TX\","
 110       "\"lang\":\"en\","
 111       "\"languages\":\"en~fr\","
 112       "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\""
 113       "}"));
 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());
 128
 129   ASSERT_TRUE(rule.ParseSerializedRule(
 130       "{"
 131       "\"fmt\":\"\","
 132       "\"require\":\"\","
 133       "\"state_name_type\":\"do_si\","
 134       "\"zip_name_type\":\"zip\","
 135       "\"sub_keys\":\"\","
 136       "\"lang\":\"\","
 137       "\"languages\":\"\","
 138       "\"zip\":\"\""
 139       "}"));
 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());
 154 }
 155
 156 TEST(RuleTest, ParseEmptyDataDoesNotOverwriteRule) {
 157   Rule rule;
 158   ASSERT_TRUE(rule.ParseSerializedRule(
 159       "{"
 160       "\"fmt\":\"%S%Z\","
 161       "\"require\":\"SZ\","
 162       "\"state_name_type\":\"area\","
 163       "\"zip_name_type\":\"postal\","
 164       "\"sub_keys\":\"CA~NY~TX\","
 165       "\"lang\":\"en\","
 166       "\"languages\":\"en~fr\","
 167       "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\""
 168       "}"));
 169
 170   Rule copy;
 171   copy.CopyFrom(rule);
 172   ASSERT_TRUE(copy.ParseSerializedRule("{}"));
 173
 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());
 188 }
 189
 190 TEST(RuleTest, ParseFormatWithNewLines) {
 191   Rule rule;
 192   ASSERT_TRUE(
 193       rule.ParseSerializedRule("{\"fmt\":\"%O%n%N%n%A%nAX-%Z %C%nÅLAND\"}"));
 194
 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")));
 209
 210   EXPECT_EQ(expected_format, rule.GetFormat());
 211 }
 212
 213 TEST(RuleTest, DoubleTokenPrefixDoesNotCrash) {
 214   Rule rule;
 215   EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%%R\"}"));
 216 }
 217
 218 TEST(RuleTest, DoubleNewlineFormatDoesNotCrash) {
 219   Rule rule;
 220   EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%n%n\"}"));
 221 }
 222
 223 TEST(RuleTest, FormatTokenWithoutPrefixDoesNotCrash) {
 224   Rule rule;
 225   ASSERT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"R\"}"));
 226 }
 227
 228 TEST(RuleTest, ParseDuplicateTokenInFormatDoesNotCrash) {
 229   Rule rule;
 230   EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%R%R\"}"));
 231 }
 232
 233 TEST(RuleTest, ParseInvalidFormatFieldsDoesNotCrash) {
 234   Rule rule;
 235   EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%K%L\"}"));
 236 }
 237
 238 TEST(RuleTest, PrefixWithoutTokenFormatDoesNotCrash) {
 239   Rule rule;
 240   EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%\"}"));
 241 }
 242
 243 TEST(RuleTest, EmptyStringFormatDoesNotCrash) {
 244   Rule rule;
 245   EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"\"}"));
 246 }
 247
 248 TEST(RuleTest, ParseRequiredFields) {
 249   Rule rule;
 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());
 258 }
 259
 260 TEST(RuleTest, ParseEmptyStringRequiredFields) {
 261   Rule rule;
 262   ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"\"}"));
 263   EXPECT_TRUE(rule.GetRequired().empty());
 264 }
 265
 266 TEST(RuleTest, ParseInvalidRequiredFields) {
 267   Rule rule;
 268   ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"garbage\"}"));
 269   EXPECT_TRUE(rule.GetRequired().empty());
 270 }
 271
 272 TEST(RuleTest, ParseDuplicateRequiredFields) {
 273   Rule rule;
 274   ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"SSS\"}"));
 275   EXPECT_EQ(std::vector<AddressField>(3, ADMIN_AREA), rule.GetRequired());
 276 }
 277
 278 TEST(RuleTest, ParsesSubKeysCorrectly) {
 279   Rule rule;
 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());
 286 }
 287
 288 TEST(RuleTest, ParsesLanguageCorrectly) {
 289   Rule rule;
 290   ASSERT_TRUE(rule.ParseSerializedRule("{\"lang\":\"en\"}"));
 291   EXPECT_EQ("en", rule.GetLanguage());
 292 }
 293
 294 TEST(RuleTest, ParsesLanguagesCorrectly) {
 295   Rule rule;
 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());
 302 }
 303
 304 TEST(RuleTest, ParsesPostalCodeFormatCorrectly) {
 305   Rule rule;
 306   ASSERT_TRUE(rule.ParseSerializedRule(
 307       "{"
 308       "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\""
 309       "}"));
 310   EXPECT_EQ("\\d{5}([ \\-]\\d{4})?", rule.GetPostalCodeFormat());
 311 }
 312
 313 TEST(RuleTest, EmptyStringIsNotValid) {
 314   Rule rule;
 315   EXPECT_FALSE(rule.ParseSerializedRule(std::string()));
 316 }
 317
 318 TEST(RuleTest, EmptyDictionaryIsValid) {
 319   Rule rule;
 320   EXPECT_TRUE(rule.ParseSerializedRule("{}"));
 321 }
 322
 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());
 330
 331   std::string sub_key;
 332   EXPECT_TRUE(rule.CanonicalizeSubKey("BAR", false, &sub_key));
 333   EXPECT_EQ("BAR", sub_key);
 334   sub_key.clear();
 335
 336   EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis", false, &sub_key));
 337   EXPECT_EQ("BAR", sub_key);
 338   sub_key.clear();
 339
 340   // Unlatinize.
 341   EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis2", false, &sub_key));
 342   EXPECT_EQ("BAR", sub_key);
 343   sub_key.clear();
 344
 345   // Keep input latin.
 346   EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis2", true, &sub_key));
 347   EXPECT_EQ("Bartopolis2", sub_key);
 348   sub_key.clear();
 349
 350   EXPECT_FALSE(rule.CanonicalizeSubKey("Beertopia", false, &sub_key));
 351   EXPECT_EQ("", sub_key);
 352 }
 353
 354 struct LabelData {
 355   LabelData(const std::string& data, int name_id, int error_id)
 356       : data(data), name_id(name_id), error_id(error_id) {}
 357
 358   ~LabelData() {}
 359
 360   std::string data;
 361   int name_id;
 362   int error_id;
 363 };
 364
 365 // Tests for parsing the postal code name.
 366 class PostalCodeNameParseTest : public testing::TestWithParam<LabelData> {
 367  protected:
 368   Rule rule_;
 369 };
 370
 371 // Verifies that a postal code name is parsed correctly.
 372 TEST_P(PostalCodeNameParseTest, ParsedCorrectly) {
 373   ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().data));
 374   EXPECT_EQ(GetParam().name_id, rule_.GetPostalCodeNameMessageId());
 375   EXPECT_EQ(GetParam().error_id, rule_.GetInvalidPostalCodeMessageId());
 376   EXPECT_EQ(GetParam().error_id, rule_.GetInvalidFieldMessageId(POSTAL_CODE));
 377 }
 378
 379 // Test parsing all postal code names.
 380 INSTANTIATE_TEST_CASE_P(
 381     AllPostalCodeNames, PostalCodeNameParseTest,
 382     testing::Values(
 383         LabelData("{\"zip_name_type\":\"postal\"}",
 384                   IDS_LIBADDRESSINPUT_I18N_POSTAL_CODE_LABEL,
 385                   IDS_LIBADDRESSINPUT_I18N_INVALID_POSTAL_CODE_LABEL),
 386         LabelData("{\"zip_name_type\":\"zip\"}",
 387                   IDS_LIBADDRESSINPUT_I18N_ZIP_CODE_LABEL,
 388                   IDS_LIBADDRESSINPUT_I18N_INVALID_ZIP_CODE_LABEL)));
 389
 390 // Tests for parsing the administrative area name.
 391 class AdminAreaNameParseTest : public testing::TestWithParam<LabelData> {
 392  protected:
 393   Rule rule_;
 394 };
 395
 396 // Verifies that an administrative area name is parsed correctly.
 397 TEST_P(AdminAreaNameParseTest, ParsedCorrectly) {
 398   ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().data));
 399   EXPECT_EQ(GetParam().name_id, rule_.GetAdminAreaNameMessageId());
 400   EXPECT_EQ(GetParam().error_id, rule_.GetInvalidAdminAreaMessageId());
 401   EXPECT_EQ(GetParam().error_id, rule_.GetInvalidFieldMessageId(ADMIN_AREA));
 402 }
 403
 404 // Test parsing all administrative area names.
 405 INSTANTIATE_TEST_CASE_P(
 406     AllAdminAreaNames, AdminAreaNameParseTest,
 407     testing::Values(
 408         LabelData("{\"state_name_type\":\"area\"}",
 409                   IDS_LIBADDRESSINPUT_I18N_AREA,
 410                   IDS_LIBADDRESSINPUT_I18N_INVALID_AREA),
 411         LabelData("{\"state_name_type\":\"county\"}",
 412                   IDS_LIBADDRESSINPUT_I18N_COUNTY_LABEL,
 413                   IDS_LIBADDRESSINPUT_I18N_INVALID_COUNTY_LABEL),
 414         LabelData("{\"state_name_type\":\"department\"}",
 415                   IDS_LIBADDRESSINPUT_I18N_DEPARTMENT,
 416                   IDS_LIBADDRESSINPUT_I18N_INVALID_DEPARTMENT),
 417         LabelData("{\"state_name_type\":\"district\"}",
 418                   IDS_LIBADDRESSINPUT_I18N_DEPENDENT_LOCALITY_LABEL,
 419                   IDS_LIBADDRESSINPUT_I18N_INVALID_DEPENDENT_LOCALITY_LABEL),
 420         LabelData("{\"state_name_type\":\"do_si\"}",
 421                   IDS_LIBADDRESSINPUT_I18N_DO_SI,
 422                   IDS_LIBADDRESSINPUT_I18N_INVALID_DO_SI),
 423         LabelData("{\"state_name_type\":\"emirate\"}",
 424                   IDS_LIBADDRESSINPUT_I18N_EMIRATE,
 425                   IDS_LIBADDRESSINPUT_I18N_INVALID_EMIRATE),
 426         LabelData("{\"state_name_type\":\"island\"}",
 427                   IDS_LIBADDRESSINPUT_I18N_ISLAND,
 428                   IDS_LIBADDRESSINPUT_I18N_INVALID_ISLAND),
 429         LabelData("{\"state_name_type\":\"parish\"}",
 430                   IDS_LIBADDRESSINPUT_I18N_PARISH,
 431                   IDS_LIBADDRESSINPUT_I18N_INVALID_PARISH),
 432         LabelData("{\"state_name_type\":\"prefecture\"}",
 433                   IDS_LIBADDRESSINPUT_I18N_PREFECTURE,
 434                   IDS_LIBADDRESSINPUT_I18N_INVALID_PREFECTURE),
 435         LabelData("{\"state_name_type\":\"province\"}",
 436                   IDS_LIBADDRESSINPUT_I18N_PROVINCE,
 437                   IDS_LIBADDRESSINPUT_I18N_INVALID_PROVINCE),
 438         LabelData("{\"state_name_type\":\"state\"}",
 439                   IDS_LIBADDRESSINPUT_I18N_STATE_LABEL,
 440                   IDS_LIBADDRESSINPUT_I18N_INVALID_STATE_LABEL)));
 441
 442 // Verifies that an address format does not contain consecutive lines with
 443 // multiple fields each. Such address format (e.g. {{ELEMENT, ELEMENT},
 444 // {ELEMENT, ELEMENT}}) will result in incorrect behavior of BuildComponents()
 445 // public API.
 446 TEST(RuleParseTest, ConsecutiveLinesWithMultipleFields) {
 447   const std::vector<std::string>& region_codes =
 448       RegionDataConstants::GetRegionCodes();
 449   Rule rule;
 450   for (size_t i = 0; i < region_codes.size(); ++i) {
 451     const std::string& region_data =
 452         RegionDataConstants::GetRegionData(region_codes[i]);
 453     SCOPED_TRACE(region_codes[i] + ": " + region_data);
 454
 455     ASSERT_TRUE(rule.ParseSerializedRule(region_data));
 456     bool previous_line_has_single_field = true;
 457     for (std::vector<std::vector<FormatElement> >::const_iterator
 458              line_it = rule.GetFormat().begin();
 459          line_it != rule.GetFormat().end();
 460          ++line_it) {
 461       int num_fields = 0;
 462       for (std::vector<FormatElement>::const_iterator
 463                element_it = line_it->begin();
 464            element_it != line_it->end();
 465            ++element_it) {
 466         if (element_it->IsField()) {
 467           ++num_fields;
 468         }
 469       }
 470       if (num_fields == 0) {
 471         continue;
 472       }
 473       ASSERT_TRUE(num_fields == 1 || previous_line_has_single_field);
 474       previous_line_has_single_field = num_fields == 1;
 475     }
 476   }
 477 }
 478
 479 // Verifies that a street line is surrounded by either newlines or spaces. A
 480 // different format will result in incorrect behavior in
 481 // AddressData::BuildDisplayLines().
 482 TEST(RuleParseTest, StreetAddressSurroundingElements) {
 483   const std::vector<std::string>& region_codes =
 484       RegionDataConstants::GetRegionCodes();
 485   Rule rule;
 486   for (size_t i = 0; i < region_codes.size(); ++i) {
 487     const std::string& region_data =
 488         RegionDataConstants::GetRegionData(region_codes[i]);
 489     SCOPED_TRACE(region_codes[i] + ": " + region_data);
 490
 491     ASSERT_TRUE(rule.ParseSerializedRule(region_data));
 492     for (std::vector<std::vector<FormatElement> >::const_iterator
 493              line_it = rule.GetFormat().begin();
 494          line_it != rule.GetFormat().end();
 495          ++line_it) {
 496       for (size_t i = 0; i < line_it->size(); ++i) {
 497         const FormatElement& element = line_it->at(i);
 498         if (element.IsField() && element.field == STREET_ADDRESS) {
 499           bool surrounded_by_newlines = line_it->size() == 1;
 500           bool surrounded_by_spaces =
 501               i > 0 &&
 502               i < line_it->size() - 1 &&
 503               !line_it->at(i - 1).IsField() &&
 504               line_it->at(i - 1).literal == " " &&
 505               !line_it->at(i + 1).IsField() &&
 506               line_it->at(i + 1).literal == " ";
 507           EXPECT_TRUE(surrounded_by_newlines || surrounded_by_spaces);
 508         }
 509       }
 510     }
 511   }
 512 }
 513
 514 }  // namespace