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", &sub_key));
 333   EXPECT_EQ("BAR", sub_key);
 334   sub_key.clear();
 335
 336   EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis", &sub_key));
 337   EXPECT_EQ("BAR", sub_key);
 338   sub_key.clear();
 339
 340   EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis2", &sub_key));
 341   EXPECT_EQ("BAR", sub_key);
 342   sub_key.clear();
 343
 344   EXPECT_FALSE(rule.CanonicalizeSubKey("Beertopia", &sub_key));
 345   EXPECT_EQ("", sub_key);
 346 }
 347
 348 struct LabelData {
 349   LabelData(const std::string& data, int name_id, int error_id)
 350       : data(data), name_id(name_id), error_id(error_id) {}
 351
 352   ~LabelData() {}
 353
 354   std::string data;
 355   int name_id;
 356   int error_id;
 357 };
 358
 359 // Tests for parsing the postal code name.
 360 class PostalCodeNameParseTest : public testing::TestWithParam<LabelData> {
 361  protected:
 362   Rule rule_;
 363 };
 364
 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));
 371 }
 372
 373 // Test parsing all postal code names.
 374 INSTANTIATE_TEST_CASE_P(
 375     AllPostalCodeNames, PostalCodeNameParseTest,
 376     testing::Values(
 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)));
 383
 384 // Tests for parsing the administrative area name.
 385 class AdminAreaNameParseTest : public testing::TestWithParam<LabelData> {
 386  protected:
 387   Rule rule_;
 388 };
 389
 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));
 396 }
 397
 398 // Test parsing all administrative area names.
 399 INSTANTIATE_TEST_CASE_P(
 400     AllAdminAreaNames, AdminAreaNameParseTest,
 401     testing::Values(
 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)));
 435
 436 // Tests for rule parsing.
 437 class RuleParseTest : public testing::TestWithParam<std::string> {
 438  protected:
 439   const std::string& GetData() const {
 440     return RegionDataConstants::GetRegionData(GetParam());
 441   }
 442
 443   Rule rule_;
 444 };
 445
 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()
 449 // public API.
 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();
 456        ++line_it) {
 457     int num_fields = 0;
 458     for (std::vector<FormatElement>::const_iterator
 459              element_it = line_it->begin();
 460          element_it != line_it->end();
 461          ++element_it) {
 462       if (element_it->IsField()) {
 463         ++num_fields;
 464       }
 465     }
 466     if (num_fields == 0) {
 467       continue;
 468     }
 469     ASSERT_TRUE(num_fields == 1 || previous_line_has_single_field)
 470         << GetParam() << ": " << GetData();
 471     previous_line_has_single_field = num_fields == 1;
 472   }
 473 }
 474
 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();
 483        ++line_it) {
 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 =
 489             i > 0 &&
 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();
 497       }
 498     }
 499   }
 500 }
 501
 502 // Test parsing all region data.
 503 INSTANTIATE_TEST_CASE_P(
 504     AllRulesTest, RuleParseTest,
 505     testing::ValuesIn(RegionDataConstants::GetRegionCodes()));
 506
 507 }  // namespace