[rac] Format an address for display.

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

 // Copyright (C) 2013 Google Inc.
 //
 // Licensed under the Apache License, Version 2.0 (the "License");
 // you may not use this file except in compliance with the License.
 // You may obtain a copy of the License at
 //
 // http://www.apache.org/licenses/LICENSE-2.0
 //
 // Unless required by applicable law or agreed to in writing, software
 // distributed under the License is distributed on an "AS IS" BASIS,
@@ skipping 12 matching lines @@
 #include <gtest/gtest.h>
 
 #include "messages.h"
 #include "region_data_constants.h"
 
 namespace {
 
 using i18n::addressinput::AddressField;
 using i18n::addressinput::ADMIN_AREA;
 using i18n::addressinput::COUNTRY;
+using i18n::addressinput::FormatElement;
 using i18n::addressinput::LOCALITY;
 using i18n::addressinput::ORGANIZATION;
 using i18n::addressinput::POSTAL_CODE;
 using i18n::addressinput::RECIPIENT;
 using i18n::addressinput::RegionDataConstants;
 using i18n::addressinput::Rule;
 using i18n::addressinput::STREET_ADDRESS;
 
-bool IsFormatEmpty(const std::vector<std::vector<AddressField> >& format) {
-  for (std::vector<std::vector<AddressField> >::const_iterator
-       it = format.begin(); it != format.end(); ++it) {
+bool IsFormatEmpty(const std::vector<std::vector<FormatElement> >& format) {
+  for (std::vector<std::vector<FormatElement> >::const_iterator
+           it = format.begin();
+       it != format.end();
+       ++it) {
     if (!it->empty()) {
       return false;
     }
   }
   return true;
 }
 
 TEST(RuleTest, CopyOverwritesRule) {
   Rule rule;
   ASSERT_TRUE(rule.ParseSerializedRule(
@@ skipping 127 matching lines @@
   EXPECT_EQ(rule.GetPostalCodeNameMessageId(),
             copy.GetPostalCodeNameMessageId());
   EXPECT_EQ(rule.GetInvalidPostalCodeMessageId(),
             copy.GetInvalidPostalCodeMessageId());
 }
 
 TEST(RuleTest, ParseFormatWithNewLines) {
   Rule rule;
   ASSERT_TRUE(
       rule.ParseSerializedRule("{\"fmt\":\"%O%n%N%n%A%nAX-%Z %C%nÅLAND\"}"));
-  std::vector<std::vector<AddressField> > expected_format;
-  expected_format.push_back(std::vector<AddressField>(1, ORGANIZATION));
-  expected_format.push_back(std::vector<AddressField>(1, RECIPIENT));
-  expected_format.push_back(std::vector<AddressField>(1, STREET_ADDRESS));
-  expected_format.push_back(std::vector<AddressField>(1, POSTAL_CODE));
-  expected_format.back().push_back(LOCALITY);
-  expected_format.push_back(std::vector<AddressField>());
+
+  std::vector<std::vector<FormatElement> > expected_format;
+  expected_format.push_back(
+      std::vector<FormatElement>(1, FormatElement(ORGANIZATION)));
+  expected_format.push_back(
+      std::vector<FormatElement>(1, FormatElement(RECIPIENT)));
+  expected_format.push_back(
+      std::vector<FormatElement>(1, FormatElement(STREET_ADDRESS)));
+  expected_format.push_back(
+      std::vector<FormatElement>(1, FormatElement("AX-")));
+  expected_format.back().push_back(FormatElement(POSTAL_CODE));
+  expected_format.back().push_back(FormatElement(" "));
+  expected_format.back().push_back(FormatElement(LOCALITY));
+  expected_format.push_back(
+      std::vector<FormatElement>(1, FormatElement("ÅLAND")));
+
   EXPECT_EQ(expected_format, rule.GetFormat());
 }
 
 TEST(RuleTest, DoubleTokenPrefixDoesNotCrash) {
   Rule rule;
   EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%%R\"}"));
 }
 
 TEST(RuleTest, DoubleNewlineFormatDoesNotCrash) {
   Rule rule;
@@ skipping 198 matching lines @@
   Rule rule_;
 };
 
 // Verifies that an address format does not contain consecutive lines with
 // multiple fields each. Such address format (e.g. {{ELEMENT, ELEMENT},
 // {ELEMENT, ELEMENT}}) will result in incorrect behavior of BuildComponents()
 // public API.
 TEST_P(RuleParseTest, ConsecutiveLinesWithMultipleFields) {
   ASSERT_TRUE(rule_.ParseSerializedRule(GetData()));
   bool previous_line_has_single_field = true;
-  for (std::vector<std::vector<AddressField> >::const_iterator
-       line_it = rule_.GetFormat().begin();
+  for (std::vector<std::vector<FormatElement> >::const_iterator
+           line_it = rule_.GetFormat().begin();
        line_it != rule_.GetFormat().end();
        ++line_it) {
-    if (line_it->empty()) {
+    int num_fields = 0;
+    for (std::vector<FormatElement>::const_iterator
+             element_it = line_it->begin();
+         element_it != line_it->end();
+         ++element_it) {
+      if (element_it->type == FormatElement::FIELD) {
+        ++num_fields;
+      }
+    }
+    if (num_fields == 0) {
       continue;
     }
-    ASSERT_TRUE(line_it->size() == 1 || previous_line_has_single_field)
+    ASSERT_TRUE(num_fields == 1 || previous_line_has_single_field)
         << GetParam() << ": " << GetData();
-    previous_line_has_single_field = line_it->size() == 1;
+    previous_line_has_single_field = num_fields == 1;
   }
 }
 
+// Verifies that a street line is surrounded by either newlines or spaces. A
+// different format will result in incorrect behavior in
+// AddressData::ToString().
+TEST_P(RuleParseTest, StreetAddressSurroundingElements) {
+  ASSERT_TRUE(rule_.ParseSerializedRule(GetData()));
+  for (std::vector<std::vector<FormatElement> >::const_iterator
+           line_it = rule_.GetFormat().begin();
+       line_it != rule_.GetFormat().end();
+       ++line_it) {
+    for (size_t i = 0; i < line_it->size(); ++i) {
+      const FormatElement& element = line_it->at(i);
+      if (element.type == FormatElement::FIELD &&
+          element.field == STREET_ADDRESS) {
+        bool surrounded_by_newlines = line_it->size() == 1;
+        bool surrounded_by_spaces =
+            i > 0 &&
+            i < line_it->size() - 1 &&
+            line_it->at(i - 1).type == FormatElement::LITERAL &&
+            line_it->at(i - 1).literal == " " &&
+            line_it->at(i + 1).type == FormatElement::LITERAL &&
+            line_it->at(i + 1).literal == " ";
+        EXPECT_TRUE(surrounded_by_newlines || surrounded_by_spaces)
+            << GetParam() << ": " << GetData();
+      }
+    }
+  }
+}
+
 // Test parsing all region data.
 INSTANTIATE_TEST_CASE_P(
     AllRulesTest, RuleParseTest,
     testing::ValuesIn(RegionDataConstants::GetRegionCodes()));
 
 }  // namespace