1 // Copyright 2013 The Chromium Authors. All rights reserved.
2 // Use of this source code is governed by a BSD-style license that can be
3 // found in the LICENSE file.
4 
5 #include <stddef.h>
6 
7 #include <string>
8 
9 #include "base/macros.h"
10 #include "base/strings/string16.h"
11 #include "base/strings/utf_string_conversions.h"
12 #include "base/test/scoped_feature_list.h"
13 #include "components/autofill/core/browser/autofill_type.h"
14 #include "components/autofill/core/browser/data_model/address.h"
15 #include "components/autofill/core/browser/geo/country_names.h"
16 #include "components/autofill/core/common/autofill_features.h"
17 #include "testing/gtest/include/gtest/gtest.h"
18 
19 using base::ASCIIToUTF16;
20 
21 namespace autofill {
22 
23 class AddressTest : public testing::Test,
24                     public testing::WithParamInterface<bool> {
25  public:
AddressTest()26   AddressTest() { CountryNames::SetLocaleString("en-US"); }
27 
StructuredAddresses() const28   bool StructuredAddresses() const { return structured_addresses_enabled_; }
29 
30  private:
SetUp()31   void SetUp() override { InitializeFeatures(); }
32 
InitializeFeatures()33   void InitializeFeatures() {
34     structured_addresses_enabled_ = GetParam();
35     if (structured_addresses_enabled_) {
36       scoped_feature_list_.InitAndEnableFeature(
37           features::kAutofillEnableSupportForMoreStructureInAddresses);
38     } else {
39       scoped_feature_list_.InitAndDisableFeature(
40           features::kAutofillEnableSupportForMoreStructureInAddresses);
41     }
42   }
43 
44   bool structured_addresses_enabled_;
45   base::test::ScopedFeatureList scoped_feature_list_;
46 };
47 
48 // Test that country data can be properly returned as either a country code or a
49 // localized country name.
TEST_P(AddressTest,GetCountry)50 TEST_P(AddressTest, GetCountry) {
51   Address address;
52   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
53 
54   // Make sure that nothing breaks when the country code is missing.
55   base::string16 country =
56       address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
57   EXPECT_EQ(base::string16(), country);
58 
59   address.SetInfo(AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("US"),
60                   "en-US");
61   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
62   EXPECT_EQ(ASCIIToUTF16("United States"), country);
63   country = address.GetInfo(
64       AutofillType(HTML_TYPE_COUNTRY_NAME, HTML_MODE_NONE), "en-US");
65   EXPECT_EQ(ASCIIToUTF16("United States"), country);
66   country = address.GetInfo(
67       AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE), "en-US");
68   EXPECT_EQ(ASCIIToUTF16("US"), country);
69 
70   address.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("CA"));
71   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
72   EXPECT_EQ(ASCIIToUTF16("Canada"), country);
73   country = address.GetInfo(
74       AutofillType(HTML_TYPE_COUNTRY_NAME, HTML_MODE_NONE), "en-US");
75   EXPECT_EQ(ASCIIToUTF16("Canada"), country);
76   country = address.GetInfo(
77       AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE), "en-US");
78   EXPECT_EQ(ASCIIToUTF16("CA"), country);
79 }
80 
81 // Test that country data can be properly returned as either a country code or a
82 // full country name that can even be localized.
TEST_P(AddressTest,SetHtmlCountryCodeTypeWithFullCountryName)83 TEST_P(AddressTest, SetHtmlCountryCodeTypeWithFullCountryName) {
84   Address address;
85   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
86 
87   // Create an autofill type from HTML_TYPE_COUNTRY_CODE.
88   AutofillType autofill_type(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE);
89 
90   // Test that the country value can be set and retrieved if it is not
91   // a country code but a full country name.
92   address.SetInfo(autofill_type, ASCIIToUTF16("Germany"), "en-US");
93   base::string16 actual_country =
94       address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
95   base::string16 actual_country_code = address.GetInfo(
96       AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE), "en-US");
97   EXPECT_EQ(ASCIIToUTF16("Germany"), actual_country);
98   EXPECT_EQ(ASCIIToUTF16("DE"), actual_country_code);
99 
100   // Reset the country and verify that the reset works as expected.
101   address.SetInfo(autofill_type, ASCIIToUTF16(""), "en-US");
102   actual_country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
103   actual_country_code = address.GetInfo(
104       AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE), "en-US");
105   EXPECT_EQ(ASCIIToUTF16(""), actual_country);
106   EXPECT_EQ(ASCIIToUTF16(""), actual_country_code);
107 
108   // Test that the country value can be set and retrieved if it is not
109   // a country code but a full country name with a non-standard locale.
110   address.SetInfo(autofill_type, ASCIIToUTF16("deutschland"), "de");
111   actual_country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
112   actual_country_code = address.GetInfo(
113       AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE), "en-US");
114   EXPECT_EQ(ASCIIToUTF16("Germany"), actual_country);
115   EXPECT_EQ(ASCIIToUTF16("DE"), actual_country_code);
116 
117   // Reset the country.
118   address.SetInfo(autofill_type, ASCIIToUTF16(""), "en-US");
119 
120   // Test that the country is still stored correctly with a supplied
121   // country code.
122   address.SetInfo(autofill_type, ASCIIToUTF16("DE"), "en-US");
123   actual_country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
124   actual_country_code = address.GetInfo(
125       AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE), "en-US");
126   EXPECT_EQ(ASCIIToUTF16("DE"), actual_country_code);
127   EXPECT_EQ(ASCIIToUTF16("Germany"), actual_country);
128 }
129 
130 // Test that we properly detect country codes appropriate for each country.
TEST_P(AddressTest,SetCountry)131 TEST_P(AddressTest, SetCountry) {
132   Address address;
133   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
134 
135   // Test basic conversion.
136   address.SetInfo(AutofillType(ADDRESS_HOME_COUNTRY),
137                   ASCIIToUTF16("United States"), "en-US");
138   base::string16 country =
139       address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
140   EXPECT_EQ(ASCIIToUTF16("US"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
141   EXPECT_EQ(ASCIIToUTF16("United States"), country);
142 
143   // Test basic synonym detection.
144   address.SetInfo(AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("USA"),
145                   "en-US");
146   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
147   EXPECT_EQ(ASCIIToUTF16("US"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
148   EXPECT_EQ(ASCIIToUTF16("United States"), country);
149 
150   // Test case-insensitivity.
151   address.SetInfo(AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("canADA"),
152                   "en-US");
153   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
154   EXPECT_EQ(ASCIIToUTF16("CA"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
155   EXPECT_EQ(ASCIIToUTF16("Canada"), country);
156 
157   // Test country code detection.
158   address.SetInfo(AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("JP"),
159                   "en-US");
160   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
161   EXPECT_EQ(ASCIIToUTF16("JP"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
162   EXPECT_EQ(ASCIIToUTF16("Japan"), country);
163 
164   // Test that we ignore unknown countries.
165   address.SetInfo(AutofillType(ADDRESS_HOME_COUNTRY), ASCIIToUTF16("Unknown"),
166                   "en-US");
167   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
168   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
169   EXPECT_EQ(base::string16(), country);
170 
171   // Test setting the country based on an HTML field type.
172   AutofillType html_type_country_code =
173       AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE);
174   address.SetInfo(html_type_country_code, ASCIIToUTF16("US"), "en-US");
175   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
176   EXPECT_EQ(ASCIIToUTF16("US"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
177   EXPECT_EQ(ASCIIToUTF16("United States"), country);
178 
179   // Test case-insensitivity when setting the country based on an HTML field
180   // type.
181   address.SetInfo(html_type_country_code, ASCIIToUTF16("cA"), "en-US");
182   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
183   EXPECT_EQ(ASCIIToUTF16("CA"), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
184   EXPECT_EQ(ASCIIToUTF16("Canada"), country);
185 
186   // Test setting the country based on invalid data with an HTML field type.
187   address.SetInfo(html_type_country_code, ASCIIToUTF16("unknown"), "en-US");
188   country = address.GetInfo(AutofillType(ADDRESS_HOME_COUNTRY), "en-US");
189   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
190   EXPECT_EQ(base::string16(), country);
191 }
192 
193 // Test setting and getting the new structured address tokens
TEST_P(AddressTest,StructuredAddressTokens)194 TEST_P(AddressTest, StructuredAddressTokens) {
195   // Activate the feature to support the new structured address tokens.
196   base::test::ScopedFeatureList scoped_feature_list;
197   scoped_feature_list.InitAndEnableFeature(
198       features::kAutofillAddressEnhancementVotes);
199   Address address;
200 
201   // Set the address tokens.
202   address.SetRawInfo(ADDRESS_HOME_STREET_NAME,
203                      base::ASCIIToUTF16("StreetName"));
204   address.SetRawInfo(ADDRESS_HOME_HOUSE_NUMBER,
205                      base::ASCIIToUTF16("HouseNumber"));
206   address.SetRawInfo(ADDRESS_HOME_DEPENDENT_STREET_NAME,
207                      base::ASCIIToUTF16("DependentStreetName"));
208   address.SetRawInfo(ADDRESS_HOME_PREMISE_NAME,
209                      base::ASCIIToUTF16("PremiseNmae"));
210   address.SetRawInfo(ADDRESS_HOME_SUBPREMISE, base::ASCIIToUTF16("SubPremise"));
211 
212   // Retrieve the tokens and verify that they are correct.
213   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_NAME),
214             base::ASCIIToUTF16("StreetName"));
215   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_HOUSE_NUMBER),
216             base::ASCIIToUTF16("HouseNumber"));
217   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_DEPENDENT_STREET_NAME),
218             base::ASCIIToUTF16("DependentStreetName"));
219   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_PREMISE_NAME),
220             base::ASCIIToUTF16("PremiseNmae"));
221   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_SUBPREMISE),
222             base::ASCIIToUTF16("SubPremise"));
223 }
224 
225 // Test setting and getting the new structured address tokens
TEST_P(AddressTest,StructuredAddressTokens_ResetOnChangedUnstructuredInformation)226 TEST_P(AddressTest,
227        StructuredAddressTokens_ResetOnChangedUnstructuredInformation) {
228   // Activate the feature to support the new structured address tokens for
229   // voting. The feature to actively support structured addresses must be turned
230   // of.
231   base::test::ScopedFeatureList scoped_feature_list;
232   scoped_feature_list.InitWithFeatures(
233       {features::kAutofillAddressEnhancementVotes},
234       {features::kAutofillEnableSupportForMoreStructureInAddresses});
235   Address address;
236 
237   // Set the address tokens.
238   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS,
239                      base::ASCIIToUTF16("Line1\nLine2"));
240   address.SetRawInfo(ADDRESS_HOME_STREET_NAME,
241                      base::ASCIIToUTF16("StreetName"));
242   address.SetRawInfo(ADDRESS_HOME_HOUSE_NUMBER,
243                      base::ASCIIToUTF16("HouseNumber"));
244   address.SetRawInfo(ADDRESS_HOME_DEPENDENT_STREET_NAME,
245                      base::ASCIIToUTF16("DependentStreetName"));
246   address.SetRawInfo(ADDRESS_HOME_PREMISE_NAME,
247                      base::ASCIIToUTF16("PremiseNmae"));
248   address.SetRawInfo(ADDRESS_HOME_SUBPREMISE, base::ASCIIToUTF16("SubPremise"));
249 
250   // Retrieve the tokens and verify that they are correct.
251   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_LINE1),
252             base::ASCIIToUTF16("Line1"));
253   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_LINE2),
254             base::ASCIIToUTF16("Line2"));
255   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS),
256             base::ASCIIToUTF16("Line1\nLine2"));
257   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_NAME),
258             base::ASCIIToUTF16("StreetName"));
259   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_HOUSE_NUMBER),
260             base::ASCIIToUTF16("HouseNumber"));
261   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_DEPENDENT_STREET_NAME),
262             base::ASCIIToUTF16("DependentStreetName"));
263   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_PREMISE_NAME),
264             base::ASCIIToUTF16("PremiseNmae"));
265   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_SUBPREMISE),
266             base::ASCIIToUTF16("SubPremise"));
267 
268   // Set the unstructured address information to the same values as they already
269   // are.
270   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS,
271                      base::ASCIIToUTF16("Line1\nLine2"));
272   address.SetRawInfo(ADDRESS_HOME_LINE1, base::ASCIIToUTF16("Line1"));
273   address.SetRawInfo(ADDRESS_HOME_LINE2, base::ASCIIToUTF16("Line2"));
274 
275   // Verify that the structured tokens are still set.
276   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_NAME),
277             base::ASCIIToUTF16("StreetName"));
278   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_HOUSE_NUMBER),
279             base::ASCIIToUTF16("HouseNumber"));
280   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_DEPENDENT_STREET_NAME),
281             base::ASCIIToUTF16("DependentStreetName"));
282   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_PREMISE_NAME),
283             base::ASCIIToUTF16("PremiseNmae"));
284   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_SUBPREMISE),
285             base::ASCIIToUTF16("SubPremise"));
286 
287   // Now, change the address by changing HOME_ADDRESS_LINE1 and verify that the
288   // structured tokens are reset.
289   address.SetRawInfo(ADDRESS_HOME_LINE1, base::ASCIIToUTF16("NewLine1"));
290 
291   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_LINE1),
292             base::ASCIIToUTF16("NewLine1"));
293   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_LINE2),
294             base::ASCIIToUTF16("Line2"));
295   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS),
296             base::ASCIIToUTF16("NewLine1\nLine2"));
297   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_NAME), base::string16());
298   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_HOUSE_NUMBER), base::string16());
299   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_DEPENDENT_STREET_NAME),
300             base::string16());
301   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_PREMISE_NAME), base::string16());
302   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_SUBPREMISE), base::string16());
303 
304   // Reset the structured tokens and perform the same step for
305   // HOME_ADDRESS_LINE2.
306   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS,
307                      base::ASCIIToUTF16("Line1\nLine2"));
308   address.SetRawInfo(ADDRESS_HOME_STREET_NAME,
309                      base::ASCIIToUTF16("StreetName"));
310   address.SetRawInfo(ADDRESS_HOME_HOUSE_NUMBER,
311                      base::ASCIIToUTF16("HouseNumber"));
312   address.SetRawInfo(ADDRESS_HOME_DEPENDENT_STREET_NAME,
313                      base::ASCIIToUTF16("DependentStreetName"));
314   address.SetRawInfo(ADDRESS_HOME_PREMISE_NAME,
315                      base::ASCIIToUTF16("PremiseNmae"));
316   address.SetRawInfo(ADDRESS_HOME_SUBPREMISE, base::ASCIIToUTF16("SubPremise"));
317 
318   address.SetRawInfo(ADDRESS_HOME_LINE2, base::ASCIIToUTF16("NewLine2"));
319 
320   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_LINE1),
321             base::ASCIIToUTF16("Line1"));
322   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_LINE2),
323             base::ASCIIToUTF16("NewLine2"));
324   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS),
325             base::ASCIIToUTF16("Line1\nNewLine2"));
326   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_NAME), base::string16());
327   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_HOUSE_NUMBER), base::string16());
328   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_DEPENDENT_STREET_NAME),
329             base::string16());
330   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_PREMISE_NAME), base::string16());
331   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_SUBPREMISE), base::string16());
332 
333   // And once again for ADDRESS_HOME_STREET_ADDRESS.
334   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS,
335                      base::ASCIIToUTF16("Line1\nLine2"));
336   address.SetRawInfo(ADDRESS_HOME_STREET_NAME,
337                      base::ASCIIToUTF16("StreetName"));
338   address.SetRawInfo(ADDRESS_HOME_HOUSE_NUMBER,
339                      base::ASCIIToUTF16("HouseNumber"));
340   address.SetRawInfo(ADDRESS_HOME_DEPENDENT_STREET_NAME,
341                      base::ASCIIToUTF16("DependentStreetName"));
342   address.SetRawInfo(ADDRESS_HOME_PREMISE_NAME,
343                      base::ASCIIToUTF16("PremiseNmae"));
344   address.SetRawInfo(ADDRESS_HOME_SUBPREMISE, base::ASCIIToUTF16("SubPremise"));
345 
346   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS,
347                      base::ASCIIToUTF16("NewLine1\nNewLine2"));
348   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_LINE1),
349             base::ASCIIToUTF16("NewLine1"));
350   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_LINE2),
351             base::ASCIIToUTF16("NewLine2"));
352   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS),
353             base::ASCIIToUTF16("NewLine1\nNewLine2"));
354   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_NAME), base::string16());
355   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_HOUSE_NUMBER), base::string16());
356   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_DEPENDENT_STREET_NAME),
357             base::string16());
358   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_PREMISE_NAME), base::string16());
359   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_SUBPREMISE), base::string16());
360 }
361 
362 // Test that we properly match typed values to stored country data.
TEST_P(AddressTest,IsCountry)363 TEST_P(AddressTest, IsCountry) {
364   Address address;
365   address.SetRawInfo(ADDRESS_HOME_COUNTRY, ASCIIToUTF16("US"));
366 
367   const char* const kValidMatches[] = {"United States", "USA", "US",
368                                        "United states", "us"};
369   for (const char* valid_match : kValidMatches) {
370     SCOPED_TRACE(valid_match);
371     ServerFieldTypeSet matching_types;
372     address.GetMatchingTypes(ASCIIToUTF16(valid_match), "US", &matching_types);
373     ASSERT_EQ(1U, matching_types.size());
374     EXPECT_EQ(ADDRESS_HOME_COUNTRY, *matching_types.begin());
375   }
376 
377   const char* const kInvalidMatches[] = {"United", "Garbage"};
378   for (const char* invalid_match : kInvalidMatches) {
379     ServerFieldTypeSet matching_types;
380     address.GetMatchingTypes(ASCIIToUTF16(invalid_match), "US",
381                              &matching_types);
382     EXPECT_EQ(0U, matching_types.size());
383   }
384 
385   // Make sure that garbage values don't match when the country code is empty.
386   address.SetRawInfo(ADDRESS_HOME_COUNTRY, base::string16());
387   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_COUNTRY));
388   ServerFieldTypeSet matching_types;
389   address.GetMatchingTypes(ASCIIToUTF16("Garbage"), "US", &matching_types);
390   EXPECT_EQ(0U, matching_types.size());
391 }
392 
393 // Verifies that Address::GetInfo() correctly combines address lines.
TEST_P(AddressTest,GetStreetAddress)394 TEST_P(AddressTest, GetStreetAddress) {
395   const AutofillType type = AutofillType(ADDRESS_HOME_STREET_ADDRESS);
396 
397   // Address has no address lines.
398   Address address;
399   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
400   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
401   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
402   EXPECT_EQ(base::string16(), address.GetInfo(type, "en-US"));
403 
404   // Address has only line 1.
405   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
406   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
407   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
408   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
409   EXPECT_EQ(ASCIIToUTF16("123 Example Ave."), address.GetInfo(type, "en-US"));
410 
411   // Address has only line 2.
412   address.SetRawInfo(ADDRESS_HOME_LINE1, base::string16());
413   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt 42."));
414   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
415   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
416   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
417   EXPECT_EQ(ASCIIToUTF16("\nApt 42."), address.GetInfo(type, "en-US"));
418 
419   // Address has lines 1 and 2.
420   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
421   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
422   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
423   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
424   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
425   EXPECT_EQ(ASCIIToUTF16("123 Example Ave.\n"
426                          "Apt. 42"),
427             address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
428   EXPECT_EQ(ASCIIToUTF16("123 Example Ave.\n"
429                          "Apt. 42"),
430             address.GetInfo(type, "en-US"));
431 
432   // A wild third line appears.
433   address.SetRawInfo(ADDRESS_HOME_LINE3, ASCIIToUTF16("Living room couch"));
434   EXPECT_EQ(ASCIIToUTF16("Living room couch"),
435             address.GetRawInfo(ADDRESS_HOME_LINE3));
436   EXPECT_EQ(ASCIIToUTF16("123 Example Ave.\n"
437                          "Apt. 42\n"
438                          "Living room couch"),
439             address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
440 
441   // The second line vanishes.
442   address.SetRawInfo(ADDRESS_HOME_LINE2, base::string16());
443   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
444   EXPECT_TRUE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
445   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
446   EXPECT_EQ(ASCIIToUTF16("123 Example Ave.\n"
447                          "\n"
448                          "Living room couch"),
449             address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
450 }
451 
452 // Verifies that overwriting an address with N lines with one that has fewer
453 // than N lines does not result in an address with blank lines at the end.
TEST_P(AddressTest,GetStreetAddressAfterOverwritingLongAddressWithShorterOne)454 TEST_P(AddressTest, GetStreetAddressAfterOverwritingLongAddressWithShorterOne) {
455   // Start with an address that has two lines.
456   Address address;
457   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
458   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
459 
460   // Now clear out the second address line.
461   address.SetRawInfo(ADDRESS_HOME_LINE2, base::string16());
462   EXPECT_EQ(ASCIIToUTF16("123 Example Ave."),
463             address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
464 
465   // Now clear out the first address line as well.
466   address.SetRawInfo(ADDRESS_HOME_LINE1, base::string16());
467   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
468 }
469 
470 // Verifies that Address::SetRawInfo() is able to split address lines correctly.
TEST_P(AddressTest,SetRawStreetAddress)471 TEST_P(AddressTest, SetRawStreetAddress) {
472   const base::string16 empty_street_address;
473   const base::string16 short_street_address = ASCIIToUTF16("456 Nowhere Ln.");
474   const base::string16 long_street_address = ASCIIToUTF16(
475       "123 Example Ave.\n"
476       "Apt. 42\n"
477       "(The one with the blue door)");
478 
479   Address address;
480   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
481   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
482 
483   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, long_street_address);
484   EXPECT_EQ(ASCIIToUTF16("123 Example Ave."),
485             address.GetRawInfo(ADDRESS_HOME_LINE1));
486   EXPECT_EQ(ASCIIToUTF16("Apt. 42"), address.GetRawInfo(ADDRESS_HOME_LINE2));
487   EXPECT_EQ(long_street_address,
488             address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
489 
490   // A short address should clear out unused address lines.
491   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, short_street_address);
492   EXPECT_EQ(ASCIIToUTF16("456 Nowhere Ln."),
493             address.GetRawInfo(ADDRESS_HOME_LINE1));
494   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
495 
496   // An empty address should clear out all address lines.
497   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, long_street_address);
498   address.SetRawInfo(ADDRESS_HOME_STREET_ADDRESS, empty_street_address);
499   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
500   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
501 }
502 
503 // Street addresses should be set properly.
TEST_P(AddressTest,SetStreetAddress)504 TEST_P(AddressTest, SetStreetAddress) {
505   const base::string16 empty_street_address;
506   const base::string16 multi_line_street_address = ASCIIToUTF16(
507       "789 Fancy Pkwy.\n"
508       "Unit 3.14\n"
509       "Box 9");
510   const base::string16 single_line_street_address =
511       ASCIIToUTF16("123 Main, Apt 7");
512   const AutofillType type = AutofillType(ADDRESS_HOME_STREET_ADDRESS);
513 
514   // Start with a non-empty address.
515   Address address;
516   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
517   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
518   address.SetRawInfo(ADDRESS_HOME_LINE3, ASCIIToUTF16("and a half"));
519   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
520   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
521   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
522 
523   // Attempting to set a multi-line address should succeed.
524   EXPECT_TRUE(address.SetInfo(type, multi_line_street_address, "en-US"));
525   EXPECT_EQ(ASCIIToUTF16("789 Fancy Pkwy."),
526             address.GetRawInfo(ADDRESS_HOME_LINE1));
527   EXPECT_EQ(ASCIIToUTF16("Unit 3.14"), address.GetRawInfo(ADDRESS_HOME_LINE2));
528   EXPECT_EQ(ASCIIToUTF16("Box 9"), address.GetRawInfo(ADDRESS_HOME_LINE3));
529 
530   // Setting a single line street address should clear out subsequent lines.
531   EXPECT_TRUE(address.SetInfo(type, single_line_street_address, "en-US"));
532   EXPECT_EQ(single_line_street_address, address.GetRawInfo(ADDRESS_HOME_LINE1));
533   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
534   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE3));
535 
536   // Attempting to set an empty address should also succeed, and clear out the
537   // previously stored data.
538   EXPECT_TRUE(address.SetInfo(type, multi_line_street_address, "en-US"));
539   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
540   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
541   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE3).empty());
542   EXPECT_TRUE(address.SetInfo(type, empty_street_address, "en-US"));
543   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
544   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
545   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE3));
546 }
547 
548 // Verifies that Address::SetInfio() rejects setting data for
549 // ADDRESS_HOME_STREET_ADDRESS if the data has any interior blank lines.
TEST_P(AddressTest,SetStreetAddressRejectsAddressesWithInteriorBlankLines)550 TEST_P(AddressTest, SetStreetAddressRejectsAddressesWithInteriorBlankLines) {
551   // Start with a non-empty address.
552   Address address;
553   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
554   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
555   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
556   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
557   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS).empty());
558 
559   // Attempting to set an address with interior blank lines should fail, and
560   // clear out the previously stored address.
561   EXPECT_FALSE(address.SetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS),
562                                ASCIIToUTF16("Address line 1\n"
563                                             "\n"
564                                             "Address line 3"),
565                                "en-US"));
566   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
567   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
568   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
569 }
570 
571 // Verifies that Address::SetInfio() rejects setting data for
572 // ADDRESS_HOME_STREET_ADDRESS if the data has any leading blank lines.
TEST_P(AddressTest,SetStreetAddressRejectsAddressesWithLeadingBlankLines)573 TEST_P(AddressTest, SetStreetAddressRejectsAddressesWithLeadingBlankLines) {
574   // Start with a non-empty address.
575   Address address;
576   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
577   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
578   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
579   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
580   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS).empty());
581 
582   // Attempting to set an address with leading blank lines should fail, and
583   // clear out the previously stored address.
584   EXPECT_FALSE(address.SetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS),
585                                ASCIIToUTF16("\n"
586                                             "Address line 2"
587                                             "Address line 3"),
588                                "en-US"));
589   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
590   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
591   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
592 }
593 
594 // Verifies that Address::SetInfio() rejects setting data for
595 // ADDRESS_HOME_STREET_ADDRESS if the data has any trailing blank lines.
TEST_P(AddressTest,SetStreetAddressRejectsAddressesWithTrailingBlankLines)596 TEST_P(AddressTest, SetStreetAddressRejectsAddressesWithTrailingBlankLines) {
597   // Start with a non-empty address.
598   Address address;
599   address.SetRawInfo(ADDRESS_HOME_LINE1, ASCIIToUTF16("123 Example Ave."));
600   address.SetRawInfo(ADDRESS_HOME_LINE2, ASCIIToUTF16("Apt. 42"));
601   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE1).empty());
602   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_LINE2).empty());
603   EXPECT_FALSE(address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS).empty());
604 
605   // Attempting to set an address with leading blank lines should fail, and
606   // clear out the previously stored address.
607   EXPECT_FALSE(address.SetInfo(AutofillType(ADDRESS_HOME_STREET_ADDRESS),
608                                ASCIIToUTF16("Address line 1"
609                                             "Address line 2"
610                                             "\n"),
611                                "en-US"));
612   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE1));
613   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_LINE2));
614   EXPECT_EQ(base::string16(), address.GetRawInfo(ADDRESS_HOME_STREET_ADDRESS));
615 }
616 
617 // Verifies that the merging-related methods for structured addresses are
618 // implemented correctly. This is not a test of the merging logic itself.
TEST_P(AddressTest,TestMergeStructuredAddresses)619 TEST_P(AddressTest, TestMergeStructuredAddresses) {
620   // This test is only applicable for structured addresses.
621   if (!StructuredAddresses())
622     return;
623 
624   Address address1;
625   Address address2;
626 
627   // Two empty addresses are mergeable by default.
628   EXPECT_TRUE(address1.IsStructuredAddressMergeable(address2));
629 
630   // The two zip codes have a is-substring relation and are mergeable.
631   address1.SetRawInfo(ADDRESS_HOME_ZIP, base::UTF8ToUTF16("12345"));
632   address2.SetRawInfo(ADDRESS_HOME_ZIP, base::UTF8ToUTF16("1234"));
633   EXPECT_TRUE(address2.IsStructuredAddressMergeable(address1));
634   EXPECT_TRUE(address1.IsStructuredAddressMergeable(address2));
635 
636   // The merging should maintain the value because address2 is not more
637   // recently used.
638   address1.MergeStructuredAddress(address2,
639                                   /*newer_use_more_recently_used=*/false);
640   EXPECT_EQ(address1.GetRawInfo(ADDRESS_HOME_ZIP), base::UTF8ToUTF16("12345"));
641 
642   // Once it is more recently used, the value from address2 should be copied
643   // into address1.
644   address1.MergeStructuredAddress(address2,
645                                   /*newer_use_more_recently_used=*/true);
646   EXPECT_EQ(address1.GetRawInfo(ADDRESS_HOME_ZIP), base::UTF8ToUTF16("1234"));
647 
648   // With a second incompatible ZIP code the addresses are not mergeable
649   // anymore.
650   Address address3;
651   address3.SetRawInfo(ADDRESS_HOME_ZIP, base::UTF8ToUTF16("67890"));
652   EXPECT_FALSE(address1.IsStructuredAddressMergeable(address3));
653 }
654 
655 // Tests the retrieval of the structured address.
TEST_P(AddressTest,TestGettingTheStructuredAddress)656 TEST_P(AddressTest, TestGettingTheStructuredAddress) {
657   // This test is only applicable for structured addresses.
658   if (!StructuredAddresses())
659     return;
660 
661   // Create the address and set a test value.
662   Address address1;
663   address1.SetRawInfo(ADDRESS_HOME_ZIP, base::UTF8ToUTF16("12345"));
664 
665   // Get the structured address and verify that it has the same test value set.
666   structured_address::Address structured_address =
667       address1.GetStructuredAddress();
668   EXPECT_EQ(structured_address.GetValueForType(ADDRESS_HOME_ZIP),
669             base::UTF8ToUTF16("12345"));
670 }
671 
672 // For structured address, test that the structured information is wiped
673 // correctly when the unstructured street address changes.
TEST_P(AddressTest,ResetStructuredTokens)674 TEST_P(AddressTest, ResetStructuredTokens) {
675   // This test is only applicable for structured addresses.
676   if (!StructuredAddresses())
677     return;
678 
679   Address address;
680   // Set a structured address line and call the finalization routine.
681   address.SetRawInfoWithVerificationStatus(
682       ADDRESS_HOME_STREET_ADDRESS, base::ASCIIToUTF16("Erika-Mann-Str 12"),
683       structured_address::VerificationStatus::kUserVerified);
684   address.FinalizeAfterImport();
685 
686   // Verify that structured tokens have been assigned correctly.
687   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_NAME),
688             base::ASCIIToUTF16("Erika-Mann-Str"));
689   EXPECT_EQ(address.GetVerificationStatus(ADDRESS_HOME_STREET_NAME),
690             structured_address::VerificationStatus::kParsed);
691   ASSERT_EQ(address.GetRawInfo(ADDRESS_HOME_HOUSE_NUMBER),
692             base::ASCIIToUTF16("12"));
693   EXPECT_EQ(address.GetVerificationStatus(ADDRESS_HOME_HOUSE_NUMBER),
694             structured_address::VerificationStatus::kParsed);
695 
696   // Lift the verification status of the house number to be |kObserved|.
697   address.SetRawInfoWithVerificationStatus(
698       ADDRESS_HOME_HOUSE_NUMBER, base::ASCIIToUTF16("12"),
699       structured_address::VerificationStatus::kObserved);
700   EXPECT_EQ(address.GetVerificationStatus(ADDRESS_HOME_HOUSE_NUMBER),
701             structured_address::VerificationStatus::kObserved);
702 
703   // Now, set a new unstructured street address that has the same tokens in a
704   // different order.
705   address.SetRawInfoWithVerificationStatus(
706       ADDRESS_HOME_STREET_ADDRESS, base::ASCIIToUTF16("12 Erika-Mann-Str"),
707       structured_address::VerificationStatus::kUserVerified);
708 
709   // After this operation, the structure should be maintained including the
710   // observed status of the house number.
711   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_NAME),
712             base::ASCIIToUTF16("Erika-Mann-Str"));
713   EXPECT_EQ(address.GetVerificationStatus(ADDRESS_HOME_STREET_NAME),
714             structured_address::VerificationStatus::kParsed);
715   ASSERT_EQ(address.GetRawInfo(ADDRESS_HOME_HOUSE_NUMBER),
716             base::ASCIIToUTF16("12"));
717   EXPECT_EQ(address.GetVerificationStatus(ADDRESS_HOME_HOUSE_NUMBER),
718             structured_address::VerificationStatus::kObserved);
719 
720   // Now set a different street address.
721   address.SetRawInfoWithVerificationStatus(
722       ADDRESS_HOME_STREET_ADDRESS, base::ASCIIToUTF16("Marienplatz"),
723       structured_address::VerificationStatus::kUserVerified);
724 
725   // The set address is not parsable and the this should unset both the street
726   // name and the house number.
727   EXPECT_EQ(address.GetRawInfo(ADDRESS_HOME_STREET_NAME),
728             base::ASCIIToUTF16(""));
729   EXPECT_EQ(address.GetVerificationStatus(ADDRESS_HOME_STREET_NAME),
730             structured_address::VerificationStatus::kNoStatus);
731   ASSERT_EQ(address.GetRawInfo(ADDRESS_HOME_HOUSE_NUMBER),
732             base::ASCIIToUTF16(""));
733   EXPECT_EQ(address.GetVerificationStatus(ADDRESS_HOME_HOUSE_NUMBER),
734             structured_address::VerificationStatus::kNoStatus);
735 }
736 
737 // Runs the suite with the feature
738 // |kAutofillSupportForStructuredStructuredNames| enabled and disabled.
739 // TODO(crbug.com/1130194): Remove parameterized test once structured addresses
740 // are fully launched.
741 INSTANTIATE_TEST_SUITE_P(, AddressTest, testing::Bool());
742 
743 }  // namespace autofill
744