| // 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, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| |
| #include "rule.h" |
| |
| #include <libaddressinput/address_field.h> |
| |
| #include <string> |
| #include <utility> |
| #include <vector> |
| |
| #include <gtest/gtest.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<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( |
| "{" |
| "\"fmt\":\"%S%Z\"," |
| "\"require\":\"SZ\"," |
| "\"state_name_type\":\"area\"," |
| "\"zip_name_type\":\"postal\"," |
| "\"sub_keys\":\"CA~NY~TX\"," |
| "\"lang\":\"en\"," |
| "\"languages\":\"en~fr\"," |
| "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\"" |
| "}")); |
| |
| Rule copy; |
| EXPECT_NE(rule.GetFormat(), copy.GetFormat()); |
| EXPECT_NE(rule.GetRequired(), copy.GetRequired()); |
| EXPECT_NE(rule.GetSubKeys(), copy.GetSubKeys()); |
| EXPECT_NE(rule.GetLanguages(), copy.GetLanguages()); |
| EXPECT_NE(rule.GetLanguage(), copy.GetLanguage()); |
| EXPECT_NE(rule.GetPostalCodeFormat(), copy.GetPostalCodeFormat()); |
| EXPECT_NE(rule.GetAdminAreaNameType(), |
| copy.GetAdminAreaNameType()); |
| EXPECT_NE(rule.GetPostalCodeNameType(), |
| copy.GetPostalCodeNameType()); |
| |
| copy.CopyFrom(rule); |
| EXPECT_EQ(rule.GetFormat(), copy.GetFormat()); |
| EXPECT_EQ(rule.GetRequired(), copy.GetRequired()); |
| EXPECT_EQ(rule.GetSubKeys(), copy.GetSubKeys()); |
| EXPECT_EQ(rule.GetLanguages(), copy.GetLanguages()); |
| EXPECT_EQ(rule.GetLanguage(), copy.GetLanguage()); |
| EXPECT_EQ(rule.GetPostalCodeFormat(), copy.GetPostalCodeFormat()); |
| EXPECT_EQ(rule.GetAdminAreaNameType(), |
| copy.GetAdminAreaNameType()); |
| EXPECT_EQ(rule.GetPostalCodeNameType(), |
| copy.GetPostalCodeNameType()); |
| } |
| |
| TEST(RuleTest, ParseOverwritesRule) { |
| Rule rule; |
| ASSERT_TRUE(rule.ParseSerializedRule( |
| "{" |
| "\"fmt\":\"%S%Z\"," |
| "\"require\":\"SZ\"," |
| "\"state_name_type\":\"area\"," |
| "\"zip_name_type\":\"postal\"," |
| "\"sub_keys\":\"CA~NY~TX\"," |
| "\"lang\":\"en\"," |
| "\"languages\":\"en~fr\"," |
| "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\"" |
| "}")); |
| EXPECT_FALSE(IsFormatEmpty(rule.GetFormat())); |
| EXPECT_FALSE(rule.GetRequired().empty()); |
| EXPECT_FALSE(rule.GetSubKeys().empty()); |
| EXPECT_FALSE(rule.GetLanguages().empty()); |
| EXPECT_FALSE(rule.GetLanguage().empty()); |
| EXPECT_FALSE(rule.GetPostalCodeFormat().empty()); |
| EXPECT_EQ("area", rule.GetAdminAreaNameType()); |
| EXPECT_EQ("postal", rule.GetPostalCodeNameType()); |
| |
| ASSERT_TRUE(rule.ParseSerializedRule( |
| "{" |
| "\"fmt\":\"\"," |
| "\"require\":\"\"," |
| "\"state_name_type\":\"do_si\"," |
| "\"zip_name_type\":\"zip\"," |
| "\"sub_keys\":\"\"," |
| "\"lang\":\"\"," |
| "\"languages\":\"\"," |
| "\"zip\":\"\"" |
| "}")); |
| EXPECT_TRUE(IsFormatEmpty(rule.GetFormat())); |
| EXPECT_TRUE(rule.GetRequired().empty()); |
| EXPECT_TRUE(rule.GetSubKeys().empty()); |
| EXPECT_TRUE(rule.GetLanguages().empty()); |
| EXPECT_TRUE(rule.GetLanguage().empty()); |
| EXPECT_TRUE(rule.GetPostalCodeFormat().empty()); |
| EXPECT_EQ("do_si", rule.GetAdminAreaNameType()); |
| EXPECT_EQ("zip", rule.GetPostalCodeNameType()); |
| } |
| |
| TEST(RuleTest, ParseEmptyDataDoesNotOverwriteRule) { |
| Rule rule; |
| ASSERT_TRUE(rule.ParseSerializedRule( |
| "{" |
| "\"fmt\":\"%S%Z\"," |
| "\"require\":\"SZ\"," |
| "\"state_name_type\":\"area\"," |
| "\"zip_name_type\":\"postal\"," |
| "\"sub_keys\":\"CA~NY~TX\"," |
| "\"lang\":\"en\"," |
| "\"languages\":\"en~fr\"," |
| "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\"" |
| "}")); |
| |
| Rule copy; |
| copy.CopyFrom(rule); |
| ASSERT_TRUE(copy.ParseSerializedRule("{}")); |
| |
| EXPECT_EQ(rule.GetFormat(), copy.GetFormat()); |
| EXPECT_EQ(rule.GetRequired(), copy.GetRequired()); |
| EXPECT_EQ(rule.GetSubKeys(), copy.GetSubKeys()); |
| EXPECT_EQ(rule.GetLanguages(), copy.GetLanguages()); |
| EXPECT_EQ(rule.GetLanguage(), copy.GetLanguage()); |
| EXPECT_EQ(rule.GetPostalCodeFormat(), copy.GetPostalCodeFormat()); |
| EXPECT_EQ(rule.GetAdminAreaNameType(), |
| copy.GetAdminAreaNameType()); |
| EXPECT_EQ(rule.GetPostalCodeNameType(), |
| copy.GetPostalCodeNameType()); |
| } |
| |
| TEST(RuleTest, ParseFormatWithNewLines) { |
| Rule rule; |
| ASSERT_TRUE( |
| rule.ParseSerializedRule("{\"fmt\":\"%O%n%N%n%A%nAX-%Z %C%nÅLAND\"}")); |
| |
| 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; |
| EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%n%n\"}")); |
| } |
| |
| TEST(RuleTest, FormatTokenWithoutPrefixDoesNotCrash) { |
| Rule rule; |
| ASSERT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"R\"}")); |
| } |
| |
| TEST(RuleTest, ParseDuplicateTokenInFormatDoesNotCrash) { |
| Rule rule; |
| EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%R%R\"}")); |
| } |
| |
| TEST(RuleTest, ParseInvalidFormatFieldsDoesNotCrash) { |
| Rule rule; |
| EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%K%L\"}")); |
| } |
| |
| TEST(RuleTest, PrefixWithoutTokenFormatDoesNotCrash) { |
| Rule rule; |
| EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"%\"}")); |
| } |
| |
| TEST(RuleTest, EmptyStringFormatDoesNotCrash) { |
| Rule rule; |
| EXPECT_TRUE(rule.ParseSerializedRule("{\"fmt\":\"\"}")); |
| } |
| |
| TEST(RuleTest, ParseRequiredFields) { |
| Rule rule; |
| ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"ONAZC\"}")); |
| std::vector<AddressField> expected; |
| expected.push_back(ORGANIZATION); |
| expected.push_back(RECIPIENT); |
| expected.push_back(STREET_ADDRESS); |
| expected.push_back(POSTAL_CODE); |
| expected.push_back(LOCALITY); |
| EXPECT_EQ(expected, rule.GetRequired()); |
| } |
| |
| TEST(RuleTest, ParseEmptyStringRequiredFields) { |
| Rule rule; |
| ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"\"}")); |
| EXPECT_TRUE(rule.GetRequired().empty()); |
| } |
| |
| TEST(RuleTest, ParseInvalidRequiredFields) { |
| Rule rule; |
| ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"garbage\"}")); |
| EXPECT_TRUE(rule.GetRequired().empty()); |
| } |
| |
| TEST(RuleTest, ParseDuplicateRequiredFields) { |
| Rule rule; |
| ASSERT_TRUE(rule.ParseSerializedRule("{\"require\":\"SSS\"}")); |
| EXPECT_EQ(std::vector<AddressField>(3, ADMIN_AREA), rule.GetRequired()); |
| } |
| |
| TEST(RuleTest, ParsesSubKeysCorrectly) { |
| Rule rule; |
| ASSERT_TRUE(rule.ParseSerializedRule("{\"sub_keys\":\"CA~NY~TX\"}")); |
| std::vector<std::string> expected; |
| expected.push_back("CA"); |
| expected.push_back("NY"); |
| expected.push_back("TX"); |
| EXPECT_EQ(expected, rule.GetSubKeys()); |
| } |
| |
| TEST(RuleTest, ParsesLanguageCorrectly) { |
| Rule rule; |
| ASSERT_TRUE(rule.ParseSerializedRule("{\"lang\":\"en\"}")); |
| EXPECT_EQ("en", rule.GetLanguage()); |
| } |
| |
| TEST(RuleTest, ParsesLanguagesCorrectly) { |
| Rule rule; |
| ASSERT_TRUE(rule.ParseSerializedRule("{\"languages\":\"de~fr~it\"}")); |
| std::vector<std::string> expected; |
| expected.push_back("de"); |
| expected.push_back("fr"); |
| expected.push_back("it"); |
| EXPECT_EQ(expected, rule.GetLanguages()); |
| } |
| |
| TEST(RuleTest, ParsesPostalCodeFormatCorrectly) { |
| Rule rule; |
| ASSERT_TRUE(rule.ParseSerializedRule( |
| "{" |
| "\"zip\":\"\\\\d{5}([ \\\\-]\\\\d{4})?\"" |
| "}")); |
| EXPECT_EQ("\\d{5}([ \\-]\\d{4})?", rule.GetPostalCodeFormat()); |
| } |
| |
| TEST(RuleTest, EmptyStringIsNotValid) { |
| Rule rule; |
| EXPECT_FALSE(rule.ParseSerializedRule(std::string())); |
| } |
| |
| TEST(RuleTest, EmptyDictionaryIsValid) { |
| Rule rule; |
| EXPECT_TRUE(rule.ParseSerializedRule("{}")); |
| } |
| |
| TEST(RuleTest, ParseSubKeyTest) { |
| i18n::addressinput::Rule rule; |
| ASSERT_TRUE(rule.ParseSerializedRule( |
| "{ \"sub_keys\": \"FOO~BAR~BAZ\"," |
| " \"sub_names\": \"Foolandia~Bartopolis~Bazmonia\"," |
| " \"sub_lnames\": \"Foolandia2~Bartopolis2~Bazmonia2\" }")); |
| EXPECT_EQ(3U, rule.GetSubKeys().size()); |
| |
| std::string sub_key; |
| EXPECT_TRUE(rule.CanonicalizeSubKey("BAR", false, &sub_key)); |
| EXPECT_EQ("BAR", sub_key); |
| sub_key.clear(); |
| |
| EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis", false, &sub_key)); |
| EXPECT_EQ("BAR", sub_key); |
| sub_key.clear(); |
| |
| // Unlatinize. |
| EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis2", false, &sub_key)); |
| EXPECT_EQ("BAR", sub_key); |
| sub_key.clear(); |
| |
| // Keep input latin. |
| EXPECT_TRUE(rule.CanonicalizeSubKey("Bartopolis2", true, &sub_key)); |
| EXPECT_EQ("Bartopolis2", sub_key); |
| sub_key.clear(); |
| |
| EXPECT_FALSE(rule.CanonicalizeSubKey("Beertopia", false, &sub_key)); |
| EXPECT_EQ("", sub_key); |
| } |
| |
| struct LabelData { |
| LabelData(const std::string& data, const std::string& name_type) |
| : data(data), name_type(name_type) {} |
| |
| ~LabelData() {} |
| |
| std::string data; |
| std::string name_type; |
| }; |
| |
| // Tests for parsing the postal code name. |
| class PostalCodeNameParseTest : public testing::TestWithParam<LabelData> { |
| protected: |
| Rule rule_; |
| }; |
| |
| // Verifies that a postal code name is parsed correctly. |
| TEST_P(PostalCodeNameParseTest, ParsedCorrectly) { |
| ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().data)); |
| EXPECT_EQ(GetParam().name_type, rule_.GetPostalCodeNameType()); |
| } |
| |
| // Test parsing all postal code names. |
| INSTANTIATE_TEST_CASE_P( |
| AllPostalCodeNames, PostalCodeNameParseTest, |
| testing::Values( |
| LabelData("{\"zip_name_type\":\"postal\"}", "postal"), |
| LabelData("{\"zip_name_type\":\"zip\"}", "zip"))); |
| |
| // Tests for parsing the administrative area name. |
| class AdminAreaNameParseTest : public testing::TestWithParam<LabelData> { |
| protected: |
| Rule rule_; |
| }; |
| |
| // Verifies that an administrative area name is parsed correctly. |
| TEST_P(AdminAreaNameParseTest, ParsedCorrectly) { |
| ASSERT_TRUE(rule_.ParseSerializedRule(GetParam().data)); |
| EXPECT_EQ(GetParam().name_type, rule_.GetAdminAreaNameType()); |
| } |
| |
| // Test parsing all administrative area names. |
| INSTANTIATE_TEST_CASE_P( |
| AllAdminAreaNames, AdminAreaNameParseTest, |
| testing::Values( |
| LabelData("{\"state_name_type\":\"area\"}", "area"), |
| LabelData("{\"state_name_type\":\"county\"}", "county"), |
| LabelData("{\"state_name_type\":\"department\"}", "department"), |
| LabelData("{\"state_name_type\":\"district\"}", "district"), |
| LabelData("{\"state_name_type\":\"do_si\"}", "do_si"), |
| LabelData("{\"state_name_type\":\"emirate\"}", "emirate"), |
| LabelData("{\"state_name_type\":\"island\"}", "island"), |
| LabelData("{\"state_name_type\":\"parish\"}", "parish"), |
| LabelData("{\"state_name_type\":\"prefecture\"}", "prefecture"), |
| LabelData("{\"state_name_type\":\"province\"}", "province"), |
| LabelData("{\"state_name_type\":\"state\"}", "state"))); |
| |
| // 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(RuleParseTest, ConsecutiveLinesWithMultipleFields) { |
| const std::vector<std::string>& region_codes = |
| RegionDataConstants::GetRegionCodes(); |
| Rule rule; |
| for (size_t i = 0; i < region_codes.size(); ++i) { |
| const std::string& region_data = |
| RegionDataConstants::GetRegionData(region_codes[i]); |
| SCOPED_TRACE(region_codes[i] + ": " + region_data); |
| |
| ASSERT_TRUE(rule.ParseSerializedRule(region_data)); |
| bool previous_line_has_single_field = true; |
| for (std::vector<std::vector<FormatElement> >::const_iterator |
| line_it = rule.GetFormat().begin(); |
| line_it != rule.GetFormat().end(); |
| ++line_it) { |
| 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->IsField()) { |
| ++num_fields; |
| } |
| } |
| if (num_fields == 0) { |
| continue; |
| } |
| ASSERT_TRUE(num_fields == 1 || previous_line_has_single_field); |
| 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::BuildDisplayLines(). |
| TEST(RuleParseTest, StreetAddressSurroundingElements) { |
| const std::vector<std::string>& region_codes = |
| RegionDataConstants::GetRegionCodes(); |
| Rule rule; |
| for (size_t i = 0; i < region_codes.size(); ++i) { |
| const std::string& region_data = |
| RegionDataConstants::GetRegionData(region_codes[i]); |
| SCOPED_TRACE(region_codes[i] + ": " + region_data); |
| |
| ASSERT_TRUE(rule.ParseSerializedRule(region_data)); |
| 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.IsField() && 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).IsField() && |
| line_it->at(i - 1).literal == " " && |
| !line_it->at(i + 1).IsField() && |
| line_it->at(i + 1).literal == " "; |
| EXPECT_TRUE(surrounded_by_newlines || surrounded_by_spaces); |
| } |
| } |
| } |
| } |
| } |
| |
| } // namespace |
