CountryNames: Separate data creation from usage

components/autofill/core/browser/address_unittest.cc

 // Copyright 2013 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include <stddef.h>
 
 #include <string>
 
 #include "base/macros.h"
 #include "base/strings/string16.h"
 #include "base/strings/utf_string_conversions.h"
 #include "components/autofill/core/browser/address.h"
 #include "components/autofill/core/browser/autofill_type.h"
+#include "components/autofill/core/browser/country_names.h"
 #include "testing/gtest/include/gtest/gtest.h"
 
 using base::ASCIIToUTF16;
 
 namespace autofill {
 
+class AddressTest : public testing::Test {
+ public:
+  AddressTest() { CountryNames::SetLocaleString("en-US"); }
+};
+
 // Test that country data can be properly returned as either a country code or a
 // localized country name.
-TEST(AddressTest, GetCountry) {
+TEST_F(AddressTest, GetCountry) {
   Address address;
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
 
   // Make sure that nothing breaks when the country code is missing.
   base::string16 country =
       address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
   EXPECT_EQ(base::string16(), country);
 
   address.SetInfo(
       AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("US"), "en-US");
@@ skipping 11 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("Canada"), country);
   country = address.GetInfo(
       AutofillType(HTML_TYPE_COUNTRY_NAME, HTML_MODE_NONE), "en-US");
   EXPECT_EQ(ASCIIToUTF16("Canada"), country);
   country = address.GetInfo(
       AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE), "en-US");
   EXPECT_EQ(ASCIIToUTF16("CA"), country);
 }
 
 // Test that we properly detect country codes appropriate for each country.
-TEST(AddressTest, SetCountry) {
+TEST_F(AddressTest, SetCountry) {
   Address address;
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
 
   // Test basic conversion.
   address.SetInfo(
       AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("United States"),
       "en-US");
   base::string16 country =
       address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
   EXPECT_EQ(ASCIIToUTF16("US"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
@@ skipping 43 matching lines @@
   EXPECT_EQ(ASCIIToUTF16("Canada"), country);
 
   // Test setting the country based on invalid data with an HTML field type.
   address.SetInfo(html_type_country_code, ASCIIToUTF16("unknown"), "en-US");
   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
   EXPECT_EQ(base::string16(), country);
 }
 
 // Test that we properly match typed values to stored country data.
-TEST(AddressTest, IsCountry) {
+TEST_F(AddressTest, IsCountry) {
   Address address;
   address.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
 
   const char* const kValidMatches[] = {
     "United States",
     "USA",
     "US",
     "United states",
     "us"
   };
@@ skipping 19 matching lines @@
 
   // Make sure that garbage values don't match when the country code is empty.
   address.SetRawInfo(ADDRESS_HOME_COUNTRY, base::string16());
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
   ServerFieldTypeSet matching_types;
   address.GetMatchingTypes(ASCIIToUTF16("Garbage"), "US", &matching_types);
   EXPECT_EQ(0U, matching_types.size());
 }
 
 // Verifies that Address::GetInfo() correctly combines address lines.
-TEST(AddressTest, GetStreetAddress) {
+TEST_F(AddressTest, GetStreetAddress) {
   const AutofillType type = AutofillType(ADDRESS_HOME_STREET_ADDRESS);
 
   // Address has no address lines.
   Address address;
   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
   EXPECT_EQ(base::string16(), address.GetInfo(type, "en-US"));
 
   // Address has only line 1.
@@ skipping 39 matching lines @@
   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
   EXPECT_EQ(ASCIIToUTF16("123 Example Ave.\n"
                          "\n"
                          "Living room couch"),
             address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
 }
 
 // Verifies that overwriting an address with N lines with one that has fewer
 // than N lines does not result in an address with blank lines at the end.
-TEST(AddressTest, GetStreetAddressAfterOverwritingLongAddressWithShorterOne) {
+TEST_F(AddressTest, GetStreetAddressAfterOverwritingLongAddressWithShorterOne) {
   // Start with an address that has two lines.
   Address address;
   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
 
   // Now clear out the second address line.
   address.SetRawInfo(ADDRESS_HOME_LINE2, base::string16());
   EXPECT_EQ(ASCIIToUTF16("123 Example Ave."),
             address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
 
   // Now clear out the first address line as well.
   address.SetRawInfo(ADDRESS_HOME_LINE1, base::string16());
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
 }
 
 // Verifies that Address::SetRawInfo() is able to split address lines correctly.
-TEST(AddressTest, SetRawStreetAddress) {
+TEST_F(AddressTest, SetRawStreetAddress) {
   const base::string16 empty_street_address;
   const base::string16 short_street_address = ASCIIToUTF16("456 Nowhere Ln.");
   const base::string16 long_street_address =
       ASCIIToUTF16("123 Example Ave.\n"
                    "Apt. 42\n"
                    "(The one with the blue door)");
 
   Address address;
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
@@ skipping 12 matching lines @@
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
 
   // An empty address should clear out all address lines.
   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, long_street_address);
   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, empty_street_address);
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
 }
 
 // Street addresses should be set properly.
-TEST(AddressTest, SetStreetAddress) {
+TEST_F(AddressTest, SetStreetAddress) {
   const base::string16 empty_street_address;
   const base::string16 multi_line_street_address =
       ASCIIToUTF16("789 Fancy Pkwy.\n"
                    "Unit 3.14\n"
                    "Box 9");
   const base::string16 single_line_street_address =
       ASCIIToUTF16("123 Main, Apt 7");
   const AutofillType type = AutofillType(ADDRESS_HOME_STREET_ADDRESS);
 
   // Start with a non-empty address.
@@ skipping 25 matching lines @@
   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
   EXPECT_TRUE(address.SetInfo(type, empty_street_address, "en-US"));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE3));
 }
 
 // Verifies that Address::SetInfio() rejects setting data for
 // ADDRESS_HOME_STREET_ADDRESS if the data has any interior blank lines.
-TEST(AddressTest, SetStreetAddressRejectsAddressesWithInteriorBlankLines) {
+TEST_F(AddressTest, SetStreetAddressRejectsAddressesWithInteriorBlankLines) {
   // Start with a non-empty address.
   Address address;
   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS).empty());
 
   // Attempting to set an address with interior blank lines should fail, and
   // clear out the previously stored address.
   EXPECT_FALSE(address.SetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS),
                                ASCIIToUTF16("Address line 1\n"
                                             "\n"
                                             "Address line 3"),
                                "en-US"));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
 }
 
 // Verifies that Address::SetInfio() rejects setting data for
 // ADDRESS_HOME_STREET_ADDRESS if the data has any leading blank lines.
-TEST(AddressTest, SetStreetAddressRejectsAddressesWithLeadingBlankLines) {
+TEST_F(AddressTest, SetStreetAddressRejectsAddressesWithLeadingBlankLines) {
   // Start with a non-empty address.
   Address address;
   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS).empty());
 
   // Attempting to set an address with leading blank lines should fail, and
   // clear out the previously stored address.
   EXPECT_FALSE(address.SetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS),
                                ASCIIToUTF16("\n"
                                             "Address line 2"
                                             "Address line 3"),
                                "en-US"));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
 }
 
 // Verifies that Address::SetInfio() rejects setting data for
 // ADDRESS_HOME_STREET_ADDRESS if the data has any trailing blank lines.
-TEST(AddressTest, SetStreetAddressRejectsAddressesWithTrailingBlankLines) {
+TEST_F(AddressTest, SetStreetAddressRejectsAddressesWithTrailingBlankLines) {
   // Start with a non-empty address.
   Address address;
   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS).empty());
 
   // Attempting to set an address with leading blank lines should fail, and
   // clear out the previously stored address.
   EXPECT_FALSE(address.SetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS),
                                ASCIIToUTF16("Address line 1"
                                             "Address line 2"
                                             "\n"),
                                "en-US"));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
 }
 
 }  // namespace autofill