OLD | NEW |
| (Empty) |
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 "components/autofill/content/browser/wallet/wallet_address.h" | |
6 | |
7 #include <memory> | |
8 | |
9 #include "base/json/json_reader.h" | |
10 #include "base/logging.h" | |
11 #include "base/strings/utf_string_conversions.h" | |
12 #include "base/values.h" | |
13 #include "components/autofill/content/browser/wallet/wallet_test_util.h" | |
14 #include "components/autofill/core/browser/autofill_profile.h" | |
15 #include "components/autofill/core/browser/autofill_test_utils.h" | |
16 #include "testing/gtest/include/gtest/gtest.h" | |
17 | |
18 using base::ASCIIToUTF16; | |
19 | |
20 namespace { | |
21 | |
22 const char kAddressMissingObjectId[] = | |
23 "{" | |
24 " \"phone_number\":\"phone_number\"," | |
25 " \"postal_address\":" | |
26 " {" | |
27 " \"recipient_name\":\"recipient_name\"," | |
28 " \"address_line\":" | |
29 " [" | |
30 " \"address_line_1\"," | |
31 " \"address_line_2\"" | |
32 " ]," | |
33 " \"locality_name\":\"locality_name\"," | |
34 " \"dependent_locality_name\":\"dependent_locality_name\"," | |
35 " \"administrative_area_name\":\"administrative_area_name\"," | |
36 " \"postal_code_number\":\"postal_code_number\"," | |
37 " \"sorting_code\":\"sorting_code\"," | |
38 " \"country_name_code\":\"US\"," | |
39 " \"language_code\":\"language_code\"" | |
40 " }" | |
41 "}"; | |
42 | |
43 const char kAddressMissingCountryNameCode[] = | |
44 "{" | |
45 " \"id\":\"id\"," | |
46 " \"phone_number\":\"phone_number\"," | |
47 " \"postal_address\":" | |
48 " {" | |
49 " \"recipient_name\":\"recipient_name\"," | |
50 " \"address_line\":" | |
51 " [" | |
52 " \"address_line_1\"," | |
53 " \"address_line_2\"" | |
54 " ]," | |
55 " \"locality_name\":\"locality_name\"," | |
56 " \"dependent_locality_name\":\"dependent_locality_name\"," | |
57 " \"administrative_area_name\":\"administrative_area_name\"," | |
58 " \"postal_code_number\":\"postal_code_number\"," | |
59 " \"sorting_code\":\"sorting_code\"" | |
60 " }" | |
61 "}"; | |
62 | |
63 const char kAddressMissingRecipientName[] = | |
64 "{" | |
65 " \"id\":\"id\"," | |
66 " \"phone_number\":\"phone_number\"," | |
67 " \"postal_address\":" | |
68 " {" | |
69 " \"address_line\":" | |
70 " [" | |
71 " \"address_line_1\"," | |
72 " \"address_line_2\"" | |
73 " ]," | |
74 " \"locality_name\":\"locality_name\"," | |
75 " \"dependent_locality_name\":\"dependent_locality_name\"," | |
76 " \"administrative_area_name\":\"administrative_area_name\"," | |
77 " \"postal_code_number\":\"postal_code_number\"," | |
78 " \"sorting_code\":\"sorting_code\"," | |
79 " \"country_name_code\":\"US\"" | |
80 " }" | |
81 "}"; | |
82 | |
83 const char kAddressMissingPostalCodeNumber[] = | |
84 "{" | |
85 " \"id\":\"id\"," | |
86 " \"phone_number\":\"phone_number\"," | |
87 " \"postal_address\":" | |
88 " {" | |
89 " \"recipient_name\":\"recipient_name\"," | |
90 " \"address_line\":" | |
91 " [" | |
92 " \"address_line_1\"," | |
93 " \"address_line_2\"" | |
94 " ]," | |
95 " \"locality_name\":\"locality_name\"," | |
96 " \"dependent_locality_name\":\"dependent_locality_name\"," | |
97 " \"administrative_area_name\":\"administrative_area_name\"," | |
98 " \"sorting_code\":\"sorting_code\"," | |
99 " \"country_name_code\":\"US\"" | |
100 " }" | |
101 "}"; | |
102 | |
103 const char kAddressMissingLanguageCode[] = | |
104 "{" | |
105 " \"id\":\"id\"," | |
106 " \"phone_number\":\"phone_number\"," | |
107 " \"is_minimal_address\":true," | |
108 " \"postal_address\":" | |
109 " {" | |
110 " \"recipient_name\":\"recipient_name\"," | |
111 " \"address_line\":" | |
112 " [" | |
113 " \"address_line_1\"," | |
114 " \"address_line_2\"" | |
115 " ]," | |
116 " \"locality_name\":\"locality_name\"," | |
117 " \"dependent_locality_name\":\"dependent_locality_name\"," | |
118 " \"administrative_area_name\":\"administrative_area_name\"," | |
119 " \"country_name_code\":\"US\"," | |
120 " \"postal_code_number\":\"postal_code_number\"," | |
121 " \"sorting_code\":\"sorting_code\"" | |
122 " }" | |
123 "}"; | |
124 | |
125 const char kValidAddress[] = | |
126 "{" | |
127 " \"id\":\"id\"," | |
128 " \"phone_number\":\"phone_number\"," | |
129 " \"is_minimal_address\":true," | |
130 " \"postal_address\":" | |
131 " {" | |
132 " \"recipient_name\":\"recipient_name\"," | |
133 " \"address_line\":" | |
134 " [" | |
135 " \"address_line_1\"," | |
136 " \"address_line_2\"" | |
137 " ]," | |
138 " \"locality_name\":\"locality_name\"," | |
139 " \"dependent_locality_name\":\"dependent_locality_name\"," | |
140 " \"administrative_area_name\":\"administrative_area_name\"," | |
141 " \"country_name_code\":\"US\"," | |
142 " \"postal_code_number\":\"postal_code_number\"," | |
143 " \"sorting_code\":\"sorting_code\"," | |
144 " \"language_code\":\"language_code\"" | |
145 " }" | |
146 "}"; | |
147 | |
148 const char kClientAddressMissingCountryCode[] = | |
149 "{" | |
150 " \"name\":\"name\"," | |
151 " \"address1\":\"address1\"," | |
152 " \"address2\":\"address2\"," | |
153 " \"city\":\"city\"," | |
154 " \"state\":\"state\"," | |
155 " \"postal_code\":\"postal_code\"," | |
156 " \"sorting_code\":\"sorting_code\"," | |
157 " \"phone_number\":\"phone_number\"" | |
158 "}"; | |
159 | |
160 const char kClientAddressMissingPostalCode[] = | |
161 "{" | |
162 " \"name\":\"name\"," | |
163 " \"address1\":\"address1\"," | |
164 " \"address2\":\"address2\"," | |
165 " \"city\":\"city\"," | |
166 " \"state\":\"state\"," | |
167 " \"phone_number\":\"phone_number\"," | |
168 " \"country_code\":\"US\"" | |
169 "}"; | |
170 | |
171 const char kClientAddressMissingName[] = | |
172 "{" | |
173 " \"address1\":\"address1\"," | |
174 " \"address2\":\"address2\"," | |
175 " \"city\":\"city\"," | |
176 " \"state\":\"state\"," | |
177 " \"postal_code\":\"postal_code\"," | |
178 " \"sorting_code\":\"sorting_code\"," | |
179 " \"phone_number\":\"phone_number\"," | |
180 " \"country_code\":\"US\"" | |
181 "}"; | |
182 | |
183 const char kClientAddressMissingLanguageCode[] = | |
184 "{" | |
185 " \"name\":\"name\"," | |
186 " \"address1\":\"address1\"," | |
187 " \"address2\":\"address2\"," | |
188 " \"city\":\"city\"," | |
189 " \"dependent_locality_name\":\"district\"," | |
190 " \"state\":\"state\"," | |
191 " \"postal_code\":\"postal_code\"," | |
192 " \"sorting_code\":\"sorting_code\"," | |
193 " \"phone_number\":\"phone_number\"," | |
194 " \"country_code\":\"US\"," | |
195 " \"type\":\"FULL\"" | |
196 "}"; | |
197 | |
198 const char kClientValidAddress[] = | |
199 "{" | |
200 " \"name\":\"name\"," | |
201 " \"address1\":\"address1\"," | |
202 " \"address2\":\"address2\"," | |
203 " \"city\":\"city\"," | |
204 " \"dependent_locality_name\":\"district\"," | |
205 " \"state\":\"state\"," | |
206 " \"postal_code\":\"postal_code\"," | |
207 " \"sorting_code\":\"sorting_code\"," | |
208 " \"phone_number\":\"phone_number\"," | |
209 " \"country_code\":\"US\"," | |
210 " \"type\":\"FULL\"," | |
211 " \"language_code\":\"language_code\"" | |
212 "}"; | |
213 | |
214 } // anonymous namespace | |
215 | |
216 namespace autofill { | |
217 namespace wallet { | |
218 | |
219 class WalletAddressTest : public testing::Test { | |
220 public: | |
221 WalletAddressTest() {} | |
222 protected: | |
223 void SetUpDictionary(const std::string& json) { | |
224 std::unique_ptr<base::Value> value = base::JSONReader::Read(json); | |
225 DCHECK(value.get()); | |
226 DCHECK(value->IsType(base::Value::TYPE_DICTIONARY)); | |
227 dict_.reset(static_cast<base::DictionaryValue*>(value.release())); | |
228 } | |
229 | |
230 std::unique_ptr<const base::DictionaryValue> dict_; | |
231 }; | |
232 | |
233 TEST_F(WalletAddressTest, AddressEqualsIgnoreID) { | |
234 Address address1("US", | |
235 ASCIIToUTF16("recipient_name"), | |
236 StreetAddress("address_line_1", "address_line_2"), | |
237 ASCIIToUTF16("locality_name"), | |
238 ASCIIToUTF16("dependent_locality_name"), | |
239 ASCIIToUTF16("administrative_area_name"), | |
240 ASCIIToUTF16("postal_code_number"), | |
241 ASCIIToUTF16("sorting_code"), | |
242 ASCIIToUTF16("phone_number"), | |
243 "id1", | |
244 "language_code"); | |
245 // Same as address1, only id is different. | |
246 Address address2("US", | |
247 ASCIIToUTF16("recipient_name"), | |
248 StreetAddress("address_line_1", "address_line_2"), | |
249 ASCIIToUTF16("locality_name"), | |
250 ASCIIToUTF16("dependent_locality_name"), | |
251 ASCIIToUTF16("administrative_area_name"), | |
252 ASCIIToUTF16("postal_code_number"), | |
253 ASCIIToUTF16("sorting_code"), | |
254 ASCIIToUTF16("phone_number"), | |
255 "id2", | |
256 "language_code"); | |
257 // Has same id as address1, but name is different. | |
258 Address address3("US", | |
259 ASCIIToUTF16("a_different_name"), | |
260 StreetAddress("address_line_1", "address_line_2"), | |
261 ASCIIToUTF16("locality_name"), | |
262 ASCIIToUTF16("dependent_locality_name"), | |
263 ASCIIToUTF16("administrative_area_name"), | |
264 ASCIIToUTF16("phone_number"), | |
265 ASCIIToUTF16("postal_code_number"), | |
266 ASCIIToUTF16("sorting_code"), | |
267 "id1", | |
268 "language_code"); | |
269 // Same as address1, but no id. | |
270 Address address4("US", | |
271 ASCIIToUTF16("recipient_name"), | |
272 StreetAddress("address_line_1", "address_line_2"), | |
273 ASCIIToUTF16("locality_name"), | |
274 ASCIIToUTF16("dependent_locality_name"), | |
275 ASCIIToUTF16("administrative_area_name"), | |
276 ASCIIToUTF16("postal_code_number"), | |
277 ASCIIToUTF16("sorting_code"), | |
278 ASCIIToUTF16("phone_number"), | |
279 std::string(), | |
280 "language_code"); | |
281 // Same as address1, only language code is different. | |
282 Address address5("US", | |
283 ASCIIToUTF16("recipient_name"), | |
284 StreetAddress("address_line_1", "address_line_2"), | |
285 ASCIIToUTF16("locality_name"), | |
286 ASCIIToUTF16("dependent_locality_name"), | |
287 ASCIIToUTF16("administrative_area_name"), | |
288 ASCIIToUTF16("postal_code_number"), | |
289 ASCIIToUTF16("sorting_code"), | |
290 ASCIIToUTF16("phone_number"), | |
291 "id1", | |
292 "other_language_code"); | |
293 | |
294 // Compare the address has id field to itself. | |
295 EXPECT_EQ(address1, address1); | |
296 EXPECT_TRUE(address1.EqualsIgnoreID(address1)); | |
297 | |
298 // Compare the address has no id field to itself | |
299 EXPECT_EQ(address4, address4); | |
300 EXPECT_TRUE(address4.EqualsIgnoreID(address4)); | |
301 | |
302 // Compare two addresses with different id. | |
303 EXPECT_NE(address1, address2); | |
304 EXPECT_TRUE(address1.EqualsIgnoreID(address2)); | |
305 EXPECT_TRUE(address2.EqualsIgnoreID(address1)); | |
306 | |
307 // Compare two different addresses. | |
308 EXPECT_NE(address1, address3); | |
309 EXPECT_FALSE(address1.EqualsIgnoreID(address3)); | |
310 EXPECT_FALSE(address3.EqualsIgnoreID(address1)); | |
311 | |
312 // Compare two same addresses, one has id, the other doesn't. | |
313 EXPECT_NE(address1, address4); | |
314 EXPECT_TRUE(address1.EqualsIgnoreID(address4)); | |
315 EXPECT_TRUE(address4.EqualsIgnoreID(address1)); | |
316 | |
317 // Compare two addresses with different language code. | |
318 EXPECT_NE(address1, address5); | |
319 EXPECT_TRUE(address1.EqualsIgnoreID(address5)); | |
320 EXPECT_TRUE(address5.EqualsIgnoreID(address1)); | |
321 } | |
322 | |
323 TEST_F(WalletAddressTest, CreateAddressMissingObjectId) { | |
324 SetUpDictionary(kAddressMissingObjectId); | |
325 Address address("US", | |
326 ASCIIToUTF16("recipient_name"), | |
327 StreetAddress("address_line_1", "address_line_2"), | |
328 ASCIIToUTF16("locality_name"), | |
329 ASCIIToUTF16("dependent_locality_name"), | |
330 ASCIIToUTF16("administrative_area_name"), | |
331 ASCIIToUTF16("postal_code_number"), | |
332 ASCIIToUTF16("sorting_code"), | |
333 ASCIIToUTF16("phone_number"), | |
334 std::string(), | |
335 "language_code"); | |
336 EXPECT_EQ(address, *Address::CreateAddress(*dict_)); | |
337 } | |
338 | |
339 TEST_F(WalletAddressTest, CreateAddressWithIDMissingObjectId) { | |
340 SetUpDictionary(kAddressMissingObjectId); | |
341 EXPECT_EQ(NULL, Address::CreateAddressWithID(*dict_).get()); | |
342 } | |
343 | |
344 TEST_F(WalletAddressTest, CreateAddressMissingCountryNameCode) { | |
345 SetUpDictionary(kAddressMissingCountryNameCode); | |
346 EXPECT_EQ(NULL, Address::CreateAddress(*dict_).get()); | |
347 EXPECT_EQ(NULL, Address::CreateAddressWithID(*dict_).get()); | |
348 } | |
349 | |
350 TEST_F(WalletAddressTest, CreateAddressMissingRecipientName) { | |
351 SetUpDictionary(kAddressMissingRecipientName); | |
352 EXPECT_EQ(NULL, Address::CreateAddress(*dict_).get()); | |
353 EXPECT_EQ(NULL, Address::CreateAddressWithID(*dict_).get()); | |
354 } | |
355 | |
356 TEST_F(WalletAddressTest, CreateAddressMissingPostalCodeNumber) { | |
357 SetUpDictionary(kAddressMissingPostalCodeNumber); | |
358 EXPECT_EQ(NULL, Address::CreateAddress(*dict_).get()); | |
359 EXPECT_EQ(NULL, Address::CreateAddressWithID(*dict_).get()); | |
360 } | |
361 | |
362 TEST_F(WalletAddressTest, CreateAddressMissingLanguageCode) { | |
363 SetUpDictionary(kAddressMissingLanguageCode); | |
364 Address address("US", | |
365 ASCIIToUTF16("recipient_name"), | |
366 StreetAddress("address_line_1", "address_line_2"), | |
367 ASCIIToUTF16("locality_name"), | |
368 ASCIIToUTF16("dependent_locality_name"), | |
369 ASCIIToUTF16("administrative_area_name"), | |
370 ASCIIToUTF16("postal_code_number"), | |
371 ASCIIToUTF16("sorting_code"), | |
372 ASCIIToUTF16("phone_number"), | |
373 "id", | |
374 std::string()); | |
375 address.set_is_complete_address(false); | |
376 EXPECT_EQ(address, *Address::CreateAddress(*dict_)); | |
377 EXPECT_EQ(address, *Address::CreateAddressWithID(*dict_)); | |
378 } | |
379 | |
380 TEST_F(WalletAddressTest, CreateAddressWithID) { | |
381 SetUpDictionary(kValidAddress); | |
382 Address address("US", | |
383 ASCIIToUTF16("recipient_name"), | |
384 StreetAddress("address_line_1", "address_line_2"), | |
385 ASCIIToUTF16("locality_name"), | |
386 ASCIIToUTF16("dependent_locality_name"), | |
387 ASCIIToUTF16("administrative_area_name"), | |
388 ASCIIToUTF16("postal_code_number"), | |
389 ASCIIToUTF16("sorting_code"), | |
390 ASCIIToUTF16("phone_number"), | |
391 "id", | |
392 "language_code"); | |
393 address.set_is_complete_address(false); | |
394 EXPECT_EQ(address, *Address::CreateAddress(*dict_)); | |
395 EXPECT_EQ(address, *Address::CreateAddressWithID(*dict_)); | |
396 } | |
397 | |
398 TEST_F(WalletAddressTest, CreateDisplayAddressMissingCountryNameCode) { | |
399 SetUpDictionary(kClientAddressMissingCountryCode); | |
400 EXPECT_EQ(NULL, Address::CreateDisplayAddress(*dict_).get()); | |
401 } | |
402 | |
403 TEST_F(WalletAddressTest, CreateDisplayAddressMissingName) { | |
404 SetUpDictionary(kClientAddressMissingName); | |
405 EXPECT_EQ(NULL, Address::CreateDisplayAddress(*dict_).get()); | |
406 } | |
407 | |
408 TEST_F(WalletAddressTest, CreateDisplayAddressMissingPostalCode) { | |
409 SetUpDictionary(kClientAddressMissingPostalCode); | |
410 EXPECT_EQ(NULL, Address::CreateDisplayAddress(*dict_).get()); | |
411 } | |
412 | |
413 TEST_F(WalletAddressTest, CreateDisplayAddressMissingLanguageCode) { | |
414 SetUpDictionary(kClientAddressMissingLanguageCode); | |
415 Address address("US", | |
416 ASCIIToUTF16("name"), | |
417 StreetAddress("address1", "address2"), | |
418 ASCIIToUTF16("city"), | |
419 ASCIIToUTF16("district"), | |
420 ASCIIToUTF16("state"), | |
421 ASCIIToUTF16("postal_code"), | |
422 ASCIIToUTF16("sorting_code"), | |
423 ASCIIToUTF16("phone_number"), | |
424 std::string(), | |
425 std::string()); | |
426 EXPECT_EQ(address, *Address::CreateDisplayAddress(*dict_)); | |
427 } | |
428 | |
429 TEST_F(WalletAddressTest, CreateDisplayAddress) { | |
430 SetUpDictionary(kClientValidAddress); | |
431 Address address("US", | |
432 ASCIIToUTF16("name"), | |
433 StreetAddress("address1", "address2"), | |
434 ASCIIToUTF16("city"), | |
435 ASCIIToUTF16("district"), | |
436 ASCIIToUTF16("state"), | |
437 ASCIIToUTF16("postal_code"), | |
438 ASCIIToUTF16("sorting_code"), | |
439 ASCIIToUTF16("phone_number"), | |
440 std::string(), | |
441 "language_code"); | |
442 EXPECT_EQ(address, *Address::CreateDisplayAddress(*dict_)); | |
443 } | |
444 | |
445 TEST_F(WalletAddressTest, ToDictionaryWithoutID) { | |
446 base::DictionaryValue expected; | |
447 expected.SetString("country_name_code", | |
448 "US"); | |
449 expected.SetString("recipient_name", | |
450 "recipient_name"); | |
451 expected.SetString("locality_name", | |
452 "locality_name"); | |
453 expected.SetString("dependent_locality_name", | |
454 "dependent_locality_name"); | |
455 expected.SetString("administrative_area_name", | |
456 "administrative_area_name"); | |
457 expected.SetString("postal_code_number", | |
458 "postal_code_number"); | |
459 expected.SetString("sorting_code", | |
460 "sorting_code"); | |
461 expected.SetString("language_code", | |
462 "language_code"); | |
463 base::ListValue* address_lines = new base::ListValue(); | |
464 address_lines->AppendString("address_line_1"); | |
465 address_lines->AppendString("address_line_2"); | |
466 expected.Set("address_line", address_lines); | |
467 | |
468 Address address("US", | |
469 ASCIIToUTF16("recipient_name"), | |
470 StreetAddress("address_line_1", "address_line_2"), | |
471 ASCIIToUTF16("locality_name"), | |
472 ASCIIToUTF16("dependent_locality_name"), | |
473 ASCIIToUTF16("administrative_area_name"), | |
474 ASCIIToUTF16("postal_code_number"), | |
475 ASCIIToUTF16("sorting_code"), | |
476 ASCIIToUTF16("phone_number"), | |
477 std::string(), | |
478 "language_code"); | |
479 | |
480 EXPECT_TRUE(expected.Equals(address.ToDictionaryWithoutID().get())); | |
481 } | |
482 | |
483 TEST_F(WalletAddressTest, ToDictionaryWithID) { | |
484 base::DictionaryValue expected; | |
485 expected.SetString("id", "id"); | |
486 expected.SetString("phone_number", "phone_number"); | |
487 expected.SetString("postal_address.country_name_code", | |
488 "US"); | |
489 expected.SetString("postal_address.recipient_name", | |
490 "recipient_name"); | |
491 expected.SetString("postal_address.locality_name", | |
492 "locality_name"); | |
493 expected.SetString("postal_address.dependent_locality_name", | |
494 "dependent_locality_name"); | |
495 expected.SetString("postal_address.administrative_area_name", | |
496 "administrative_area_name"); | |
497 expected.SetString("postal_address.postal_code_number", | |
498 "postal_code_number"); | |
499 expected.SetString("postal_address.sorting_code", | |
500 "sorting_code"); | |
501 expected.SetString("postal_address.language_code", | |
502 "language_code"); | |
503 base::ListValue* address_lines = new base::ListValue(); | |
504 address_lines->AppendString("address_line_1"); | |
505 address_lines->AppendString("address_line_2"); | |
506 expected.Set("postal_address.address_line", address_lines); | |
507 | |
508 Address address("US", | |
509 ASCIIToUTF16("recipient_name"), | |
510 StreetAddress("address_line_1", "address_line_2"), | |
511 ASCIIToUTF16("locality_name"), | |
512 ASCIIToUTF16("dependent_locality_name"), | |
513 ASCIIToUTF16("administrative_area_name"), | |
514 ASCIIToUTF16("postal_code_number"), | |
515 ASCIIToUTF16("sorting_code"), | |
516 ASCIIToUTF16("phone_number"), | |
517 "id", | |
518 "language_code"); | |
519 | |
520 EXPECT_TRUE(expected.Equals(address.ToDictionaryWithID().get())); | |
521 } | |
522 | |
523 // Verifies that WalletAddress::GetInfo() can correctly return both country | |
524 // codes and localized country names. | |
525 TEST_F(WalletAddressTest, GetCountryInfo) { | |
526 Address address("FR", | |
527 ASCIIToUTF16("recipient_name"), | |
528 StreetAddress("address_line_1", "address_line_2"), | |
529 ASCIIToUTF16("locality_name"), | |
530 ASCIIToUTF16("dependent_locality_name"), | |
531 ASCIIToUTF16("administrative_area_name"), | |
532 ASCIIToUTF16("postal_code_number"), | |
533 ASCIIToUTF16("sorting_code"), | |
534 ASCIIToUTF16("phone_number"), | |
535 "id1", | |
536 "language_code"); | |
537 | |
538 AutofillType type = AutofillType(HTML_TYPE_COUNTRY_CODE, HTML_MODE_NONE); | |
539 EXPECT_EQ(ASCIIToUTF16("FR"), address.GetInfo(type, "en-US")); | |
540 | |
541 type = AutofillType(HTML_TYPE_COUNTRY_NAME, HTML_MODE_NONE); | |
542 EXPECT_EQ(ASCIIToUTF16("France"), address.GetInfo(type, "en-US")); | |
543 | |
544 type = AutofillType(ADDRESS_HOME_COUNTRY); | |
545 EXPECT_EQ(ASCIIToUTF16("France"), address.GetInfo(type, "en-US")); | |
546 } | |
547 | |
548 // Verifies that WalletAddress::GetInfo() can correctly return a concatenated | |
549 // full street address. | |
550 TEST_F(WalletAddressTest, GetStreetAddress) { | |
551 std::vector<base::string16> street_address = StreetAddress( | |
552 "address_line_1", "address_line_2"); | |
553 // Address has both lines 1 and 2. | |
554 Address address1("FR", | |
555 ASCIIToUTF16("recipient_name"), | |
556 street_address, | |
557 ASCIIToUTF16("locality_name"), | |
558 ASCIIToUTF16("dependent_locality_name"), | |
559 ASCIIToUTF16("administrative_area_name"), | |
560 ASCIIToUTF16("postal_code_number"), | |
561 ASCIIToUTF16("sorting_code"), | |
562 ASCIIToUTF16("phone_number"), | |
563 "id1", | |
564 "language_code"); | |
565 AutofillType type = AutofillType(HTML_TYPE_STREET_ADDRESS, HTML_MODE_NONE); | |
566 EXPECT_EQ(ASCIIToUTF16("address_line_1\naddress_line_2"), | |
567 address1.GetInfo(type, "en-US")); | |
568 | |
569 // Address has only line 1. | |
570 street_address.resize(1); | |
571 Address address2("FR", | |
572 ASCIIToUTF16("recipient_name"), | |
573 street_address, | |
574 ASCIIToUTF16("locality_name"), | |
575 ASCIIToUTF16("dependent_locality_name"), | |
576 ASCIIToUTF16("administrative_area_name"), | |
577 ASCIIToUTF16("postal_code_number"), | |
578 ASCIIToUTF16("sorting_code"), | |
579 ASCIIToUTF16("phone_number"), | |
580 "id1", | |
581 "language_code"); | |
582 EXPECT_EQ(ASCIIToUTF16("address_line_1"), address2.GetInfo(type, "en-US")); | |
583 | |
584 // Address has no address lines. | |
585 street_address.clear(); | |
586 Address address3("FR", | |
587 ASCIIToUTF16("recipient_name"), | |
588 street_address, | |
589 ASCIIToUTF16("locality_name"), | |
590 ASCIIToUTF16("dependent_locality_name"), | |
591 ASCIIToUTF16("administrative_area_name"), | |
592 ASCIIToUTF16("postal_code_number"), | |
593 ASCIIToUTF16("sorting_code"), | |
594 ASCIIToUTF16("phone_number"), | |
595 "id1", | |
596 "language_code"); | |
597 EXPECT_EQ(base::string16(), address3.GetInfo(type, "en-US")); | |
598 } | |
599 | |
600 } // namespace wallet | |
601 } // namespace autofill | |
OLD | NEW |