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